@witqq/agent-sdk 0.7.0 → 0.9.0

package/dist/backends/copilot.cjs

@@ -1,6 +1,44 @@
 'use strict';
 
-// src/types.ts
+// src/types/errors.ts
+var RECOVERABLE_CODES = /* @__PURE__ */ new Set([
+  "TIMEOUT" /* TIMEOUT */,
+  "RATE_LIMIT" /* RATE_LIMIT */,
+  "NETWORK" /* NETWORK */,
+  "TOOL_EXECUTION" /* TOOL_EXECUTION */,
+  "MODEL_OVERLOADED" /* MODEL_OVERLOADED */,
+  "PROVIDER_ERROR" /* PROVIDER_ERROR */
+]);
+function isRecoverableErrorCode(code) {
+  return RECOVERABLE_CODES.has(code);
+}
+function classifyAgentError(error) {
+  const msg = (error instanceof Error ? error.message : error).toLowerCase();
+  if (msg.includes("timeout") || msg.includes("timed out") || msg.includes("timedout") || msg.includes("etimedout")) {
+    return "TIMEOUT" /* TIMEOUT */;
+  }
+  if (msg.includes("rate limit") || msg.includes("rate_limit") || msg.includes("429") || msg.includes("too many requests")) {
+    return "RATE_LIMIT" /* RATE_LIMIT */;
+  }
+  if (msg.includes("unauthorized") || msg.includes("401") || msg.includes("auth") && (msg.includes("expired") || msg.includes("invalid") || msg.includes("denied") || msg.includes("failed"))) {
+    return "AUTH_EXPIRED" /* AUTH_EXPIRED */;
+  }
+  if (msg.includes("econnrefused") || msg.includes("econnreset") || msg.includes("enotfound") || msg.includes("network") || msg.includes("fetch failed") || msg.includes("socket hang up")) {
+    return "NETWORK" /* NETWORK */;
+  }
+  if (msg.includes("subprocess") || msg.includes("process exited") || msg.includes("spawn") || msg.includes("enoent") || msg.includes("killed")) {
+    return "DEPENDENCY_MISSING" /* DEPENDENCY_MISSING */;
+  }
+  if (msg.includes("abort") || msg.includes("cancel")) {
+    return "ABORTED" /* ABORTED */;
+  }
+  if (msg.includes("500") || msg.includes("502") || msg.includes("503") || msg.includes("internal server error") || msg.includes("service unavailable") || msg.includes("bad gateway") || msg.includes("overloaded")) {
+    return "PROVIDER_ERROR" /* PROVIDER_ERROR */;
+  }
+  return "PROVIDER_ERROR" /* PROVIDER_ERROR */;
+}
+
+// src/types/guards.ts
 function getTextContent(content) {
   if (typeof content === "string") return content;
   return content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
@@ -10,9 +48,18 @@ function getTextContent(content) {
 var AgentSDKError = class extends Error {
   /** @internal Marker for cross-bundle identity checks */
   _agentSDKError = true;
+  /** Machine-readable error code. Prefer values from the ErrorCode enum. */
+  code;
+  /** Whether this error is safe to retry */
+  retryable;
+  /** HTTP status code hint for error classification */
+  httpStatus;
   constructor(message, options) {
     super(message, options);
     this.name = "AgentSDKError";
+    this.code = options?.code;
+    this.retryable = options?.retryable ?? false;
+    this.httpStatus = options?.httpStatus;
   }
   /** Check if an error is an AgentSDKError (works across bundled copies) */
   static is(error) {
@@ -21,28 +68,41 @@ var AgentSDKError = class extends Error {
 };
 var ReentrancyError = class extends AgentSDKError {
   constructor() {
-    super("Agent is already running. Await the current run before starting another.");
+    super("Agent is already running. Await the current run before starting another.", {
+      code: "REENTRANCY" /* REENTRANCY */
+    });
     this.name = "ReentrancyError";
   }
 };
 var DisposedError = class extends AgentSDKError {
   constructor(entity) {
-    super(`${entity} has been disposed and cannot be used.`);
+    super(`${entity} has been disposed and cannot be used.`, {
+      code: "DISPOSED" /* DISPOSED */
+    });
     this.name = "DisposedError";
   }
 };
 var SubprocessError = class extends AgentSDKError {
   constructor(message, options) {
-    super(message, options);
+    super(message, { ...options, code: "DEPENDENCY_MISSING" /* DEPENDENCY_MISSING */ });
     this.name = "SubprocessError";
   }
 };
 var AbortError = class extends AgentSDKError {
   constructor() {
-    super("Agent run was aborted.");
+    super("Agent run was aborted.", { code: "ABORTED" /* ABORTED */ });
     this.name = "AbortError";
   }
 };
+var ActivityTimeoutError = class extends AgentSDKError {
+  constructor(timeoutMs) {
+    super(`Stream activity timeout: no event received within ${timeoutMs}ms.`, {
+      code: "TIMEOUT" /* TIMEOUT */,
+      retryable: true
+    });
+    this.name = "ActivityTimeoutError";
+  }
+};
 
 // src/base-agent.ts
 var BaseAgent = class {
@@ -50,6 +110,7 @@ var BaseAgent = class {
   abortController = null;
   config;
   _cleanupExternalSignal = null;
+  _streamMiddleware = [];
   /** CLI session ID for persistent mode. Override in backends that support it. */
   get sessionId() {
     return void 0;
@@ -65,8 +126,11 @@ var BaseAgent = class {
     this.state = "running";
     try {
       const messages = [{ role: "user", content: prompt }];
-      const result = await this.executeRun(messages, options, ac.signal);
-      this.enrichAndNotifyUsage(result);
+      const result = await this.withRetry(
+        () => this.executeRun(messages, options, ac.signal),
+        options
+      );
+      this.enrichAndNotifyUsage(result, options);
       return result;
     } finally {
       this.cleanupRun();
@@ -78,8 +142,11 @@ var BaseAgent = class {
     const ac = this.createAbortController(options?.signal);
     this.state = "running";
     try {
-      const result = await this.executeRun(messages, options, ac.signal);
-      this.enrichAndNotifyUsage(result);
+      const result = await this.withRetry(
+        () => this.executeRun(messages, options, ac.signal),
+        options
+      );
+      this.enrichAndNotifyUsage(result, options);
       return result;
     } finally {
       this.cleanupRun();
@@ -92,13 +159,11 @@ var BaseAgent = class {
     this.state = "running";
     try {
       const messages = [{ role: "user", content: prompt }];
-      const result = await this.executeRunStructured(
-        messages,
-        schema,
-        options,
-        ac.signal
+      const result = await this.withRetry(
+        () => this.executeRunStructured(messages, schema, options, ac.signal),
+        options
       );
-      this.enrichAndNotifyUsage(result);
+      this.enrichAndNotifyUsage(result, options);
       return result;
     } finally {
       this.cleanupRun();
@@ -111,8 +176,10 @@ var BaseAgent = class {
     this.state = "streaming";
     try {
       const messages = [{ role: "user", content: prompt }];
-      const enriched = this.enrichStream(this.executeStream(messages, options, ac.signal));
-      yield* this.heartbeatStream(enriched);
+      yield* this.streamWithRetry(
+        () => this.applyStreamPipeline(this.executeStream(messages, options, ac.signal), options, ac),
+        options
+      );
     } finally {
       this.cleanupRun();
     }
@@ -123,12 +190,37 @@ var BaseAgent = class {
     const ac = this.createAbortController(options?.signal);
     this.state = "streaming";
     try {
-      const enriched = this.enrichStream(this.executeStream(messages, options, ac.signal));
-      yield* this.heartbeatStream(enriched);
+      yield* this.streamWithRetry(
+        () => this.applyStreamPipeline(this.executeStream(messages, options, ac.signal), options, ac),
+        options
+      );
     } finally {
       this.cleanupRun();
     }
   }
+  /** Register a stream middleware. Applied in registration order after built-in transforms. */
+  addStreamMiddleware(middleware) {
+    this.guardDisposed();
+    this._streamMiddleware.push(middleware);
+  }
+  /** Apply built-in transforms (enrich→timeout→heartbeat) then custom middleware */
+  async *applyStreamPipeline(source, options, ac) {
+    let stream = this.enrichStream(source, options);
+    stream = this.activityTimeoutStream(stream, options?.activityTimeoutMs, ac);
+    stream = this.heartbeatStream(stream);
+    if (this._streamMiddleware.length > 0) {
+      const ctx = {
+        model: options.model,
+        backend: this.backendName,
+        abortController: ac,
+        config: Object.freeze({ ...this.config })
+      };
+      for (const mw of this._streamMiddleware) {
+        stream = mw(stream, ctx);
+      }
+    }
+    yield* stream;
+  }
   abort() {
     if (this.abortController) {
       this.abortController.abort();
@@ -151,26 +243,109 @@ var BaseAgent = class {
     this.abort();
     this.state = "disposed";
   }
+  // ─── Retry Logic ─────────────────────────────────────────────
+  /** Check if an error should be retried given the retry configuration. */
+  isRetryableError(error, retry) {
+    if (error instanceof AbortError || error instanceof ReentrancyError || error instanceof DisposedError) {
+      return false;
+    }
+    if (AgentSDKError.is(error)) {
+      if (retry.retryableErrors && retry.retryableErrors.length > 0 && error.code) {
+        return retry.retryableErrors.includes(error.code);
+      }
+      if (error.retryable) return true;
+      if (error.code) return isRecoverableErrorCode(error.code);
+    }
+    return false;
+  }
+  /** Execute a function with retry logic per RetryConfig. */
+  async withRetry(fn, options) {
+    const retry = options?.retry;
+    if (!retry || !retry.maxRetries || retry.maxRetries <= 0) {
+      return fn();
+    }
+    const maxRetries = retry.maxRetries;
+    const initialDelay = retry.initialDelayMs ?? 1e3;
+    const multiplier = retry.backoffMultiplier ?? 2;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (attempt >= maxRetries || !this.isRetryableError(err, retry)) {
+          throw err;
+        }
+        const delay = initialDelay * Math.pow(multiplier, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        if (options?.signal?.aborted || this.abortController?.signal.aborted) {
+          throw err;
+        }
+      }
+    }
+    throw lastError;
+  }
+  /** Execute a stream factory with pre-stream retry: retries until first event, then committed. */
+  async *streamWithRetry(factory, options) {
+    const retry = options?.retry;
+    if (!retry || !retry.maxRetries || retry.maxRetries <= 0) {
+      yield* factory();
+      return;
+    }
+    const maxRetries = retry.maxRetries;
+    const initialDelay = retry.initialDelayMs ?? 1e3;
+    const multiplier = retry.backoffMultiplier ?? 2;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const stream = factory();
+        const iterator = stream[Symbol.asyncIterator]();
+        const first = await iterator.next();
+        if (first.done) return;
+        yield first.value;
+        while (true) {
+          const next = await iterator.next();
+          if (next.done) break;
+          yield next.value;
+        }
+        return;
+      } catch (err) {
+        if (attempt >= maxRetries || !this.isRetryableError(err, retry)) {
+          throw err;
+        }
+        const delay = initialDelay * Math.pow(multiplier, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        if (options?.signal?.aborted || this.abortController?.signal.aborted) {
+          throw err;
+        }
+      }
+    }
+  }
+  // ─── CallOptions Resolution ──────────────────────────────────
+  /** Resolve tools to use for this call (per-call override > config default) */
+  resolveTools(options) {
+    return options?.tools ?? this.config.tools ?? [];
+  }
   // ─── Usage Enrichment ───────────────────────────────────────────
   /** Enrich result usage with model/backend and fire onUsage callback */
-  enrichAndNotifyUsage(result) {
+  enrichAndNotifyUsage(result, options) {
     if (result.usage) {
       result.usage = {
         ...result.usage,
-        model: this.config.model,
+        model: options.model,
         backend: this.backendName
       };
       this.callOnUsage(result.usage);
     }
   }
   /** Wrap a stream to enrich usage_update events and fire onUsage callback */
-  async *enrichStream(source) {
+  async *enrichStream(source, options) {
+    const model = options.model;
     for await (const event of source) {
       if (event.type === "usage_update") {
         const usage = {
           promptTokens: event.promptTokens,
           completionTokens: event.completionTokens,
-          model: this.config.model,
+          model,
           backend: this.backendName
         };
         this.callOnUsage(usage);
@@ -240,6 +415,35 @@ var BaseAgent = class {
       heartbeatResolve = null;
     }
   }
+  // ─── Activity Timeout ────────────────────────────────────────
+  /** Wrap a stream to abort on inactivity. Resets timer on every event.
+   *  When timeoutMs is not set, passes through directly. */
+  async *activityTimeoutStream(source, timeoutMs, ac) {
+    if (!timeoutMs || timeoutMs <= 0) {
+      yield* source;
+      return;
+    }
+    const iterator = source[Symbol.asyncIterator]();
+    let timerId;
+    try {
+      while (true) {
+        const timeoutPromise = new Promise((_, reject) => {
+          timerId = setTimeout(() => reject(new ActivityTimeoutError(timeoutMs)), timeoutMs);
+        });
+        const result = await Promise.race([iterator.next(), timeoutPromise]);
+        clearTimeout(timerId);
+        if (result.done) break;
+        yield result.value;
+      }
+    } catch (err) {
+      if (err instanceof ActivityTimeoutError) {
+        ac.abort(err);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timerId);
+    }
+  }
   // ─── Guards ───────────────────────────────────────────────────
   guardReentrancy() {
     if (this.state === "running" || this.state === "streaming") {
@@ -338,13 +542,67 @@ function extractSchemaFromDef(schema) {
   }
 }
 
+// src/backends/shared.ts
+function extractLastUserPrompt(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "user") {
+      return getTextContent(msg.content);
+    }
+  }
+  return "";
+}
+function serializeToolCall(tc) {
+  const args = typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args);
+  return `  Tool call: ${tc.name}(${args})`;
+}
+function serializeToolResult(tr) {
+  const result = typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
+  const prefix = tr.isError ? "[ERROR] " : "";
+  return `  ${tr.name} \u2192 ${prefix}${result}`;
+}
+function buildContextualPrompt(messages) {
+  if (messages.length <= 1) {
+    return extractLastUserPrompt(messages);
+  }
+  const history = messages.slice(0, -1).map((msg) => {
+    if (msg.role === "user") {
+      return `User: ${msg.content ? getTextContent(msg.content) : ""}`;
+    }
+    if (msg.role === "tool" && msg.toolResults) {
+      const results = msg.toolResults.map(serializeToolResult).join("\n");
+      return `Tool results:
+${results}`;
+    }
+    if (msg.role === "assistant") {
+      const parts = [];
+      const thinking = msg.thinking;
+      if (thinking) {
+        parts.push(`[reasoning: ${thinking}]`);
+      }
+      const text2 = msg.content ? getTextContent(msg.content) : "";
+      if (text2) parts.push(text2);
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        parts.push(msg.toolCalls.map(serializeToolCall).join("\n"));
+      }
+      return `Assistant: ${parts.join("\n")}`;
+    }
+    const text = msg.content ? getTextContent(msg.content) : "";
+    return `${msg.role}: ${text}`;
+  }).join("\n");
+  const lastPrompt = extractLastUserPrompt(messages);
+  return `Conversation history:
+${history}
+
+User: ${lastPrompt}`;
+}
+
 // src/backends/copilot.ts
-var sdkModule = null;
+var _sdkMock = null;
 async function loadSDK() {
-  if (sdkModule) return sdkModule;
+  if (_sdkMock) return _sdkMock;
   try {
-    sdkModule = await import('@github/copilot-sdk');
-    return sdkModule;
+    return await import('@github/copilot-sdk');
   } catch {
     throw new SubprocessError(
       "@github/copilot-sdk is not installed. Install it: npm install @github/copilot-sdk"
@@ -352,10 +610,10 @@ async function loadSDK() {
   }
 }
 function _injectSDK(mock) {
-  sdkModule = mock;
+  _sdkMock = mock;
 }
 function _resetSDK() {
-  sdkModule = null;
+  _sdkMock = null;
 }
 function mapToolsToSDK(tools) {
   return tools.map((tool) => ({
@@ -375,17 +633,6 @@ function convertParameters(params) {
   }
   return params;
 }
-async function mapToolsToSDKAsync(tools) {
-  return tools.map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    parameters: convertParameters(tool.parameters),
-    handler: async (args) => {
-      const result = await tool.execute(args);
-      return typeof result === "string" ? result : JSON.stringify(result);
-    }
-  }));
-}
 function buildPermissionHandler(config) {
   const onPermission = config.supervisor?.onPermission;
   if (!onPermission) {
@@ -400,6 +647,7 @@ function buildPermissionHandler(config) {
     const unifiedRequest = {
       toolName,
       toolArgs: { ...request },
+      toolCallId: request.toolCallId,
       rawSDKRequest: request
     };
     const ac = new AbortController();
@@ -542,15 +790,21 @@ function mapSessionEvent(event, tracker, thinkingTracker) {
       };
     case "session.error":
       console.error("[copilot] mapSessionEvent error:", JSON.stringify(data));
-      return {
-        type: "error",
-        error: String(data.message ?? "Unknown error"),
-        recoverable: false
-      };
+      {
+        const errorMsg = String(data.message ?? "Unknown error");
+        const code = classifyAgentError(errorMsg);
+        return {
+          type: "error",
+          error: errorMsg,
+          recoverable: isRecoverableErrorCode(code),
+          code
+        };
+      }
     case "assistant.message": {
       const doneEvent = {
         type: "done",
-        finalOutput: data.content ? String(data.content) : null
+        finalOutput: null,
+        streamed: true
       };
       if (thinkingTracker.endThinking()) {
         return [{ type: "thinking_end" }, doneEvent];
@@ -570,6 +824,7 @@ var CopilotAgent = class extends BaseAgent {
   isPersistent;
   persistentSession = null;
   _sessionId;
+  _persistentModel;
   activeSession = null;
   _resumeSessionId;
   _toolsReady = null;
@@ -588,15 +843,15 @@ var CopilotAgent = class extends BaseAgent {
       },
       onPermissionRequest: buildPermissionHandler(config),
       onUserInputRequest: buildUserInputHandler(config),
-      ...config.availableTools?.length ? { availableTools: config.availableTools } : {}
+      ...config.availableTools ? { availableTools: config.availableTools } : {}
     };
     this._toolsReady = this._initToolsAsync(config);
     this._resumeSessionId = resumeSessionId;
   }
-  /** Pre-convert Zod schemas to JSON Schema asynchronously.
+  /** Pre-convert Zod schemas to JSON Schema.
    *  Updates sdkTools and sessionConfig.tools before first session creation. */
   async _initToolsAsync(config) {
-    this.sdkTools = await mapToolsToSDKAsync(config.tools ?? []);
+    this.sdkTools = mapToolsToSDK(config.tools ?? []);
     this.sessionConfig.tools = this.sdkTools;
   }
   get sessionId() {
@@ -620,47 +875,63 @@ var CopilotAgent = class extends BaseAgent {
       });
       this.persistentSession = null;
       this._sessionId = void 0;
+      this._persistentModel = void 0;
     }
   }
-  async getOrCreateSession(streaming) {
+  async getOrCreateSession(streaming, options) {
     if (this.isPersistent && this.persistentSession) {
-      return { session: this.persistentSession, isNew: false };
+      if (options.model !== this._persistentModel) {
+        this.persistentSession.destroy().catch(() => {
+        });
+        this.persistentSession = null;
+        this._sessionId = void 0;
+      } else {
+        return { session: this.persistentSession, isNew: false };
+      }
     }
     if (this._toolsReady) {
       await this._toolsReady;
       this._toolsReady = null;
     }
+    const sessionConfig = { ...this.sessionConfig };
+    sessionConfig.model = options.model;
+    const resolvedTools = this.resolveTools(options);
+    if (options?.tools) {
+      sessionConfig.tools = mapToolsToSDK(resolvedTools);
+    }
     const client = await this.getClient();
     if (this._resumeSessionId) {
       const storedId = this._resumeSessionId;
       this._resumeSessionId = void 0;
       try {
         const session2 = await client.resumeSession(storedId, {
-          ...this.sessionConfig,
+          ...sessionConfig,
           streaming: this.isPersistent ? true : streaming
         });
         if (this.isPersistent) {
           this.persistentSession = session2;
           this._sessionId = session2.sessionId;
+          this._persistentModel = options.model;
         }
         return { session: session2, isNew: false };
       } catch {
       }
     }
     const session = await client.createSession({
-      ...this.sessionConfig,
+      ...sessionConfig,
       streaming: this.isPersistent ? true : streaming
     });
     if (this.isPersistent) {
       this.persistentSession = session;
       this._sessionId = session.sessionId;
+      this._persistentModel = options.model;
     }
     return { session, isNew: true };
   }
   // ─── executeRun ─────────────────────────────────────────────────
-  async executeRun(messages, _options, signal) {
+  async executeRun(messages, options, signal) {
     this.checkAbort(signal);
-    const { session, isNew: isNewSession } = await this.getOrCreateSession(false);
+    const { session, isNew: isNewSession } = await this.getOrCreateSession(false, options);
     this.activeSession = session;
     const prompt = this.isPersistent && !isNewSession ? extractLastUserPrompt(messages) : buildContextualPrompt(messages);
     const tracker = new ToolCallTracker();
@@ -757,9 +1028,9 @@ You MUST respond with ONLY valid JSON matching this schema:
     };
   }
   // ─── executeStream ──────────────────────────────────────────────
-  async *executeStream(messages, _options, signal) {
+  async *executeStream(messages, options, signal) {
     this.checkAbort(signal);
-    const { session, isNew: isNewSession } = await this.getOrCreateSession(true);
+    const { session, isNew: isNewSession } = await this.getOrCreateSession(true, options);
     this.activeSession = session;
     if (isNewSession) {
       yield this.emitSessionInfo(session.sessionId);
@@ -845,59 +1116,6 @@ You MUST respond with ONLY valid JSON matching this schema:
     super.dispose();
   }
 };
-function extractLastUserPrompt(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role === "user") {
-      return getTextContent(msg.content);
-    }
-  }
-  return "";
-}
-function serializeToolCall(tc) {
-  const args = typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args);
-  return `  Tool call: ${tc.name}(${args})`;
-}
-function serializeToolResult(tr) {
-  const result = typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
-  const prefix = tr.isError ? "[ERROR] " : "";
-  return `  ${tr.name} \u2192 ${prefix}${result}`;
-}
-function buildContextualPrompt(messages) {
-  if (messages.length <= 1) {
-    return extractLastUserPrompt(messages);
-  }
-  const history = messages.slice(0, -1).map((msg) => {
-    if (msg.role === "user") {
-      return `User: ${msg.content ? getTextContent(msg.content) : ""}`;
-    }
-    if (msg.role === "tool" && msg.toolResults) {
-      const results = msg.toolResults.map(serializeToolResult).join("\n");
-      return `Tool results:
-${results}`;
-    }
-    if (msg.role === "assistant") {
-      const parts = [];
-      const thinking = msg.thinking;
-      if (thinking) {
-        parts.push(`[reasoning: ${thinking}]`);
-      }
-      const text2 = msg.content ? getTextContent(msg.content) : "";
-      if (text2) parts.push(text2);
-      if (msg.toolCalls && msg.toolCalls.length > 0) {
-        parts.push(msg.toolCalls.map(serializeToolCall).join("\n"));
-      }
-      return `Assistant: ${parts.join("\n")}`;
-    }
-    const text = msg.content ? getTextContent(msg.content) : "";
-    return `${msg.role}: ${text}`;
-  }).join("\n");
-  const lastPrompt = extractLastUserPrompt(messages);
-  return `Conversation history:
-${history}
-
-User: ${lastPrompt}`;
-}
 function withTimeout(promise, ms, message) {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => reject(new SubprocessError(message)), ms);
@@ -939,7 +1157,11 @@ var CopilotAgentService = class {
           githubToken: this.options.githubToken,
           useLoggedInUser: this.options.useLoggedInUser ?? !this.options.githubToken,
           ...this.options.cliArgs ? { cliArgs: this.options.cliArgs } : {},
-          ...this.options.env ? { env: { ...process.env, ...this.options.env } } : {}
+          env: {
+            ...process.env,
+            ...this.options.githubToken ? { GITHUB_TOKEN: this.options.githubToken } : {},
+            ...this.options.env
+          }
         });
         const startupTimeout = this.options.startupTimeoutMs ?? 3e4;
         await withTimeout(client.start(), startupTimeout, "CLI startup timed out");
@@ -973,7 +1195,10 @@ var CopilotAgentService = class {
     return models.map((m) => ({
       id: m.id,
       name: m.name,
-      provider: "copilot"
+      provider: "copilot",
+      ...m.capabilities?.limits?.max_context_window_tokens != null && {
+        contextWindow: m.capabilities.limits.max_context_window_tokens
+      }
     }));
   }
   async validate() {