@nomomon/ai-sdk-provider-github-copilot 0.1.0 → 0.1.1

package/README.md

@@ -1,6 +1,15 @@
 # AI SDK Provider for GitHub Copilot
 
-Vercel AI SDK community provider for GitHub Copilot - use `streamText`, `generateText`, and related AI SDK APIs with GitHub Copilot as the backend model.
+[![Tests](https://img.shields.io/github/actions/workflow/status/nomomon/ai-sdk-provider-github-copilot/test.yml?branch=main&label=tests)](https://github.com/nomomon/ai-sdk-provider-github-copilot/actions)
+[![codecov](https://codecov.io/gh/nomomon/ai-sdk-provider-github-copilot/graph/badge.svg)](https://codecov.io/gh/nomomon/ai-sdk-provider-github-copilot)
+[![GitHub Packages](https://img.shields.io/badge/GitHub-Packages-blue?logo=github)](https://github.com/nomomon/ai-sdk-provider-github-copilot/pkgs/npm/ai-sdk-provider-github-copilot)
+[![License](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+[![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
+[![Fully AI Generated](https://img.shields.io/badge/fully-AI%20generated-purple?logo=openai)](https://github.com/nomomon/ai-sdk-provider-github-copilot)
+
+Vercel AI SDK community provider for GitHub Copilot — use `streamText`, `generateText`, and related AI SDK APIs with GitHub Copilot as the backend model.
+
+---
 
 ## Installation
 
@@ -48,13 +57,7 @@ for await (const chunk of result.textStream) {
 
 ## Models
 
-Use model IDs available via Copilot CLI, for example:
-
-- `gpt-5` - GPT-5 (when available)
-- `claude-sonnet-4.5` - Claude Sonnet
-- `claude-opus-4` - Claude Opus
-
-Run `copilot models` to list available models in your environment.
+Use model IDs available via Copilot CLI. Run `copilot -i /models` to list available models in your environment.
 
 ## Configuration
 
@@ -79,7 +82,7 @@ const model = githubCopilot("gpt-5", {
 
 ### Custom tools
 
-Pass tools via provider settings using Copilot's `defineTool`:
+Pass tools via provider settings using Copilot's `defineTool`. Tool support varies by model; verify with Copilot CLI or documentation.
 
 ```typescript
 import { defineTool } from "@github/copilot-sdk";
@@ -101,6 +104,10 @@ const model = githubCopilot("gpt-5", {
 });
 ```
 
+## Development
+
+Tests live in `tests/` (not colocated with source) to keep the published `src/` tree clean and to exclude test files from the build. Each source module has a corresponding `tests/*.test.ts` file. Run `npm test` or `npm run test:coverage` for coverage with thresholds.
+
 ## Limitations
 
 - **Requires Copilot CLI** - Must be installed and authenticated
@@ -109,6 +116,7 @@ const model = githubCopilot("gpt-5", {
 - **Unsupported parameters** - `temperature`, `maxTokens`, `topP`, etc. are not supported by the Copilot CLI and will be ignored (warnings emitted)
 - **Structured outputs** - Native JSON schema support may be limited; consider prompt engineering for structured responses
 - **Session-based** - Each generate/stream creates a new session; no built-in multi-session continuity across separate AI SDK calls
+- **Model capabilities** - Tools, reasoning, and other features may vary by model; capabilities are determined by Copilot CLI
 
 ## Disclaimer
 
@@ -120,4 +128,4 @@ const model = githubCopilot("gpt-5", {
 
 ## License
 
-MIT
+[MIT](LICENSE)

package/dist/index.cjs

@@ -42,7 +42,7 @@ function isAbortError(error) {
   }
   return false;
 }
-function handleCopilotError(error, _context) {
+function handleCopilotError(error) {
   if (isAbortError(error)) {
     throw error;
   }
@@ -57,9 +57,220 @@ function handleCopilotError(error, _context) {
   });
 }
 
-// src/convert-to-copilot-messages.ts
+// src/conversion/map-copilot-finish-reason.ts
+function mapCopilotFinishReason() {
+  return {
+    unified: "stop",
+    raw: void 0
+  };
+}
+
+// src/conversion/usage.ts
+function createEmptyUsage() {
+  return {
+    inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+    outputTokens: { total: 0, text: void 0, reasoning: void 0 },
+    raw: void 0
+  };
+}
+function convertCopilotUsage(event) {
+  const inputTokens = event.inputTokens ?? 0;
+  const outputTokens = event.outputTokens ?? 0;
+  const cacheRead = event.cacheReadTokens ?? 0;
+  const cacheWrite = event.cacheWriteTokens ?? 0;
+  return {
+    inputTokens: {
+      total: inputTokens + cacheRead + cacheWrite,
+      noCache: inputTokens,
+      cacheRead,
+      cacheWrite
+    },
+    outputTokens: {
+      total: outputTokens,
+      text: outputTokens,
+      reasoning: void 0
+    },
+    raw: event
+  };
+}
+function createStreamEventHandler(params) {
+  const { controller, session } = params;
+  let textPartId;
+  let usage = createEmptyUsage();
+  const toolStates = /* @__PURE__ */ new Map();
+  const finishStream = () => {
+    if (textPartId) {
+      controller.enqueue({ type: "text-end", id: textPartId });
+    }
+    controller.enqueue({
+      type: "finish",
+      finishReason: mapCopilotFinishReason(),
+      usage
+    });
+    controller.close();
+    void session.destroy();
+  };
+  const handleError = (message) => {
+    controller.enqueue({
+      type: "error",
+      error: new Error(message)
+    });
+    controller.close();
+    void session.destroy();
+  };
+  return (event) => {
+    switch (event.type) {
+      case "assistant.message_delta": {
+        const delta = event.data.deltaContent;
+        if (delta) {
+          if (!textPartId) {
+            textPartId = providerUtils.generateId();
+            controller.enqueue({ type: "text-start", id: textPartId });
+          }
+          controller.enqueue({
+            type: "text-delta",
+            id: textPartId,
+            delta
+          });
+        }
+        break;
+      }
+      case "assistant.reasoning_delta": {
+        const delta = event.data.deltaContent;
+        if (delta) {
+          const reasoningId = providerUtils.generateId();
+          controller.enqueue({ type: "reasoning-start", id: reasoningId });
+          controller.enqueue({
+            type: "reasoning-delta",
+            id: reasoningId,
+            delta
+          });
+          controller.enqueue({ type: "reasoning-end", id: reasoningId });
+        }
+        break;
+      }
+      case "assistant.message": {
+        const { content, toolRequests } = event.data;
+        if (content && !textPartId) {
+          textPartId = providerUtils.generateId();
+          controller.enqueue({ type: "text-start", id: textPartId });
+          controller.enqueue({
+            type: "text-delta",
+            id: textPartId,
+            delta: content
+          });
+          controller.enqueue({ type: "text-end", id: textPartId });
+        }
+        if (toolRequests?.length) {
+          for (const tr of toolRequests) {
+            const toolId = tr.toolCallId;
+            let state = toolStates.get(toolId);
+            if (!state) {
+              state = {
+                name: tr.name,
+                inputStarted: false,
+                callEmitted: false
+              };
+              toolStates.set(toolId, state);
+            }
+            if (!state.inputStarted) {
+              controller.enqueue({
+                type: "tool-input-start",
+                id: toolId,
+                toolName: tr.name,
+                providerExecuted: true,
+                dynamic: true
+              });
+              state.inputStarted = true;
+            }
+            const args = tr.arguments ?? {};
+            controller.enqueue({
+              type: "tool-input-delta",
+              id: toolId,
+              delta: JSON.stringify(args)
+            });
+            controller.enqueue({ type: "tool-input-end", id: toolId });
+            if (!state.callEmitted) {
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: toolId,
+                toolName: tr.name,
+                input: typeof args === "string" ? args : JSON.stringify(args),
+                providerExecuted: true,
+                dynamic: true
+              });
+              state.callEmitted = true;
+            }
+          }
+        }
+        break;
+      }
+      case "tool.execution_start": {
+        const { toolCallId, toolName } = event.data;
+        let state = toolStates.get(toolCallId);
+        if (!state) {
+          state = {
+            name: toolName,
+            inputStarted: true,
+            callEmitted: false
+          };
+          toolStates.set(toolCallId, state);
+        }
+        if (!state.callEmitted) {
+          controller.enqueue({
+            type: "tool-input-start",
+            id: toolCallId,
+            toolName,
+            providerExecuted: true,
+            dynamic: true
+          });
+          controller.enqueue({ type: "tool-input-end", id: toolCallId });
+          controller.enqueue({
+            type: "tool-call",
+            toolCallId,
+            toolName,
+            input: "{}",
+            providerExecuted: true,
+            dynamic: true
+          });
+          state.callEmitted = true;
+        }
+        break;
+      }
+      case "tool.execution_complete": {
+        const { toolCallId, success, result, error } = event.data;
+        const toolNameStr = toolStates.get(toolCallId)?.name ?? "unknown";
+        const resultContent = success && result?.content ? result.content : error?.message ?? "Tool execution failed";
+        controller.enqueue({
+          type: "tool-result",
+          toolCallId,
+          toolName: toolNameStr,
+          result: resultContent,
+          isError: !success,
+          dynamic: true
+        });
+        break;
+      }
+      case "assistant.usage": {
+        usage = convertCopilotUsage(event.data);
+        break;
+      }
+      case "session.idle":
+        finishStream();
+        break;
+      case "session.error":
+        handleError(event.data.message ?? "Session error");
+        break;
+    }
+  };
+}
+
+// src/conversion/convert-to-copilot-messages.ts
 var IMAGE_URL_WARNING = "Image URLs are not supported by this provider; supply file paths as attachments.";
 var IMAGE_BASE64_WARNING = "Base64/image data URLs require file paths. Write to temp file and pass path, or use attachments with path.";
+function isImagePart(part) {
+  return part.type === "image";
+}
 function convertToCopilotMessages(prompt) {
   const messages = [];
   const warnings = [];
@@ -95,7 +306,7 @@ function convertToCopilotMessages(prompt) {
               } else if (fileInfo.warning) {
                 warnings.push(fileInfo.warning);
               }
-            } else if (part.type === "image") {
+            } else if (isImagePart(part)) {
               warnings.push(IMAGE_BASE64_WARNING);
             }
           }
@@ -181,41 +392,50 @@ function extractFileAttachment(part) {
   return {};
 }
 
-// src/map-copilot-finish-reason.ts
-function mapCopilotFinishReason() {
+// src/model/session-setup.ts
+async function prepareSession(input) {
+  const {
+    prompt,
+    options,
+    streaming,
+    buildSessionConfig,
+    generateWarnings,
+    getClient,
+    systemMessageFromSettings
+  } = input;
+  const {
+    prompt: promptText,
+    systemMessage,
+    attachments,
+    warnings: msgWarnings
+  } = convertToCopilotMessages(prompt);
+  const warnings = [
+    ...generateWarnings(options),
+    ...msgWarnings?.map((m) => ({ type: "other", message: m })) ?? []
+  ];
+  const client = getClient();
+  if (client.getState() !== "connected") {
+    await client.start();
+  }
+  const session = await client.createSession({
+    ...buildSessionConfig(streaming),
+    systemMessage: systemMessage ? { mode: "append", content: systemMessage } : systemMessageFromSettings
+  });
   return {
-    unified: "stop",
-    raw: void 0
+    prompt: promptText,
+    attachments,
+    warnings,
+    session
   };
 }
 
-// src/github-copilot-language-model.ts
-function createEmptyUsage() {
-  return {
-    inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
-    outputTokens: { total: 0, text: void 0, reasoning: void 0 },
-    raw: void 0
-  };
-}
-function convertCopilotUsage(event) {
-  const inputTokens = event.inputTokens ?? 0;
-  const outputTokens = event.outputTokens ?? 0;
-  const cacheRead = event.cacheReadTokens ?? 0;
-  const cacheWrite = 0;
-  return {
-    inputTokens: {
-      total: inputTokens + cacheRead + cacheWrite,
-      noCache: inputTokens,
-      cacheRead,
-      cacheWrite
-    },
-    outputTokens: {
-      total: outputTokens,
-      text: outputTokens,
-      reasoning: void 0
-    },
-    raw: event
+// src/model/github-copilot-language-model.ts
+var SEND_AND_WAIT_TIMEOUT_MS = 6e4;
+function addAbortListener(signal, onAbort) {
+  if (!signal) return () => {
   };
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => signal.removeEventListener("abort", onAbort);
 }
 var GitHubCopilotLanguageModel = class {
   specificationVersion = "v3";
@@ -267,34 +487,27 @@ var GitHubCopilotLanguageModel = class {
     }
     return warnings;
   }
-  async doGenerate(options) {
-    const {
-      prompt,
-      systemMessage,
-      attachments,
-      warnings: msgWarnings
-    } = convertToCopilotMessages(options.prompt);
-    const warnings = [
-      ...this.generateWarnings(options),
-      ...msgWarnings?.map((m) => ({ type: "other", message: m })) ?? []
-    ];
-    const client = this.getClient();
-    if (client.getState() !== "connected") {
-      await client.start();
-    }
-    const session = await client.createSession({
-      ...this.buildSessionConfig(false),
-      systemMessage: systemMessage ? { mode: "append", content: systemMessage } : this.settings.systemMessage
+  async prepareSessionForCall(options, streaming) {
+    return prepareSession({
+      prompt: options.prompt,
+      options,
+      streaming,
+      buildSessionConfig: (s) => this.buildSessionConfig(s),
+      generateWarnings: (o) => this.generateWarnings(o),
+      getClient: this.getClient,
+      systemMessageFromSettings: this.settings.systemMessage
     });
-    let abortListener;
-    if (options.abortSignal) {
-      abortListener = () => session.abort();
-      options.abortSignal.addEventListener("abort", abortListener, { once: true });
-    }
+  }
+  async doGenerate(options) {
+    const { prompt, attachments, warnings, session } = await this.prepareSessionForCall(
+      options,
+      false
+    );
+    const removeAbortListener = addAbortListener(options.abortSignal, () => session.abort());
     try {
       const result = await session.sendAndWait(
         { prompt, attachments },
-        options.abortSignal?.aborted ? 0 : 6e4
+        options.abortSignal?.aborted ? 0 : SEND_AND_WAIT_TIMEOUT_MS
       );
       const content = [];
       const text = result?.data?.content ?? "";
@@ -323,12 +536,10 @@ var GitHubCopilotLanguageModel = class {
       if (isAbortError(error)) {
         throw options.abortSignal?.aborted ? options.abortSignal.reason : error;
       }
-      handleCopilotError(error, { promptExcerpt: prompt.substring(0, 200) });
-      return void 0;
+      handleCopilotError(error);
+      throw new Error("Unreachable: handleCopilotError always throws");
     } finally {
-      if (options.abortSignal && abortListener) {
-        options.abortSignal.removeEventListener("abort", abortListener);
-      }
+      removeAbortListener();
       try {
         await session.destroy();
       } catch {
@@ -336,196 +547,27 @@ var GitHubCopilotLanguageModel = class {
     }
   }
   async doStream(options) {
-    const {
-      prompt,
-      systemMessage,
-      attachments,
-      warnings: msgWarnings
-    } = convertToCopilotMessages(options.prompt);
-    const warnings = [
-      ...this.generateWarnings(options),
-      ...msgWarnings?.map((m) => ({ type: "other", message: m })) ?? []
-    ];
-    const client = this.getClient();
-    if (client.getState() !== "connected") {
-      await client.start();
-    }
-    const session = await client.createSession({
-      ...this.buildSessionConfig(true),
-      systemMessage: systemMessage ? { mode: "append", content: systemMessage } : this.settings.systemMessage
-    });
+    const { prompt, attachments, warnings, session } = await this.prepareSessionForCall(
+      options,
+      true
+    );
     const abortController = new AbortController();
-    let abortListener;
     if (options.abortSignal?.aborted) {
       abortController.abort(options.abortSignal.reason);
-    } else if (options.abortSignal) {
-      abortListener = () => {
-        session.abort();
-        abortController.abort(options.abortSignal?.reason);
-      };
-      options.abortSignal.addEventListener("abort", abortListener, { once: true });
     }
+    const removeAbortListener = addAbortListener(options.abortSignal, () => {
+      session.abort();
+      abortController.abort(options.abortSignal?.reason);
+    });
     const stream = new ReadableStream({
       start: async (controller) => {
-        let textPartId;
-        let usage = createEmptyUsage();
-        const toolStates = /* @__PURE__ */ new Map();
         try {
           controller.enqueue({ type: "stream-start", warnings });
-          session.on((event) => {
-            if (event.type === "assistant.message_delta") {
-              const delta = event.data?.deltaContent;
-              if (delta) {
-                if (!textPartId) {
-                  textPartId = providerUtils.generateId();
-                  controller.enqueue({ type: "text-start", id: textPartId });
-                }
-                controller.enqueue({
-                  type: "text-delta",
-                  id: textPartId,
-                  delta
-                });
-              }
-            } else if (event.type === "assistant.reasoning_delta") {
-              const delta = event.data?.deltaContent;
-              if (delta) {
-                const reasoningId = providerUtils.generateId();
-                controller.enqueue({ type: "reasoning-start", id: reasoningId });
-                controller.enqueue({
-                  type: "reasoning-delta",
-                  id: reasoningId,
-                  delta
-                });
-                controller.enqueue({ type: "reasoning-end", id: reasoningId });
-              }
-            } else if (event.type === "assistant.message") {
-              const data = event.data;
-              if (data?.content && !textPartId) {
-                textPartId = providerUtils.generateId();
-                controller.enqueue({ type: "text-start", id: textPartId });
-                controller.enqueue({
-                  type: "text-delta",
-                  id: textPartId,
-                  delta: data.content
-                });
-                controller.enqueue({ type: "text-end", id: textPartId });
-              }
-              if (data?.toolRequests?.length) {
-                for (const tr of data.toolRequests) {
-                  const toolId = tr.toolCallId;
-                  let state = toolStates.get(toolId);
-                  if (!state) {
-                    state = {
-                      name: tr.name,
-                      inputStarted: false,
-                      callEmitted: false
-                    };
-                    toolStates.set(toolId, state);
-                  }
-                  if (!state.inputStarted) {
-                    controller.enqueue({
-                      type: "tool-input-start",
-                      id: toolId,
-                      toolName: tr.name,
-                      providerExecuted: true,
-                      dynamic: true
-                    });
-                    state.inputStarted = true;
-                  }
-                  const args = tr.arguments ?? {};
-                  controller.enqueue({
-                    type: "tool-input-delta",
-                    id: toolId,
-                    delta: JSON.stringify(args)
-                  });
-                  controller.enqueue({ type: "tool-input-end", id: toolId });
-                  if (!state.callEmitted) {
-                    controller.enqueue({
-                      type: "tool-call",
-                      toolCallId: toolId,
-                      toolName: tr.name,
-                      input: typeof args === "string" ? args : JSON.stringify(args),
-                      providerExecuted: true,
-                      dynamic: true
-                    });
-                    state.callEmitted = true;
-                  }
-                }
-              }
-            } else if (event.type === "tool.execution_start") {
-              const data = event.data;
-              if (data) {
-                const toolId = data.toolCallId;
-                let state = toolStates.get(toolId);
-                if (!state) {
-                  state = {
-                    name: data.toolName,
-                    inputStarted: true,
-                    callEmitted: false
-                  };
-                  toolStates.set(toolId, state);
-                }
-                if (!state.callEmitted) {
-                  controller.enqueue({
-                    type: "tool-input-start",
-                    id: toolId,
-                    toolName: data.toolName,
-                    providerExecuted: true,
-                    dynamic: true
-                  });
-                  controller.enqueue({ type: "tool-input-end", id: toolId });
-                  controller.enqueue({
-                    type: "tool-call",
-                    toolCallId: toolId,
-                    toolName: data.toolName,
-                    input: "{}",
-                    providerExecuted: true,
-                    dynamic: true
-                  });
-                  state.callEmitted = true;
-                }
-              }
-            } else if (event.type === "tool.execution_complete") {
-              const evt = event;
-              const data = evt.data;
-              if (data) {
-                const toolName = data.toolName ?? "unknown";
-                const result = data.success && data.result?.content ? data.result.content : data.error?.message ?? "Tool execution failed";
-                controller.enqueue({
-                  type: "tool-result",
-                  toolCallId: data.toolCallId,
-                  toolName,
-                  result,
-                  isError: !data.success,
-                  dynamic: true
-                });
-              }
-            } else if (event.type === "assistant.usage") {
-              const data = event.data;
-              if (data) {
-                usage = convertCopilotUsage(data);
-              }
-            } else if (event.type === "session.idle") {
-              if (textPartId) {
-                controller.enqueue({ type: "text-end", id: textPartId });
-              }
-              controller.enqueue({
-                type: "finish",
-                finishReason: mapCopilotFinishReason(),
-                usage
-              });
-              controller.close();
-              void session.destroy();
-            } else if (event.type === "session.error") {
-              const data = event.data;
-              controller.enqueue({
-                type: "error",
-                error: new Error(data?.message ?? "Session error")
-              });
-              controller.close();
-              void session.destroy();
-            }
+          const handleEvent = createStreamEventHandler({
+            controller,
+            session
           });
+          session.on(handleEvent);
           await session.send({ prompt, attachments });
         } catch (error) {
           if (isAbortError(error)) {
@@ -534,20 +576,16 @@ var GitHubCopilotLanguageModel = class {
               error: options.abortSignal?.aborted ? options.abortSignal.reason : error
             });
           } else {
-            handleCopilotError(error, { promptExcerpt: prompt.substring(0, 200) });
+            handleCopilotError(error);
           }
           controller.close();
           await session.destroy();
         } finally {
-          if (options.abortSignal && abortListener) {
-            options.abortSignal.removeEventListener("abort", abortListener);
-          }
+          removeAbortListener();
         }
       },
       cancel: () => {
-        if (options.abortSignal && abortListener) {
-          options.abortSignal.removeEventListener("abort", abortListener);
-        }
+        removeAbortListener();
       }
     });
     return {