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

package/dist/index.cjs

@@ -0,0 +1,613 @@
+'use strict';
+
+var provider = require('@ai-sdk/provider');
+var providerUtils = require('@ai-sdk/provider-utils');
+var copilotSdk = require('@github/copilot-sdk');
+
+// src/errors.ts
+var AUTH_ERROR_PATTERNS = [
+  "not authenticated",
+  "authentication",
+  "unauthorized",
+  "auth failed",
+  "please login",
+  "login required",
+  "invalid token",
+  "token expired"
+];
+function createAuthenticationError(options) {
+  return new provider.LoadAPIKeyError({
+    message: options.message ?? "Authentication failed. Please ensure Copilot CLI is properly authenticated."
+  });
+}
+function createAPICallError(options) {
+  return new provider.APICallError({
+    message: options.message,
+    url: "copilot://session",
+    requestBodyValues: {},
+    statusCode: options.statusCode,
+    cause: options.cause,
+    isRetryable: options.isRetryable ?? false
+  });
+}
+function isAuthenticationError(error) {
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  return AUTH_ERROR_PATTERNS.some((pattern) => message.includes(pattern));
+}
+function isAbortError(error) {
+  if (error && typeof error === "object") {
+    const e = error;
+    if (typeof e.name === "string" && e.name === "AbortError") return true;
+    if (typeof e.code === "string" && e.code.toUpperCase() === "ABORT_ERR") return true;
+  }
+  return false;
+}
+function handleCopilotError(error, _context) {
+  if (isAbortError(error)) {
+    throw error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (isAuthenticationError(error)) {
+    throw createAuthenticationError({ message });
+  }
+  throw createAPICallError({
+    message: message || "GitHub Copilot SDK error",
+    cause: error,
+    isRetryable: false
+  });
+}
+
+// src/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 convertToCopilotMessages(prompt) {
+  const messages = [];
+  const warnings = [];
+  let systemMessage;
+  const attachments = [];
+  for (const message of prompt) {
+    switch (message.role) {
+      case "system": {
+        const content = message.content;
+        systemMessage = typeof content === "string" ? content : extractTextFromParts(content);
+        if (systemMessage?.trim()) {
+          messages.push(`System: ${systemMessage}`);
+        }
+        break;
+      }
+      case "user": {
+        const content = message.content;
+        if (typeof content === "string") {
+          messages.push(`User: ${content}`);
+        } else {
+          const textParts = [];
+          for (const part of content) {
+            if (part.type === "text") {
+              textParts.push(part.text);
+            } else if (part.type === "file") {
+              const fileInfo = extractFileAttachment(part);
+              if (fileInfo.path) {
+                attachments.push({
+                  type: "file",
+                  path: fileInfo.path,
+                  displayName: fileInfo.displayName
+                });
+              } else if (fileInfo.warning) {
+                warnings.push(fileInfo.warning);
+              }
+            } else if (part.type === "image") {
+              warnings.push(IMAGE_BASE64_WARNING);
+            }
+          }
+          if (textParts.length > 0) {
+            messages.push(`User: ${textParts.join("\n")}`);
+          }
+        }
+        break;
+      }
+      case "assistant": {
+        const content = message.content;
+        if (typeof content === "string") {
+          messages.push(`Assistant: ${content}`);
+        } else {
+          const textParts = [];
+          for (const part of content) {
+            if (part.type === "text") {
+              textParts.push(part.text);
+            } else if (part.type === "tool-call") {
+              textParts.push(`[Tool call: ${part.toolName}]`);
+            } else if (part.type === "reasoning") {
+              textParts.push(`[Reasoning: ${part.text}]`);
+            }
+          }
+          if (textParts.length > 0) {
+            messages.push(`Assistant: ${textParts.join("\n")}`);
+          }
+        }
+        break;
+      }
+      case "tool": {
+        for (const part of message.content) {
+          if (part.type === "tool-result") {
+            const output = part.output;
+            let resultStr;
+            if (output.type === "text" || output.type === "error-text") {
+              resultStr = output.value;
+            } else if (output.type === "json" || output.type === "error-json") {
+              resultStr = JSON.stringify(output.value);
+            } else if (output.type === "execution-denied") {
+              resultStr = `[Execution denied${output.reason ? `: ${output.reason}` : ""}]`;
+            } else if (output.type === "content") {
+              resultStr = output.value.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+            } else {
+              resultStr = "[Unknown output type]";
+            }
+            const isError = output.type === "error-text" || output.type === "error-json";
+            messages.push(
+              `Tool result (${part.toolName}): ${isError ? "Error: " : ""}${resultStr}`
+            );
+          }
+        }
+        break;
+      }
+    }
+  }
+  const promptText = messages.join("\n\n");
+  return {
+    prompt: promptText,
+    systemMessage: systemMessage?.trim() || void 0,
+    attachments: attachments.length > 0 ? attachments : void 0,
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
+}
+function extractTextFromParts(content) {
+  return content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+function extractFileAttachment(part) {
+  if (part.type !== "file") return {};
+  const data = part.data;
+  if (typeof data === "string") {
+    if (data.startsWith("http://") || data.startsWith("https://")) {
+      return { warning: IMAGE_URL_WARNING };
+    }
+    if (data.startsWith("file://")) {
+      return { path: data.slice(7), displayName: part.filename };
+    }
+    if (data.startsWith("/") || /^[A-Za-z]:[\\/]/.test(data)) {
+      return { path: data, displayName: part.filename };
+    }
+    return { warning: IMAGE_BASE64_WARNING };
+  }
+  return {};
+}
+
+// src/map-copilot-finish-reason.ts
+function mapCopilotFinishReason() {
+  return {
+    unified: "stop",
+    raw: void 0
+  };
+}
+
+// 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
+  };
+}
+var GitHubCopilotLanguageModel = class {
+  specificationVersion = "v3";
+  defaultObjectGenerationMode = "json";
+  supportsImageUrls = false;
+  supportedUrls = {};
+  supportsStructuredOutputs = false;
+  modelId;
+  settings;
+  getClient;
+  constructor(options) {
+    this.modelId = options.modelId;
+    this.settings = options.settings;
+    this.getClient = options.getClient;
+  }
+  get provider() {
+    return "github-copilot";
+  }
+  getEffectiveModel() {
+    return this.settings.model ?? this.modelId;
+  }
+  buildSessionConfig(streaming) {
+    return {
+      model: this.getEffectiveModel(),
+      sessionId: this.settings.sessionId,
+      streaming,
+      systemMessage: this.settings.systemMessage,
+      tools: this.settings.tools,
+      provider: this.settings.provider,
+      workingDirectory: this.settings.workingDirectory
+    };
+  }
+  generateWarnings(options) {
+    const warnings = [];
+    const unsupported = [];
+    if (options.temperature !== void 0) unsupported.push("temperature");
+    if (options.topP !== void 0) unsupported.push("topP");
+    if (options.topK !== void 0) unsupported.push("topK");
+    if (options.presencePenalty !== void 0) unsupported.push("presencePenalty");
+    if (options.frequencyPenalty !== void 0) unsupported.push("frequencyPenalty");
+    if (options.stopSequences?.length) unsupported.push("stopSequences");
+    if (options.seed !== void 0) unsupported.push("seed");
+    for (const param of unsupported) {
+      warnings.push({
+        type: "unsupported",
+        feature: param,
+        details: `GitHub Copilot SDK does not support the ${param} parameter. It will be ignored.`
+      });
+    }
+    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
+    });
+    let abortListener;
+    if (options.abortSignal) {
+      abortListener = () => session.abort();
+      options.abortSignal.addEventListener("abort", abortListener, { once: true });
+    }
+    try {
+      const result = await session.sendAndWait(
+        { prompt, attachments },
+        options.abortSignal?.aborted ? 0 : 6e4
+      );
+      const content = [];
+      const text = result?.data?.content ?? "";
+      if (text) {
+        content.push({ type: "text", text });
+      }
+      let usage = createEmptyUsage();
+      const usageEvent = result?.data?.usage;
+      if (usageEvent && typeof usageEvent === "object") {
+        usage = convertCopilotUsage(usageEvent);
+      }
+      const finishReason = mapCopilotFinishReason();
+      return {
+        content,
+        finishReason,
+        usage,
+        warnings,
+        request: { body: { prompt, attachments } },
+        response: {
+          id: providerUtils.generateId(),
+          timestamp: /* @__PURE__ */ new Date(),
+          modelId: this.modelId
+        }
+      };
+    } catch (error) {
+      if (isAbortError(error)) {
+        throw options.abortSignal?.aborted ? options.abortSignal.reason : error;
+      }
+      handleCopilotError(error, { promptExcerpt: prompt.substring(0, 200) });
+      return void 0;
+    } finally {
+      if (options.abortSignal && abortListener) {
+        options.abortSignal.removeEventListener("abort", abortListener);
+      }
+      try {
+        await session.destroy();
+      } catch {
+      }
+    }
+  }
+  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 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 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();
+            }
+          });
+          await session.send({ prompt, attachments });
+        } catch (error) {
+          if (isAbortError(error)) {
+            controller.enqueue({
+              type: "error",
+              error: options.abortSignal?.aborted ? options.abortSignal.reason : error
+            });
+          } else {
+            handleCopilotError(error, { promptExcerpt: prompt.substring(0, 200) });
+          }
+          controller.close();
+          await session.destroy();
+        } finally {
+          if (options.abortSignal && abortListener) {
+            options.abortSignal.removeEventListener("abort", abortListener);
+          }
+        }
+      },
+      cancel: () => {
+        if (options.abortSignal && abortListener) {
+          options.abortSignal.removeEventListener("abort", abortListener);
+        }
+      }
+    });
+    return {
+      stream,
+      request: { body: { prompt, attachments } }
+    };
+  }
+};
+function createGitHubCopilot(options = {}) {
+  let clientInstance = null;
+  const getOrCreateClient = () => {
+    if (!clientInstance) {
+      clientInstance = new copilotSdk.CopilotClient(options.clientOptions ?? {});
+    }
+    return clientInstance;
+  };
+  const createModel = (modelId, settings = {}) => {
+    const mergedSettings = {
+      ...options.defaultSettings,
+      ...settings
+    };
+    return new GitHubCopilotLanguageModel({
+      modelId,
+      settings: mergedSettings,
+      getClient: getOrCreateClient
+    });
+  };
+  const provider$1 = function(modelId, settings) {
+    if (new.target) {
+      throw new Error("The GitHub Copilot model function cannot be called with the new keyword.");
+    }
+    return createModel(modelId, settings);
+  };
+  provider$1.languageModel = createModel;
+  provider$1.chat = createModel;
+  provider$1.specificationVersion = "v3";
+  provider$1.embeddingModel = (modelId) => {
+    throw new provider.NoSuchModelError({
+      modelId,
+      modelType: "embeddingModel"
+    });
+  };
+  provider$1.imageModel = (modelId) => {
+    throw new provider.NoSuchModelError({
+      modelId,
+      modelType: "imageModel"
+    });
+  };
+  provider$1.getClient = getOrCreateClient;
+  return provider$1;
+}
+var githubCopilot = createGitHubCopilot();
+
+exports.GitHubCopilotLanguageModel = GitHubCopilotLanguageModel;
+exports.createAPICallError = createAPICallError;
+exports.createAuthenticationError = createAuthenticationError;
+exports.createGitHubCopilot = createGitHubCopilot;
+exports.githubCopilot = githubCopilot;
+exports.handleCopilotError = handleCopilotError;
+exports.isAbortError = isAbortError;
+exports.isAuthenticationError = isAuthenticationError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map