1// Package main implements a tool to fetch GitHub Copilot models and generate a Catwalk provider configuration.
2package main
3
4import (
5 "context"
6 "encoding/json"
7 "fmt"
8 "io"
9 "net/http"
10 "os"
11 "path/filepath"
12 "regexp"
13 "runtime"
14 "slices"
15 "strings"
16 "time"
17
18 "github.com/charmbracelet/catwalk/pkg/catwalk"
19)
20
21type Response struct {
22 Object string `json:"object"`
23 Data []Model `json:"data"`
24}
25
26type Model struct {
27 ID string `json:"id"`
28 Name string `json:"name"`
29 Version string `json:"version"`
30 Vendor string `json:"vendor"`
31 Preview bool `json:"preview"`
32 ModelPickerEnabled bool `json:"model_picker_enabled"`
33 Capabilities Capability `json:"capabilities"`
34 Policy *Policy `json:"policy,omitempty"`
35}
36
37type Capability struct {
38 Family string `json:"family"`
39 Type string `json:"type"`
40 Tokenizer string `json:"tokenizer"`
41 Limits Limits `json:"limits"`
42 Supports Supports `json:"supports"`
43}
44
45type Limits struct {
46 MaxContextWindowTokens int `json:"max_context_window_tokens,omitempty"`
47 MaxOutputTokens int `json:"max_output_tokens,omitempty"`
48 MaxPromptTokens int `json:"max_prompt_tokens,omitempty"`
49}
50
51type Supports struct {
52 ToolCalls bool `json:"tool_calls,omitempty"`
53 ParallelToolCalls bool `json:"parallel_tool_calls,omitempty"`
54 Vision bool `json:"vision,omitempty"`
55}
56
57type Policy struct {
58 State string `json:"state"`
59 Terms string `json:"terms"`
60}
61
62var versionedModelRegexp = regexp.MustCompile(`-\d{4}-\d{2}-\d{2}$`)
63
64func main() {
65 if err := run(); err != nil {
66 fmt.Fprintf(os.Stderr, "Error: %v\n", err)
67 os.Exit(1)
68 }
69}
70
71func run() error {
72 copilotModels, err := fetchCopilotModels()
73 if err != nil {
74 return err
75 }
76
77 // NOTE(@andreynering): Exclude versioned models and keep only the main version of each.
78 copilotModels = slices.DeleteFunc(copilotModels, func(m Model) bool {
79 return m.ID != m.Version || versionedModelRegexp.MatchString(m.ID) || strings.Contains(m.ID, "embedding")
80 })
81
82 catwalkModels := modelsToCatwalk(copilotModels)
83 slices.SortStableFunc(catwalkModels, func(a, b catwalk.Model) int {
84 return strings.Compare(a.ID, b.ID)
85 })
86
87 provider := catwalk.Provider{
88 ID: catwalk.InferenceProviderCopilot,
89 Name: "GitHub Copilot",
90 Models: catwalkModels,
91 APIEndpoint: "https://api.githubcopilot.com",
92 Type: catwalk.TypeOpenAICompat,
93 DefaultLargeModelID: "claude-sonnet-4.5",
94 DefaultSmallModelID: "claude-haiku-4.5",
95 }
96 data, err := json.MarshalIndent(provider, "", " ")
97 if err != nil {
98 return fmt.Errorf("unable to marshal json: %w", err)
99 }
100 if err := os.WriteFile("internal/providers/configs/copilot.json", data, 0o600); err != nil {
101 return fmt.Errorf("unable to write copilog.json: %w", err)
102 }
103 return nil
104}
105
106func fetchCopilotModels() ([]Model, error) {
107 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
108 defer cancel()
109
110 req, err := http.NewRequestWithContext(
111 ctx,
112 "GET",
113 "https://api.githubcopilot.com/models",
114 nil,
115 )
116 if err != nil {
117 return nil, fmt.Errorf("unable to create request: %w", err)
118 }
119 req.Header.Set("Accept", "application/json")
120 req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", copilotToken()))
121
122 client := &http.Client{}
123 resp, err := client.Do(req)
124 if err != nil {
125 return nil, fmt.Errorf("unable to make http request: %w", err)
126 }
127 defer resp.Body.Close() //nolint:errcheck
128
129 if resp.StatusCode != http.StatusOK {
130 return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
131 }
132
133 bts, err := io.ReadAll(resp.Body)
134 if err != nil {
135 return nil, fmt.Errorf("unable to read response body: %w", err)
136 }
137
138 // for debugging
139 _ = os.MkdirAll("tmp", 0o700)
140 _ = os.WriteFile("tmp/copilot-response.json", bts, 0o600)
141
142 var data Response
143 if err := json.Unmarshal(bts, &data); err != nil {
144 return nil, fmt.Errorf("unable to unmarshal json: %w", err)
145 }
146 return data.Data, nil
147}
148
149func modelsToCatwalk(m []Model) []catwalk.Model {
150 models := make([]catwalk.Model, 0, len(m))
151 for _, model := range m {
152 models = append(models, modelToCatwalk(model))
153 }
154 return models
155}
156
157func modelToCatwalk(m Model) catwalk.Model {
158 return catwalk.Model{
159 ID: m.ID,
160 Name: m.Name,
161 DefaultMaxTokens: int64(m.Capabilities.Limits.MaxOutputTokens),
162 ContextWindow: int64(m.Capabilities.Limits.MaxContextWindowTokens),
163 SupportsImages: m.Capabilities.Supports.Vision,
164 }
165}
166
167func copilotToken() string {
168 if token := os.Getenv("COPILOT_TOKEN"); token != "" {
169 return token
170 }
171 return tokenFromDisk()
172}
173
174func tokenFromDisk() string {
175 data, err := os.ReadFile(tokenFilePath())
176 if err != nil {
177 return ""
178 }
179 var content map[string]struct {
180 User string `json:"user"`
181 OAuthToken string `json:"oauth_token"`
182 GitHubAppID string `json:"githubAppId"`
183 }
184 if err := json.Unmarshal(data, &content); err != nil {
185 return ""
186 }
187 if app, ok := content["github.com:Iv1.b507a08c87ecfe98"]; ok {
188 return app.OAuthToken
189 }
190 return ""
191}
192
193func tokenFilePath() string {
194 switch runtime.GOOS {
195 case "windows":
196 return filepath.Join(os.Getenv("LOCALAPPDATA"), "github-copilot/apps.json")
197 default:
198 return filepath.Join(os.Getenv("HOME"), ".config/github-copilot/apps.json")
199 }
200}