Awesome/awesome-copilot
1
0
Fork 0
mirror of https://github.com/github/awesome-copilot.git synced 2026-02-20 02:15:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix Go cookbook recipes to use correct SDK API

Browse Source 
All 5 Go recipes and their markdown docs used incorrect API patterns
that don't match the real github.com/github/copilot-sdk/go v0.1.23:

- copilot.NewClient() -> copilot.NewClient(nil) (*ClientOptions param)
- client.Start() -> client.Start(ctx) (context.Context required)
- copilot.SessionConfig -> &copilot.SessionConfig (pointer required)
- session.On(func(event copilot.Event)) -> session.On(func(event copilot.SessionEvent))
- Type assertions -> event.Type string check + *event.Data.Content deref
- session.WaitForIdle() -> session.SendAndWait(ctx, ...) (WaitForIdle doesn't exist)
- copilot.SystemMessage -> copilot.SystemMessageConfig

All 5 recipes verified to compile against SDK v0.1.23.
This commit is contained in:
Anthony Shaw
2026-02-11 06:06:37 -08:00
parent 4555fee5d2
commit 5eb7adb376
10 changed files with 246 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
cookbook/copilot-sdk/go/error-handling.md
View File

@@ -18,24 +18,22 @@ You need to handle various error conditions like connection failures, timeouts,
package main package main
import ( import (
"context"
"fmt" "fmt"
"log" "log"
"github.com/github/copilot-sdk/go" copilot "github.com/github/copilot-sdk/go"
) )
func main() { func main() {
client := copilot.NewClient() ctx := context.Background()
client := copilot.NewClient(nil)
if err := client.Start(); err != nil { if err := client.Start(ctx); err != nil {
log.Fatalf("Failed to start client: %v", err) log.Fatalf("Failed to start client: %v", err)
} }
defer func() { defer client.Stop()
if err := client.Stop(); err != nil {
log.Printf("Error stopping client: %v", err)
}
}()
session, err := client.CreateSession(copilot.SessionConfig{ session, err := client.CreateSession(ctx, &copilot.SessionConfig{
Model: "gpt-5", Model: "gpt-5",
}) })
if err != nil { if err != nil {
@@ -43,19 +41,15 @@ func main() {
} }
defer session.Destroy() defer session.Destroy()
responseChan := make(chan string, 1) result, err := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})
session.On(func(event copilot.Event) { if err != nil {
if msg, ok := event.(copilot.AssistantMessageEvent); ok {
responseChan <- msg.Data.Content
}
})
if err := session.Send(copilot.MessageOptions{Prompt: "Hello!"}); err != nil {
log.Printf("Failed to send message: %v", err) log.Printf("Failed to send message: %v", err)
return
} }
response := <-responseChan if result != nil && result.Data.Content != nil {
fmt.Println(response) fmt.Println(*result.Data.Content)
}
} }
``` ```
@@ -63,14 +57,17 @@ func main() {
```go ```go
import ( import (
"context"
"errors" "errors"
"fmt"
"os/exec" "os/exec"
copilot "github.com/github/copilot-sdk/go"
) )
func startClient() error { func startClient(ctx context.Context) error {
client := copilot.NewClient() client := copilot.NewClient(nil)
if err := client.Start(); err != nil { if err := client.Start(ctx); err != nil {
var execErr *exec.Error var execErr *exec.Error
if errors.As(err, &execErr) { if errors.As(err, &execErr) {
return fmt.Errorf("Copilot CLI not found. Please install it first: %w", err) return fmt.Errorf("Copilot CLI not found. Please install it first: %w", err)
@@ -90,48 +87,41 @@ func startClient() error {
```go ```go
import ( import (
"context" "context"
"errors"
"fmt"
"time" "time"
copilot "github.com/github/copilot-sdk/go"
) )
func sendWithTimeout(session *copilot.Session) error { func sendWithTimeout(session *copilot.Session) error {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel() defer cancel()
responseChan := make(chan string, 1) result, err := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Complex question..."})
errChan := make(chan error, 1) if err != nil {
if errors.Is(err, context.DeadlineExceeded) {
session.On(func(event copilot.Event) { return fmt.Errorf("request timed out")
if msg, ok := event.(copilot.AssistantMessageEvent); ok {
responseChan <- msg.Data.Content
} }
})
if err := session.Send(copilot.MessageOptions{Prompt: "Complex question..."}); err != nil {
return err return err
} }
select { if result != nil && result.Data.Content != nil {
case response := <-responseChan: fmt.Println(*result.Data.Content)
fmt.Println(response)
return nil
case err := <-errChan:
return err
case <-ctx.Done():
return fmt.Errorf("request timed out")
} }
return nil
} }
``` ```
## Aborting a request ## Aborting a request
```go ```go
func abortAfterDelay(session *copilot.Session) { func abortAfterDelay(ctx context.Context, session *copilot.Session) {
// Start a request // Start a request (non-blocking send)
session.Send(copilot.MessageOptions{Prompt: "Write a very long story..."}) session.Send(ctx, copilot.MessageOptions{Prompt: "Write a very long story..."})
// Abort it after some condition // Abort it after some condition
time.AfterFunc(5*time.Second, func() { time.AfterFunc(5*time.Second, func() {
if err := session.Abort(); err != nil { if err := session.Abort(ctx); err != nil {
log.Printf("Failed to abort: %v", err) log.Printf("Failed to abort: %v", err)
} }
fmt.Println("Request aborted") fmt.Println("Request aborted")
@@ -143,13 +133,18 @@ func abortAfterDelay(session *copilot.Session) {
```go ```go
import ( import (
"context"
"fmt"
"log"
"os" "os"
"os/signal" "os/signal"
"syscall" "syscall"
copilot "github.com/github/copilot-sdk/go"
) )
func main() { func main() {
client := copilot.NewClient() ctx := context.Background()
client := copilot.NewClient(nil)
// Set up signal handling // Set up signal handling
sigChan := make(chan os.Signal, 1) sigChan := make(chan os.Signal, 1)
@@ -158,15 +153,11 @@ func main() {
go func() { go func() {
<-sigChan <-sigChan
fmt.Println("\nShutting down...") fmt.Println("\nShutting down...")
client.Stop()
if err := client.Stop(); err != nil {
log.Printf("Cleanup errors: %v", err)
}
os.Exit(0) os.Exit(0)
}() }()
if err := client.Start(); err != nil { if err := client.Start(ctx); err != nil {
log.Fatal(err) log.Fatal(err)
} }
@@ -178,14 +169,15 @@ func main() {
```go ```go
func doWork() error { func doWork() error {
client := copilot.NewClient() ctx := context.Background()
client := copilot.NewClient(nil)
if err := client.Start(); err != nil { if err := client.Start(ctx); err != nil {
return fmt.Errorf("failed to start: %w", err) return fmt.Errorf("failed to start: %w", err)
} }
defer client.Stop() defer client.Stop()
session, err := client.CreateSession(copilot.SessionConfig{Model: "gpt-5"}) session, err := client.CreateSession(ctx, &copilot.SessionConfig{Model: "gpt-5"})
if err != nil { if err != nil {
return fmt.Errorf("failed to create session: %w", err) return fmt.Errorf("failed to create session: %w", err)
} }

42
cookbook/copilot-sdk/go/managing-local-files.md
View File

@@ -18,23 +18,26 @@ You have a folder with many files and want to organize them into subfolders base
package main package main
import ( import (
"context"
"fmt" "fmt"
"log" "log"
"os" "os"
"path/filepath" "path/filepath"
"github.com/github/copilot-sdk/go" copilot "github.com/github/copilot-sdk/go"
) )
func main() { func main() {
ctx := context.Background()
// Create and start client // Create and start client
client := copilot.NewClient() client := copilot.NewClient(nil)
if err := client.Start(); err != nil { if err := client.Start(ctx); err != nil {
log.Fatal(err) log.Fatal(err)
} }
defer client.Stop() defer client.Stop()
// Create session // Create session
session, err := client.CreateSession(copilot.SessionConfig{ session, err := client.CreateSession(ctx, &copilot.SessionConfig{
Model: "gpt-5", Model: "gpt-5",
}) })
if err != nil { if err != nil {
@@ -43,14 +46,20 @@ func main() {
defer session.Destroy() defer session.Destroy()
// Event handler // Event handler
session.On(func(event copilot.Event) { session.On(func(event copilot.SessionEvent) {
switch e := event.(type) { switch event.Type {
case copilot.AssistantMessageEvent: case "assistant.message":
fmt.Printf("\nCopilot: %s\n", e.Data.Content) if event.Data.Content != nil {
case copilot.ToolExecutionStartEvent: fmt.Printf("\nCopilot: %s\n", *event.Data.Content)
fmt.Printf(" → Running: %s\n", e.Data.ToolName) }
case copilot.ToolExecutionCompleteEvent: case "tool.execution_start":
fmt.Printf(" ✓ Completed: %s\n", e.Data.ToolName) if event.Data.ToolName != nil {
fmt.Printf(" → Running: %s\n", *event.Data.ToolName)
}
case "tool.execution_complete":
if event.Data.ToolName != nil {
fmt.Printf(" ✓ Completed: %s\n", *event.Data.ToolName)
}
} }
}) })
@@ -69,11 +78,10 @@ Analyze the files in "%s" and organize them into subfolders.
Please confirm before moving any files. Please confirm before moving any files.
`, targetFolder) `, targetFolder)
if err := session.Send(copilot.MessageOptions{Prompt: prompt}); err != nil { _, err = session.SendAndWait(ctx, copilot.MessageOptions{Prompt: prompt})
if err != nil {
log.Fatal(err) log.Fatal(err)
} }
session.WaitForIdle()
} }
``` ```
@@ -116,7 +124,7 @@ Analyze files in "%s" and show me how you would organize them
by file type. DO NOT move any files - just show me the plan. by file type. DO NOT move any files - just show me the plan.
`, targetFolder) `, targetFolder)
session.Send(copilot.MessageOptions{Prompt: prompt}) session.SendAndWait(ctx, copilot.MessageOptions{Prompt: prompt})
``` ```
## Custom grouping with AI analysis ## Custom grouping with AI analysis
@@ -134,7 +142,7 @@ Consider:
Propose folder names that are descriptive and useful. Propose folder names that are descriptive and useful.
`, targetFolder) `, targetFolder)
session.Send(copilot.MessageOptions{Prompt: prompt}) session.SendAndWait(ctx, copilot.MessageOptions{Prompt: prompt})
``` ```
## Safety considerations ## Safety considerations

32
cookbook/copilot-sdk/go/multiple-sessions.md
View File

@@ -18,47 +18,49 @@ You need to run multiple conversations in parallel, each with its own context an
package main package main
import ( import (
"context"
"fmt" "fmt"
"log" "log"
"github.com/github/copilot-sdk/go" copilot "github.com/github/copilot-sdk/go"
) )
func main() { func main() {
client := copilot.NewClient() ctx := context.Background()
client := copilot.NewClient(nil)
if err := client.Start(); err != nil { if err := client.Start(ctx); err != nil {
log.Fatal(err) log.Fatal(err)
} }
defer client.Stop() defer client.Stop()
// Create multiple independent sessions // Create multiple independent sessions
session1, err := client.CreateSession(copilot.SessionConfig{Model: "gpt-5"}) session1, err := client.CreateSession(ctx, &copilot.SessionConfig{Model: "gpt-5"})
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
defer session1.Destroy() defer session1.Destroy()
session2, err := client.CreateSession(copilot.SessionConfig{Model: "gpt-5"}) session2, err := client.CreateSession(ctx, &copilot.SessionConfig{Model: "gpt-5"})
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
defer session2.Destroy() defer session2.Destroy()
session3, err := client.CreateSession(copilot.SessionConfig{Model: "claude-sonnet-4.5"}) session3, err := client.CreateSession(ctx, &copilot.SessionConfig{Model: "claude-sonnet-4.5"})
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
defer session3.Destroy() defer session3.Destroy()
// Each session maintains its own conversation history // Each session maintains its own conversation history
session1.Send(copilot.MessageOptions{Prompt: "You are helping with a Python project"}) session1.Send(ctx, copilot.MessageOptions{Prompt: "You are helping with a Python project"})
session2.Send(copilot.MessageOptions{Prompt: "You are helping with a TypeScript project"}) session2.Send(ctx, copilot.MessageOptions{Prompt: "You are helping with a TypeScript project"})
session3.Send(copilot.MessageOptions{Prompt: "You are helping with a Go project"}) session3.Send(ctx, copilot.MessageOptions{Prompt: "You are helping with a Go project"})
// Follow-up messages stay in their respective contexts // Follow-up messages stay in their respective contexts
session1.Send(copilot.MessageOptions{Prompt: "How do I create a virtual environment?"}) session1.Send(ctx, copilot.MessageOptions{Prompt: "How do I create a virtual environment?"})
session2.Send(copilot.MessageOptions{Prompt: "How do I set up tsconfig?"}) session2.Send(ctx, copilot.MessageOptions{Prompt: "How do I set up tsconfig?"})
session3.Send(copilot.MessageOptions{Prompt: "How do I initialize a module?"}) session3.Send(ctx, copilot.MessageOptions{Prompt: "How do I initialize a module?"})
} }
``` ```
@@ -67,7 +69,7 @@ func main() {
Use custom IDs for easier tracking: Use custom IDs for easier tracking:
```go ```go
session, err := client.CreateSession(copilot.SessionConfig{ session, err := client.CreateSession(ctx, &copilot.SessionConfig{
SessionID: "user-123-chat", SessionID: "user-123-chat",
Model: "gpt-5", Model: "gpt-5",
}) })
@@ -81,7 +83,7 @@ fmt.Println(session.SessionID) // "user-123-chat"
## Listing sessions ## Listing sessions
```go ```go
sessions, err := client.ListSessions() sessions, err := client.ListSessions(ctx)
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
@@ -95,7 +97,7 @@ for _, sessionInfo := range sessions {
```go ```go
// Delete a specific session // Delete a specific session
if err := client.DeleteSession("user-123-chat"); err != nil { if err := client.DeleteSession(ctx, "user-123-chat"); err != nil {
log.Printf("Failed to delete session: %v", err) log.Printf("Failed to delete session: %v", err)
} }
``` ```

31
cookbook/copilot-sdk/go/persisting-sessions.md
View File

@@ -19,22 +19,24 @@ You want users to be able to continue a conversation even after closing and reop
package main package main
import ( import (
"context"
"fmt" "fmt"
"github.com/github/copilot-sdk/go" copilot "github.com/github/copilot-sdk/go"
) )
func main() { func main() {
client := copilot.NewClient() ctx := context.Background()
client.Start() client := copilot.NewClient(nil)
client.Start(ctx)
defer client.Stop() defer client.Stop()
// Create session with a memorable ID // Create session with a memorable ID
session, _ := client.CreateSession(copilot.SessionConfig{ session, _ := client.CreateSession(ctx, &copilot.SessionConfig{
SessionID: "user-123-conversation", SessionID: "user-123-conversation",
Model: "gpt-5", Model: "gpt-5",
}) })
session.Send(copilot.MessageOptions{Prompt: "Let's discuss TypeScript generics"}) session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Let's discuss TypeScript generics"})
// Session ID is preserved // Session ID is preserved
fmt.Println(session.SessionID) fmt.Println(session.SessionID)
@@ -47,15 +49,16 @@ func main() {
### Resuming a session ### Resuming a session
```go ```go
client := copilot.NewClient() ctx := context.Background()
client.Start() client := copilot.NewClient(nil)
client.Start(ctx)
defer client.Stop() defer client.Stop()
// Resume the previous session // Resume the previous session
session, _ := client.ResumeSession("user-123-conversation") session, _ := client.ResumeSession(ctx, "user-123-conversation")
// Previous context is restored // Previous context is restored
session.Send(copilot.MessageOptions{Prompt: "What were we discussing?"}) session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "What were we discussing?"})
session.Destroy() session.Destroy()
``` ```
@@ -63,7 +66,7 @@ session.Destroy()
### Listing available sessions ### Listing available sessions
```go ```go
sessions, _ := client.ListSessions() sessions, _ := client.ListSessions(ctx)
for _, s := range sessions { for _, s := range sessions {
fmt.Println("Session:", s.SessionID) fmt.Println("Session:", s.SessionID)
} }
@@ -73,15 +76,17 @@ for _, s := range sessions {
```go ```go
// Remove session and all its data from disk // Remove session and all its data from disk
client.DeleteSession("user-123-conversation") client.DeleteSession(ctx, "user-123-conversation")
``` ```
### Getting session history ### Getting session history
```go ```go
messages, _ := session.GetMessages() messages, _ := session.GetMessages(ctx)
for _, msg := range messages { for _, msg := range messages {
fmt.Printf("[%s] %v\n", msg.Type, msg.Data) if msg.Data.Content != nil {
fmt.Printf("[%s] %s\n", msg.Type, *msg.Data.Content)
}
} }
``` ```

38
cookbook/copilot-sdk/go/pr-visualization.md
View File

@@ -39,6 +39,7 @@ package main
import ( import (
"bufio" "bufio"
"context"
"flag" "flag"
"fmt" "fmt"
"log" "log"
@@ -46,7 +47,7 @@ import (
"os/exec" "os/exec"
"regexp" "regexp"
"strings" "strings"
"github.com/github/copilot-sdk/go" copilot "github.com/github/copilot-sdk/go"
) )
// ============================================================================ // ============================================================================
@@ -94,6 +95,7 @@ func promptForRepo() string {
// ============================================================================ // ============================================================================
func main() { func main() {
ctx := context.Background()
repoFlag := flag.String("repo", "", "GitHub repository (owner/repo)") repoFlag := flag.String("repo", "", "GitHub repository (owner/repo)")
flag.Parse() flag.Parse()
@@ -126,18 +128,18 @@ func main() {
parts := strings.SplitN(repo, "/", 2) parts := strings.SplitN(repo, "/", 2)
owner, repoName := parts[0], parts[1] owner, repoName := parts[0], parts[1]
// Create Copilot client - no custom tools needed! // Create Copilot client
client := copilot.NewClient(copilot.ClientConfig{LogLevel: "error"}) client := copilot.NewClient(nil)
if err := client.Start(); err != nil { if err := client.Start(ctx); err != nil {
log.Fatal(err) log.Fatal(err)
} }
defer client.Stop() defer client.Stop()
cwd, _ := os.Getwd() cwd, _ := os.Getwd()
session, err := client.CreateSession(copilot.SessionConfig{ session, err := client.CreateSession(ctx, &copilot.SessionConfig{
Model: "gpt-5", Model: "gpt-5",
SystemMessage: copilot.SystemMessage{ SystemMessage: &copilot.SystemMessageConfig{
Content: fmt.Sprintf(` Content: fmt.Sprintf(`
<context> <context>
You are analyzing pull requests for the GitHub repository: %s/%s You are analyzing pull requests for the GitHub repository: %s/%s
@@ -159,12 +161,16 @@ The current working directory is: %s
defer session.Destroy() defer session.Destroy()
// Set up event handling // Set up event handling
session.On(func(event copilot.Event) { session.On(func(event copilot.SessionEvent) {
switch e := event.(type) { switch event.Type {
case copilot.AssistantMessageEvent: case "assistant.message":
fmt.Printf("\n🤖 %s\n\n", e.Data.Content) if event.Data.Content != nil {
case copilot.ToolExecutionStartEvent: fmt.Printf("\n🤖 %s\n\n", *event.Data.Content)
fmt.Printf(" ⚙️ %s\n", e.Data.ToolName) }
case "tool.execution_start":
if event.Data.ToolName != nil {
fmt.Printf(" ⚙️ %s\n", *event.Data.ToolName)
}
} }
}) })
@@ -180,12 +186,10 @@ The current working directory is: %s
Finally, summarize the PR health - average age, oldest PR, and how many might be considered stale. Finally, summarize the PR health - average age, oldest PR, and how many might be considered stale.
`, owner, repoName) `, owner, repoName)
if err := session.Send(copilot.MessageOptions{Prompt: prompt}); err != nil { if _, err := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: prompt}); err != nil {
log.Fatal(err) log.Fatal(err)
} }
session.WaitForIdle()
// Interactive loop // Interactive loop
fmt.Println("\n💡 Ask follow-up questions or type \"exit\" to quit.\n") fmt.Println("\n💡 Ask follow-up questions or type \"exit\" to quit.\n")
fmt.Println("Examples:") fmt.Println("Examples:")
@@ -209,11 +213,9 @@ The current working directory is: %s
break break
} }
if err := session.Send(copilot.MessageOptions{Prompt: input}); err != nil { if _, err := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: input}); err != nil {
log.Printf("Error: %v", err) log.Printf("Error: %v", err)
} }
session.WaitForIdle()
} }
} }
``` ```

31
cookbook/copilot-sdk/go/recipe/error-handling.go
View File

@@ -1,25 +1,23 @@
package main package main
import ( import (
"context"
"fmt" "fmt"
"log" "log"
"github.com/github/copilot-sdk/go" copilot "github.com/github/copilot-sdk/go"
) )
func main() { func main() {
client := copilot.NewClient() ctx := context.Background()
client := copilot.NewClient(nil)
if err := client.Start(); err != nil { if err := client.Start(ctx); err != nil {
log.Fatalf("Failed to start client: %v", err) log.Fatalf("Failed to start client: %v", err)
} }
defer func() { defer client.Stop()
if err := client.Stop(); err != nil {
log.Printf("Error stopping client: %v", err)
}
}()
session, err := client.CreateSession(copilot.SessionConfig{ session, err := client.CreateSession(ctx, &copilot.SessionConfig{
Model: "gpt-5", Model: "gpt-5",
}) })
if err != nil { if err != nil {
@@ -27,18 +25,13 @@ func main() {
} }
defer session.Destroy() defer session.Destroy()
responseChan := make(chan string, 1) result, err := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})
session.On(func(event copilot.Event) { if err != nil {
if msg, ok := event.(copilot.AssistantMessageEvent); ok {
responseChan <- msg.Data.Content
}
})
if err := session.Send(copilot.MessageOptions{Prompt: "Hello!"}); err != nil {
log.Printf("Failed to send message: %v", err) log.Printf("Failed to send message: %v", err)
return return
} }
response := <-responseChan if result != nil && result.Data.Content != nil {
fmt.Println(response) fmt.Println(*result.Data.Content)
}
} }

38
cookbook/copilot-sdk/go/recipe/managing-local-files.go
View File

@@ -1,24 +1,27 @@
package main package main
import ( import (
"context"
"fmt" "fmt"
"log" "log"
"os" "os"
"path/filepath" "path/filepath"
"github.com/github/copilot-sdk/go" copilot "github.com/github/copilot-sdk/go"
) )
func main() { func main() {
ctx := context.Background()
// Create and start client // Create and start client
client := copilot.NewClient() client := copilot.NewClient(nil)
if err := client.Start(); err != nil { if err := client.Start(ctx); err != nil {
log.Fatal(err) log.Fatal(err)
} }
defer client.Stop() defer client.Stop()
// Create session // Create session
session, err := client.CreateSession(copilot.SessionConfig{ session, err := client.CreateSession(ctx, &copilot.SessionConfig{
Model: "gpt-5", Model: "gpt-5",
}) })
if err != nil { if err != nil {
@@ -27,14 +30,20 @@ func main() {
defer session.Destroy() defer session.Destroy()
// Event handler // Event handler
session.On(func(event copilot.Event) { session.On(func(event copilot.SessionEvent) {
switch e := event.(type) { switch event.Type {
case copilot.AssistantMessageEvent: case "assistant.message":
fmt.Printf("\nCopilot: %s\n", e.Data.Content) if event.Data.Content != nil {
case copilot.ToolExecutionStartEvent: fmt.Printf("\nCopilot: %s\n", *event.Data.Content)
fmt.Printf(" → Running: %s\n", e.Data.ToolName) }
case copilot.ToolExecutionCompleteEvent: case "tool.execution_start":
fmt.Printf(" ✓ Completed: %s\n", e.Data.ToolName) if event.Data.ToolName != nil {
fmt.Printf(" → Running: %s\n", *event.Data.ToolName)
}
case "tool.execution_complete":
if event.Data.ToolName != nil {
fmt.Printf(" ✓ Completed: %s\n", *event.Data.ToolName)
}
} }
}) })
@@ -54,9 +63,8 @@ Analyze the files in "%s" and organize them into subfolders.
Please confirm before moving any files. Please confirm before moving any files.
`, targetFolder) `, targetFolder)
if err := session.Send(copilot.MessageOptions{Prompt: prompt}); err != nil { _, err = session.SendAndWait(ctx, copilot.MessageOptions{Prompt: prompt})
if err != nil {
log.Fatal(err) log.Fatal(err)
} }
session.WaitForIdle()
} }

26
cookbook/copilot-sdk/go/recipe/multiple-sessions.go
View File

@@ -1,34 +1,36 @@
package main package main
import ( import (
"context"
"fmt" "fmt"
"log" "log"
"github.com/github/copilot-sdk/go" copilot "github.com/github/copilot-sdk/go"
) )
func main() { func main() {
client := copilot.NewClient() ctx := context.Background()
client := copilot.NewClient(nil)
if err := client.Start(); err != nil { if err := client.Start(ctx); err != nil {
log.Fatal(err) log.Fatal(err)
} }
defer client.Stop() defer client.Stop()
// Create multiple independent sessions // Create multiple independent sessions
session1, err := client.CreateSession(copilot.SessionConfig{Model: "gpt-5"}) session1, err := client.CreateSession(ctx, &copilot.SessionConfig{Model: "gpt-5"})
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
defer session1.Destroy() defer session1.Destroy()
session2, err := client.CreateSession(copilot.SessionConfig{Model: "gpt-5"}) session2, err := client.CreateSession(ctx, &copilot.SessionConfig{Model: "gpt-5"})
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
defer session2.Destroy() defer session2.Destroy()
session3, err := client.CreateSession(copilot.SessionConfig{Model: "claude-sonnet-4.5"}) session3, err := client.CreateSession(ctx, &copilot.SessionConfig{Model: "claude-sonnet-4.5"})
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
@@ -37,16 +39,16 @@ func main() {
fmt.Println("Created 3 independent sessions") fmt.Println("Created 3 independent sessions")
// Each session maintains its own conversation history // Each session maintains its own conversation history
session1.Send(copilot.MessageOptions{Prompt: "You are helping with a Python project"}) session1.Send(ctx, copilot.MessageOptions{Prompt: "You are helping with a Python project"})
session2.Send(copilot.MessageOptions{Prompt: "You are helping with a TypeScript project"}) session2.Send(ctx, copilot.MessageOptions{Prompt: "You are helping with a TypeScript project"})
session3.Send(copilot.MessageOptions{Prompt: "You are helping with a Go project"}) session3.Send(ctx, copilot.MessageOptions{Prompt: "You are helping with a Go project"})
fmt.Println("Sent initial context to all sessions") fmt.Println("Sent initial context to all sessions")
// Follow-up messages stay in their respective contexts // Follow-up messages stay in their respective contexts
session1.Send(copilot.MessageOptions{Prompt: "How do I create a virtual environment?"}) session1.Send(ctx, copilot.MessageOptions{Prompt: "How do I create a virtual environment?"})
session2.Send(copilot.MessageOptions{Prompt: "How do I set up tsconfig?"}) session2.Send(ctx, copilot.MessageOptions{Prompt: "How do I set up tsconfig?"})
session3.Send(copilot.MessageOptions{Prompt: "How do I initialize a module?"}) session3.Send(ctx, copilot.MessageOptions{Prompt: "How do I initialize a module?"})
fmt.Println("Sent follow-up questions to each session") fmt.Println("Sent follow-up questions to each session")
fmt.Println("All sessions will be destroyed on exit") fmt.Println("All sessions will be destroyed on exit")

104
cookbook/copilot-sdk/go/recipe/persisting-sessions.go
View File

@@ -1,68 +1,68 @@
package main package main
import ( import (
"fmt" "context"
"log" "fmt"
"log"
"github.com/github/copilot-sdk/go" copilot "github.com/github/copilot-sdk/go"
) )
func main() { func main() {
client := copilot.NewClient() ctx := context.Background()
if err := client.Start(); err != nil { client := copilot.NewClient(nil)
log.Fatal(err) if err := client.Start(ctx); err != nil {
} log.Fatal(err)
defer client.Stop() }
defer client.Stop()
// Create session with a memorable ID // Create session with a memorable ID
session, err := client.CreateSession(copilot.SessionConfig{ session, err := client.CreateSession(ctx, &copilot.SessionConfig{
SessionID: "user-123-conversation", SessionID: "user-123-conversation",
Model: "gpt-5", Model: "gpt-5",
}) })
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
if err := session.Send(copilot.MessageOptions{Prompt: "Let's discuss TypeScript generics"}); err != nil { _, err = session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Let's discuss TypeScript generics"})
log.Fatal(err) if err != nil {
} log.Fatal(err)
fmt.Printf("Session created: %s\n", session.SessionID) }
fmt.Printf("Session created: %s\n", session.SessionID)
// Destroy session but keep data on disk // Destroy session but keep data on disk
if err := session.Destroy(); err != nil { session.Destroy()
log.Fatal(err) fmt.Println("Session destroyed (state persisted)")
}
fmt.Println("Session destroyed (state persisted)")
// Resume the previous session // Resume the previous session
resumed, err := client.ResumeSession("user-123-conversation") resumed, err := client.ResumeSession(ctx, "user-123-conversation")
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
fmt.Printf("Resumed: %s\n", resumed.SessionID) fmt.Printf("Resumed: %s\n", resumed.SessionID)
if err := resumed.Send(copilot.MessageOptions{Prompt: "What were we discussing?"}); err != nil { _, err = resumed.SendAndWait(ctx, copilot.MessageOptions{Prompt: "What were we discussing?"})
log.Fatal(err) if err != nil {
} log.Fatal(err)
}
// List sessions // List sessions
sessions, err := client.ListSessions() sessions, err := client.ListSessions(ctx)
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
ids := make([]string, 0, len(sessions)) ids := make([]string, 0, len(sessions))
for _, s := range sessions { for _, s := range sessions {
ids = append(ids, s.SessionID) ids = append(ids, s.SessionID)
} }
fmt.Printf("Sessions: %v\n", ids) fmt.Printf("Sessions: %v\n", ids)
// Delete session permanently // Delete session permanently
if err := client.DeleteSession("user-123-conversation"); err != nil { if err := client.DeleteSession(ctx, "user-123-conversation"); err != nil {
log.Fatal(err) log.Fatal(err)
} }
fmt.Println("Session deleted") fmt.Println("Session deleted")
if err := resumed.Destroy(); err != nil { resumed.Destroy()
log.Fatal(err)
}
} }

38
cookbook/copilot-sdk/go/recipe/pr-visualization.go
View File

@@ -2,6 +2,7 @@ package main
import ( import (
"bufio" "bufio"
"context"
"flag" "flag"
"fmt" "fmt"
"log" "log"
@@ -10,7 +11,7 @@ import (
"regexp" "regexp"
"strings" "strings"
"github.com/github/copilot-sdk/go" copilot "github.com/github/copilot-sdk/go"
) )
// ============================================================================ // ============================================================================
@@ -58,6 +59,7 @@ func promptForRepo() string {
// ============================================================================ // ============================================================================
func main() { func main() {
ctx := context.Background()
repoFlag := flag.String("repo", "", "GitHub repository (owner/repo)") repoFlag := flag.String("repo", "", "GitHub repository (owner/repo)")
flag.Parse() flag.Parse()
@@ -90,18 +92,18 @@ func main() {
parts := strings.SplitN(repo, "/", 2) parts := strings.SplitN(repo, "/", 2)
owner, repoName := parts[0], parts[1] owner, repoName := parts[0], parts[1]
// Create Copilot client - no custom tools needed! // Create Copilot client
client := copilot.NewClient(copilot.ClientConfig{LogLevel: "error"}) client := copilot.NewClient(nil)
if err := client.Start(); err != nil { if err := client.Start(ctx); err != nil {
log.Fatal(err) log.Fatal(err)
} }
defer client.Stop() defer client.Stop()
cwd, _ := os.Getwd() cwd, _ := os.Getwd()
session, err := client.CreateSession(copilot.SessionConfig{ session, err := client.CreateSession(ctx, &copilot.SessionConfig{
Model: "gpt-5", Model: "gpt-5",
SystemMessage: copilot.SystemMessage{ SystemMessage: &copilot.SystemMessageConfig{
Content: fmt.Sprintf(` Content: fmt.Sprintf(`
<context> <context>
You are analyzing pull requests for the GitHub repository: %s/%s You are analyzing pull requests for the GitHub repository: %s/%s
@@ -123,12 +125,16 @@ The current working directory is: %s
defer session.Destroy() defer session.Destroy()
// Set up event handling // Set up event handling
session.On(func(event copilot.Event) { session.On(func(event copilot.SessionEvent) {
switch e := event.(type) { switch event.Type {
case copilot.AssistantMessageEvent: case "assistant.message":
fmt.Printf("\n🤖 %s\n\n", e.Data.Content) if event.Data.Content != nil {
case copilot.ToolExecutionStartEvent: fmt.Printf("\n🤖 %s\n\n", *event.Data.Content)
fmt.Printf(" ⚙️ %s\n", e.Data.ToolName) }
case "tool.execution_start":
if event.Data.ToolName != nil {
fmt.Printf(" ⚙️ %s\n", *event.Data.ToolName)
}
} }
}) })
@@ -144,12 +150,10 @@ The current working directory is: %s
Finally, summarize the PR health - average age, oldest PR, and how many might be considered stale. Finally, summarize the PR health - average age, oldest PR, and how many might be considered stale.
`, owner, repoName) `, owner, repoName)
if err := session.Send(copilot.MessageOptions{Prompt: prompt}); err != nil { if _, err := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: prompt}); err != nil {
log.Fatal(err) log.Fatal(err)
} }
session.WaitForIdle()
// Interactive loop // Interactive loop
fmt.Println("\n💡 Ask follow-up questions or type \"exit\" to quit.\n") fmt.Println("\n💡 Ask follow-up questions or type \"exit\" to quit.\n")
fmt.Println("Examples:") fmt.Println("Examples:")
@@ -173,10 +177,8 @@ The current working directory is: %s
break break
} }
if err := session.Send(copilot.MessageOptions{Prompt: input}); err != nil { if _, err := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: input}); err != nil {
log.Printf("Error: %v", err) log.Printf("Error: %v", err)
} }
session.WaitForIdle()
} }
} }