@charzhu/openjaw-agent 0.2.7 → 0.2.8

package/dist/main.js

@@ -204,7 +204,7 @@ var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_packageRoot();
-    DEFAULT_COPILOT_OAUTH_CLIENT_ID = "Ov23li8tweQw6odWQebz";
+    DEFAULT_COPILOT_OAUTH_CLIENT_ID = "Iv1.b507a08c87ecfe98";
     DEFAULT_CONFIG = {
       llm: {
         provider: "anthropic",
@@ -1884,6 +1884,85 @@ var init_openai = __esm({
   }
 });
 
+// src/copilot-token.ts
+function normalizeCopilotEnterpriseDomain(value) {
+  return value.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+}
+function copilotApiBase(enterpriseUrl) {
+  return enterpriseUrl ? `https://copilot-api.${normalizeCopilotEnterpriseDomain(enterpriseUrl)}` : "https://api.githubcopilot.com";
+}
+function copilotTokenEndpoint(enterpriseUrl) {
+  if (!enterpriseUrl) return "https://api.github.com/copilot_internal/v2/token";
+  const domain = normalizeCopilotEnterpriseDomain(enterpriseUrl);
+  const apiDomain = domain.startsWith("api.") ? domain : `api.${domain}`;
+  return `https://${apiDomain}/copilot_internal/v2/token`;
+}
+function decodeQueryComponent(value) {
+  return decodeURIComponent(value.replace(/\+/g, "%20"));
+}
+function copilotApiBaseFromToken(token) {
+  for (const part of token.split(";")) {
+    const rawProxyEndpoint = part.startsWith("proxy-ep=") ? part.slice("proxy-ep=".length) : void 0;
+    if (!rawProxyEndpoint) continue;
+    const proxyEndpoint = decodeQueryComponent(rawProxyEndpoint).trim().replace(/\/+$/, "");
+    if (!proxyEndpoint) return void 0;
+    if (proxyEndpoint.startsWith("http://") || proxyEndpoint.startsWith("https://")) return proxyEndpoint;
+    const host = proxyEndpoint.startsWith("proxy.") ? `api.${proxyEndpoint.slice("proxy.".length)}` : proxyEndpoint.startsWith("api.") ? proxyEndpoint : `api.${proxyEndpoint}`;
+    return `https://${host}`;
+  }
+  return void 0;
+}
+async function exchangeGitHubTokenForCopilotToken(githubAccess, enterpriseUrl, signal) {
+  const res = await fetch(copilotTokenEndpoint(enterpriseUrl), {
+    headers: {
+      "Accept": "application/json",
+      "Authorization": `Bearer ${githubAccess}`,
+      "User-Agent": COPILOT_USER_AGENT,
+      "Editor-Version": COPILOT_EDITOR_VERSION,
+      "Editor-Plugin-Version": COPILOT_EDITOR_PLUGIN_VERSION,
+      "Copilot-Integration-Id": COPILOT_INTEGRATION_ID
+    },
+    signal
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    let message = text;
+    try {
+      const parsed = JSON.parse(text);
+      message = parsed.error_description || parsed.message || text;
+    } catch {
+    }
+    throw new Error(`GitHub Copilot token request failed: ${res.status}${message ? ` ${message.slice(0, 160)}` : ""}`);
+  }
+  const body = JSON.parse(text);
+  if (!body.token || typeof body.expires_at !== "number") {
+    throw new Error("GitHub Copilot token response was missing token or expires_at.");
+  }
+  return {
+    githubAccess,
+    copilotAccess: body.token,
+    copilotExpires: body.expires_at * 1e3,
+    copilotApiBaseUrl: copilotApiBaseFromToken(body.token) ?? copilotApiBase(enterpriseUrl),
+    enterpriseUrl
+  };
+}
+var COPILOT_USER_AGENT, COPILOT_EDITOR_VERSION, COPILOT_EDITOR_PLUGIN_VERSION, COPILOT_INTEGRATION_ID;
+var init_copilot_token = __esm({
+  "src/copilot-token.ts"() {
+    "use strict";
+    COPILOT_USER_AGENT = "GitHubCopilotChat/0.35.0";
+    COPILOT_EDITOR_VERSION = "vscode/1.107.0";
+    COPILOT_EDITOR_PLUGIN_VERSION = "copilot-chat/0.35.0";
+    COPILOT_INTEGRATION_ID = "vscode-chat";
+    __name(normalizeCopilotEnterpriseDomain, "normalizeCopilotEnterpriseDomain");
+    __name(copilotApiBase, "copilotApiBase");
+    __name(copilotTokenEndpoint, "copilotTokenEndpoint");
+    __name(decodeQueryComponent, "decodeQueryComponent");
+    __name(copilotApiBaseFromToken, "copilotApiBaseFromToken");
+    __name(exchangeGitHubTokenForCopilotToken, "exchangeGitHubTokenForCopilotToken");
+  }
+});
+
 // src/provider-auth.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join5 } from "node:path";
@@ -2024,12 +2103,6 @@ var init_types = __esm({
 });
 
 // src/providers/copilot.ts
-function normalizeCopilotEnterpriseDomain(value) {
-  return value.replace(/^https?:\/\//, "").replace(/\/+$/, "");
-}
-function copilotApiBase(enterpriseUrl) {
-  return enterpriseUrl ? `https://copilot-api.${normalizeCopilotEnterpriseDomain(enterpriseUrl)}` : "https://api.githubcopilot.com";
-}
 function shouldUseResponsesApi(modelID) {
   const normalized = modelID.toLowerCase();
   const match = /^gpt-(\d+)/.exec(normalized);
@@ -2079,6 +2152,12 @@ function toResponsesTool(tool) {
     parameters: normalizeObjectSchema2(tool.parameters)
   };
 }
+function endpointSupported(endpoints, target) {
+  return endpoints?.some((endpoint) => endpoint.trim().toLowerCase() === target) ?? false;
+}
+function copilotSupportsResponsesWebSocket(modelInfo) {
+  return endpointSupported(modelInfo?.supportedEndpoints, "ws:/responses");
+}
 function toAnthropicTool(tool) {
   assertToolName(tool.name);
   return {
@@ -2113,6 +2192,16 @@ function safeJsonParse(value) {
     return {};
   }
 }
+async function loadWebSocket() {
+  const { createRequire } = await import("node:module");
+  return createRequire(import.meta.url)("ws");
+}
+function responsesWebSocketUrl(baseUrl) {
+  const url = new URL(`${baseUrl.replace(/\/+$/, "")}/responses`);
+  if (url.protocol === "https:") url.protocol = "wss:";
+  else if (url.protocol === "http:") url.protocol = "ws:";
+  return url.toString();
+}
 function valueAtPath(value, path3) {
   let current = value;
   for (const key of path3) {
@@ -2121,6 +2210,24 @@ function valueAtPath(value, path3) {
   }
   return current;
 }
+function firstStringAtAny(value, paths2) {
+  for (const path3 of paths2) {
+    const candidate = valueAtPath(value, path3);
+    if (typeof candidate === "string" && candidate.trim()) return candidate;
+  }
+  return void 0;
+}
+function valueContainsAny(value, needles) {
+  if (typeof value === "string") {
+    const normalized = value.toLowerCase();
+    return needles.some((needle) => normalized.includes(needle));
+  }
+  if (Array.isArray(value)) return value.some((item) => valueContainsAny(item, needles));
+  if (value && typeof value === "object") {
+    return Object.values(value).some((item) => valueContainsAny(item, needles));
+  }
+  return false;
+}
 function firstPositiveIntegerAtAny(value, paths2) {
   for (const path3 of paths2) {
     const candidate = valueAtPath(value, path3);
@@ -2151,25 +2258,68 @@ function readCopilotOutputTokens(capabilities) {
 function readCopilotReasoningEfforts(capabilities) {
   return normalizeReasoningEfforts(valueAtPath(capabilities, ["supports", "reasoning_effort"]));
 }
+function copilotModelItems(body) {
+  if (Array.isArray(body.data) && body.data.length > 0) return body.data;
+  if (Array.isArray(body.models)) return body.models;
+  return [];
+}
+function isDisabledPolicyValue(value) {
+  return ["disabled", "blocked", "denied", "unavailable", "off"].includes(value.toLowerCase());
+}
+function policyAllows(policy) {
+  if (policy === void 0 || policy === null) return true;
+  if (typeof policy === "boolean") return policy;
+  if (typeof policy === "string") return !isDisabledPolicyValue(policy);
+  if (!policy || typeof policy !== "object" || Array.isArray(policy)) return true;
+  const record = policy;
+  if (record.enabled === false) return false;
+  return !["state", "status", "result"].some((key) => {
+    const value = record[key];
+    return typeof value === "string" && isDisabledPolicyValue(value);
+  });
+}
+function isChatCapable(model) {
+  if (model.id?.toLowerCase().includes("embedding")) return false;
+  if (!model.capabilities) return true;
+  if (valueContainsAny(model.capabilities, ["embedding", "embeddings"])) return false;
+  const kind = firstStringAtAny(model.capabilities, [["type"], ["kind"], ["family"]]);
+  return !kind || !["embedding", "embeddings", "completion", "completions"].includes(kind.toLowerCase());
+}
 function buildReasoning(effort, modelInfo) {
   const supported = modelInfo?.supportedReasoningEfforts?.map((option) => option.effort) ?? [];
   const selected = effort && supported.includes(effort) ? effort : void 0;
   const effective = selected ?? modelInfo?.defaultReasoningEffort;
   return effective ? { effort: effective } : void 0;
 }
+function collectResponsesOutputItem(item, accumulator) {
+  if (item.type === "message" && !accumulator.sawTextDelta) {
+    for (const block of item.content ?? []) {
+      if ((block.type === "output_text" || block.type === "text") && block.text) {
+        accumulator.text = (accumulator.text ?? "") + block.text;
+      }
+    }
+  } else if (item.type === "function_call" && item.name) {
+    accumulator.toolCalls.push({
+      id: item.call_id || item.id || `call_${accumulator.toolCalls.length}`,
+      name: item.name,
+      input: safeJsonParse(item.arguments)
+    });
+  }
+}
 function parseCopilotModels(body) {
-  const items = Array.isArray(body.data) ? body.data : [];
+  const items = copilotModelItems(body);
   const models = [];
   for (const item of items) {
-    if (!item.id || item.model_picker_enabled === false || item.policy?.state === "disabled") continue;
-    const visionMedia = item.capabilities?.limits?.vision?.supported_media_types ?? [];
+    if (!item.id || item.model_picker_enabled === false || !policyAllows(item.policy) || !isChatCapable(item)) continue;
+    const visionMedia = valueAtPath(item.capabilities, ["limits", "vision", "supported_media_types"]);
     const supportedReasoning = readCopilotReasoningEfforts(item.capabilities);
     models.push({
       id: item.id,
       name: item.name,
       supportedEndpoints: item.supported_endpoints ?? [],
-      supportsVision: item.capabilities?.supports?.vision === true || visionMedia.some((media) => media.startsWith("image/")),
-      supportsToolCalls: item.capabilities?.supports?.tool_calls !== false,
+      supportsResponsesWebSocket: copilotSupportsResponsesWebSocket({ supportedEndpoints: item.supported_endpoints ?? [] }),
+      supportsVision: valueAtPath(item.capabilities, ["supports", "vision"]) === true || Array.isArray(visionMedia) && visionMedia.some((media) => typeof media === "string" && media.startsWith("image/")),
+      supportsToolCalls: valueAtPath(item.capabilities, ["supports", "tool_calls"]) !== false,
       contextWindow: readCopilotContextWindow(item.capabilities),
       outputTokens: readCopilotOutputTokens(item.capabilities),
       supportedReasoningEfforts: supportedReasoning.map((effort) => ({ effort, description: effort })),
@@ -2178,32 +2328,46 @@ function parseCopilotModels(body) {
   }
   return models;
 }
-var COPILOT_PROVIDER, USER_AGENT, OPENAI_TOOL_NAME2, CopilotProvider;
+var COPILOT_PROVIDER, USER_AGENT, OPENAI_TOOL_NAME2, COPILOT_TOKEN_EXPIRY_SAFETY_MARGIN_MS, RESPONSES_WEBSOCKET_CONNECT_TIMEOUT_MS, RESPONSES_WEBSOCKET_IDLE_TIMEOUT_MS, CopilotProvider;
 var init_copilot = __esm({
   "src/providers/copilot.ts"() {
     "use strict";
+    init_copilot_token();
     init_provider_auth();
     init_types();
+    init_copilot_token();
     COPILOT_PROVIDER = "github-copilot";
     USER_AGENT = "openjaw-agent/0.1.0";
     OPENAI_TOOL_NAME2 = /^[A-Za-z0-9_-]{1,64}$/;
-    __name(normalizeCopilotEnterpriseDomain, "normalizeCopilotEnterpriseDomain");
-    __name(copilotApiBase, "copilotApiBase");
+    COPILOT_TOKEN_EXPIRY_SAFETY_MARGIN_MS = 6e4;
+    RESPONSES_WEBSOCKET_CONNECT_TIMEOUT_MS = 1e4;
+    RESPONSES_WEBSOCKET_IDLE_TIMEOUT_MS = 12e4;
     __name(shouldUseResponsesApi, "shouldUseResponsesApi");
     __name(normalizeObjectSchema2, "normalizeObjectSchema");
     __name(assertToolName, "assertToolName");
     __name(toChatTool, "toChatTool");
     __name(toResponsesTool, "toResponsesTool");
+    __name(endpointSupported, "endpointSupported");
+    __name(copilotSupportsResponsesWebSocket, "copilotSupportsResponsesWebSocket");
     __name(toAnthropicTool, "toAnthropicTool");
     __name(hasImageContent, "hasImageContent");
     __name(openAIUserContent, "openAIUserContent");
     __name(safeJsonParse, "safeJsonParse");
+    __name(loadWebSocket, "loadWebSocket");
+    __name(responsesWebSocketUrl, "responsesWebSocketUrl");
     __name(valueAtPath, "valueAtPath");
+    __name(firstStringAtAny, "firstStringAtAny");
+    __name(valueContainsAny, "valueContainsAny");
     __name(firstPositiveIntegerAtAny, "firstPositiveIntegerAtAny");
     __name(readCopilotContextWindow, "readCopilotContextWindow");
     __name(readCopilotOutputTokens, "readCopilotOutputTokens");
     __name(readCopilotReasoningEfforts, "readCopilotReasoningEfforts");
+    __name(copilotModelItems, "copilotModelItems");
+    __name(isDisabledPolicyValue, "isDisabledPolicyValue");
+    __name(policyAllows, "policyAllows");
+    __name(isChatCapable, "isChatCapable");
     __name(buildReasoning, "buildReasoning");
+    __name(collectResponsesOutputItem, "collectResponsesOutputItem");
     __name(parseCopilotModels, "parseCopilotModels");
     CopilotProvider = class {
       static {
@@ -2212,6 +2376,7 @@ var init_copilot = __esm({
       name = COPILOT_PROVIDER;
       config;
       modelCache = null;
+      responsesWebSocketDisabled = false;
       constructor(config) {
         this.config = config;
       }
@@ -2228,39 +2393,74 @@ var init_copilot = __esm({
       }
       async chat(options) {
         const modelInfo = await this.resolveModelInfo(this.config.model);
-        if (modelInfo?.supportedEndpoints.includes("/v1/messages") || this.config.model.toLowerCase().startsWith("claude-")) {
-          return this.chatAnthropicMessages(options);
-        }
         if (this.shouldRouteToResponses(modelInfo)) {
           return this.chatResponses(options, modelInfo);
         }
+        if (this.shouldRouteToAnthropicMessages(modelInfo)) {
+          return this.chatAnthropicMessages(options);
+        }
         return this.chatCompletions(options);
       }
       shouldRouteToResponses(modelInfo) {
         if (this.config.use_responses_api === false) return false;
         if (modelInfo?.supportedEndpoints.length) {
-          return modelInfo.supportedEndpoints.includes("/responses");
+          return endpointSupported(modelInfo.supportedEndpoints, "/responses");
         }
         return shouldUseResponsesApi(this.config.model);
       }
+      shouldRouteToAnthropicMessages(modelInfo) {
+        if (modelInfo?.supportedEndpoints.length) return false;
+        return this.config.model.toLowerCase().startsWith("claude-");
+      }
+      copilotBaseUrl(credential) {
+        if (this.config.base_url) return this.config.base_url.replace(/\/+$/, "");
+        if (credential?.type === "oauth" && credential.copilotApiBaseUrl) return credential.copilotApiBaseUrl.replace(/\/+$/, "");
+        const enterpriseUrl = this.config.copilot_enterprise_url || (credential?.type === "oauth" ? credential.enterpriseUrl : void 0);
+        return copilotApiBase(enterpriseUrl);
+      }
+      async resolveCopilotAuth(signal) {
+        if (this.config.api_key && this.config.api_key !== "proxy-token") {
+          return { token: this.config.api_key, baseUrl: this.copilotBaseUrl() };
+        }
+        const credential = getProviderCredential(COPILOT_PROVIDER);
+        if (credential?.type !== "oauth") {
+          throw new Error("GitHub Copilot is not connected. Run /connect github-copilot first.");
+        }
+        if (credential.copilotAccess && credential.copilotExpires && credential.copilotExpires > Date.now() + COPILOT_TOKEN_EXPIRY_SAFETY_MARGIN_MS) {
+          return { token: credential.copilotAccess, baseUrl: this.copilotBaseUrl(credential) };
+        }
+        const githubAccess = credential.githubAccess || credential.refresh || credential.access;
+        const enterpriseUrl = this.config.copilot_enterprise_url || credential.enterpriseUrl;
+        const exchanged = await exchangeGitHubTokenForCopilotToken(githubAccess, enterpriseUrl, signal);
+        saveProviderCredential({
+          ...credential,
+          access: exchanged.copilotAccess,
+          refresh: exchanged.githubAccess,
+          expires: exchanged.copilotExpires,
+          githubAccess: exchanged.githubAccess,
+          copilotAccess: exchanged.copilotAccess,
+          copilotExpires: exchanged.copilotExpires,
+          copilotApiBaseUrl: exchanged.copilotApiBaseUrl,
+          enterpriseUrl
+        });
+        return { token: exchanged.copilotAccess, baseUrl: this.config.base_url?.replace(/\/+$/, "") ?? exchanged.copilotApiBaseUrl };
+      }
       resolveGitHubToken() {
         if (this.config.api_key && this.config.api_key !== "proxy-token") return this.config.api_key;
         const credential = getProviderCredential(COPILOT_PROVIDER);
-        if (credential?.type === "oauth") return credential.access || credential.refresh;
+        if (credential?.type === "oauth") return credential.githubAccess || credential.refresh || credential.access;
         throw new Error("GitHub Copilot is not connected. Run /connect github-copilot first.");
       }
-      resolveCopilotToken() {
-        return this.resolveGitHubToken();
+      async resolveCopilotToken(signal) {
+        return (await this.resolveCopilotAuth(signal)).token;
       }
-      baseUrl() {
-        if (this.config.base_url) return this.config.base_url.replace(/\/+$/, "");
-        const credential = getProviderCredential(COPILOT_PROVIDER);
-        const enterpriseUrl = this.config.copilot_enterprise_url || (credential?.type === "oauth" ? credential.enterpriseUrl : void 0);
-        return copilotApiBase(enterpriseUrl);
+      async baseUrl(signal) {
+        return (await this.resolveCopilotAuth(signal)).baseUrl;
       }
-      async headers(options, extra) {
+      async headers(options, extra, auth) {
+        const resolvedAuth = auth ?? await this.resolveCopilotAuth(options.signal);
         const headers = {
-          "Authorization": `Bearer ${await this.resolveCopilotToken()}`,
+          "Authorization": `Bearer ${resolvedAuth.token}`,
           "Content-Type": "application/json",
           "User-Agent": USER_AGENT,
           "Editor-Version": "OpenJaw/0.1.0",
@@ -2274,15 +2474,17 @@ var init_copilot = __esm({
         return headers;
       }
       async fetchModelInfo() {
-        const res = await fetch(`${this.baseUrl()}/models`, {
+        const signal = AbortSignal.timeout(1e4);
+        const auth = await this.resolveCopilotAuth(signal);
+        const res = await fetch(`${auth.baseUrl}/models`, {
           headers: {
-            "Authorization": `Bearer ${await this.resolveCopilotToken()}`,
+            "Authorization": `Bearer ${auth.token}`,
             "User-Agent": USER_AGENT,
             "Editor-Version": "OpenJaw/0.1.0",
             "Editor-Plugin-Version": "OpenJaw/0.1.0",
             "Copilot-Integration-Id": "vscode-chat"
           },
-          signal: AbortSignal.timeout(1e4)
+          signal
         });
         if (!res.ok) {
           const detail = await res.text().catch(() => "");
@@ -2304,6 +2506,7 @@ var init_copilot = __esm({
               id: modelID,
               name: modelID,
               supportedEndpoints: ["/v1/messages"],
+              supportsResponsesWebSocket: false,
               supportsVision: true,
               supportsToolCalls: true
             };
@@ -2311,6 +2514,102 @@ var init_copilot = __esm({
           return null;
         }
       }
+      shouldUseResponsesWebSocket(modelInfo) {
+        return !this.responsesWebSocketDisabled && copilotSupportsResponsesWebSocket(modelInfo);
+      }
+      disableResponsesWebSocket() {
+        this.responsesWebSocketDisabled = true;
+      }
+      buildResponsesRequestBody(options, modelInfo) {
+        const reasoning = buildReasoning(options.reasoningEffort, modelInfo);
+        return {
+          model: this.config.model,
+          input: this.buildResponsesInput(options),
+          instructions: Array.isArray(options.systemPrompt) ? options.systemPrompt.map((block) => block.text).join("\n\n") : options.systemPrompt,
+          tools: options.tools.length > 0 ? options.tools.map(toResponsesTool) : void 0,
+          ...reasoning && { reasoning, include: ["reasoning.encrypted_content"] }
+        };
+      }
+      buildResponsesWebSocketRequest(requestBody) {
+        return {
+          type: "response.create",
+          ...requestBody,
+          tools: requestBody.tools ?? [],
+          tool_choice: requestBody.tools?.length ? "auto" : "none",
+          parallel_tool_calls: true,
+          store: false,
+          stream: true,
+          include: requestBody.include ?? []
+        };
+      }
+      async chatResponsesWebSocket(options, requestBody) {
+        const auth = await this.resolveCopilotAuth(options.signal);
+        const headers = await this.headers(options, void 0, auth);
+        const WebSocket2 = await loadWebSocket();
+        const ws = new WebSocket2(responsesWebSocketUrl(auth.baseUrl), {
+          headers,
+          handshakeTimeout: RESPONSES_WEBSOCKET_CONNECT_TIMEOUT_MS
+        });
+        const request = JSON.stringify(this.buildResponsesWebSocketRequest(requestBody));
+        return new Promise((resolve5, reject) => {
+          const accumulator = { sawTextDelta: false, text: null, toolCalls: [] };
+          let settled = false;
+          const timeout = setTimeout(() => {
+            if (settled) return;
+            settled = true;
+            ws.close();
+            reject(new Error("Responses WebSocket idle timeout"));
+          }, RESPONSES_WEBSOCKET_IDLE_TIMEOUT_MS);
+          const finish = /* @__PURE__ */ __name((value) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            ws.close();
+            resolve5(value);
+          }, "finish");
+          const fail = /* @__PURE__ */ __name((error) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            ws.close();
+            reject(error instanceof Error ? error : new Error(String(error)));
+          }, "fail");
+          options.signal?.addEventListener("abort", () => fail(options.signal?.reason ?? new DOMException("Aborted", "AbortError")), { once: true });
+          ws.addEventListener("open", () => ws.send(request));
+          ws.addEventListener("error", (event) => fail(event.error ?? event.message ?? "Responses WebSocket error"));
+          ws.addEventListener("close", (event) => {
+            if (!settled) fail(new Error(`Responses WebSocket closed before completion (${event.code ?? "unknown"})`));
+          });
+          ws.addEventListener("message", (event) => {
+            try {
+              const text = typeof event.data === "string" ? event.data : Buffer.isBuffer(event.data) ? event.data.toString("utf8") : String(event.data);
+              const parsed = JSON.parse(text);
+              const type = String(parsed.type ?? "");
+              if (type === "response.output_text.delta" && typeof parsed.delta === "string") {
+                accumulator.sawTextDelta = true;
+                accumulator.text = (accumulator.text ?? "") + parsed.delta;
+              } else if (type === "response.output_item.done" && parsed.item && typeof parsed.item === "object") {
+                collectResponsesOutputItem(parsed.item, accumulator);
+              } else if (type === "response.failed") {
+                fail(new Error(JSON.stringify(parsed.response ?? parsed)));
+              } else if (type === "response.incomplete") {
+                fail(new Error("Responses WebSocket returned incomplete response"));
+              } else if (type === "response.completed") {
+                const response = parsed.response && typeof parsed.response === "object" ? parsed.response : {};
+                const usage2 = response.usage && typeof response.usage === "object" ? response.usage : void 0;
+                finish({
+                  text: accumulator.text,
+                  toolCalls: accumulator.toolCalls,
+                  stopReason: accumulator.toolCalls.length > 0 ? "tool_use" : "end",
+                  usage: this.usage(usage2?.input_tokens, usage2?.output_tokens)
+                });
+              }
+            } catch (error) {
+              fail(error);
+            }
+          });
+        });
+      }
       buildChatMessages(options) {
         const messages = [
           {
@@ -2362,7 +2661,7 @@ var init_copilot = __esm({
           tool_choice: options.tools.length > 0 ? "auto" : void 0,
           temperature: this.config.temperature
         };
-        const res = await fetch(`${this.baseUrl()}/chat/completions`, {
+        const res = await fetch(`${await this.baseUrl(options.signal)}/chat/completions`, {
           method: "POST",
           headers: await this.headers(options),
           body: JSON.stringify(requestBody),
@@ -2406,15 +2705,16 @@ var init_copilot = __esm({
         return input;
       }
       async chatResponses(options, modelInfo) {
-        const reasoning = buildReasoning(options.reasoningEffort, modelInfo);
-        const requestBody = {
-          model: this.config.model,
-          input: this.buildResponsesInput(options),
-          instructions: Array.isArray(options.systemPrompt) ? options.systemPrompt.map((block) => block.text).join("\n\n") : options.systemPrompt,
-          tools: options.tools.length > 0 ? options.tools.map(toResponsesTool) : void 0,
-          ...reasoning && { reasoning, include: ["reasoning.encrypted_content"] }
-        };
-        const res = await fetch(`${this.baseUrl()}/responses`, {
+        const requestBody = this.buildResponsesRequestBody(options, modelInfo);
+        if (this.shouldUseResponsesWebSocket(modelInfo)) {
+          try {
+            return await this.chatResponsesWebSocket(options, requestBody);
+          } catch (err) {
+            if (options.signal?.aborted) throw err;
+            this.disableResponsesWebSocket();
+          }
+        }
+        const res = await fetch(`${await this.baseUrl(options.signal)}/responses`, {
           method: "POST",
           headers: await this.headers(options),
           body: JSON.stringify(requestBody),
@@ -2493,7 +2793,7 @@ var init_copilot = __esm({
           messages: this.buildAnthropicMessages(options),
           tools: options.tools.length > 0 ? options.tools.map(toAnthropicTool) : void 0
         };
-        const res = await fetch(`${this.baseUrl()}/v1/messages`, {
+        const res = await fetch(`${await this.baseUrl(options.signal)}/v1/messages`, {
           method: "POST",
           headers: await this.headers(options, {
             "anthropic-version": "2023-06-01",
@@ -3825,13 +4125,18 @@ async function completeCopilotDeviceFlow(flow, signal) {
     }
     const body = await res.json();
     if (body.access_token) {
+      const copilotToken = await exchangeGitHubTokenForCopilotToken(body.access_token, flow.enterpriseUrl, signal);
       const now2 = (/* @__PURE__ */ new Date()).toISOString();
       saveProviderCredential({
         type: "oauth",
         provider: "github-copilot",
-        access: body.access_token,
-        refresh: body.access_token,
-        expires: 0,
+        access: copilotToken.copilotAccess,
+        refresh: copilotToken.githubAccess,
+        expires: copilotToken.copilotExpires,
+        githubAccess: copilotToken.githubAccess,
+        copilotAccess: copilotToken.copilotAccess,
+        copilotExpires: copilotToken.copilotExpires,
+        copilotApiBaseUrl: copilotToken.copilotApiBaseUrl,
         enterpriseUrl: flow.enterpriseUrl,
         createdAt: now2,
         updatedAt: now2
@@ -3839,7 +4144,7 @@ async function completeCopilotDeviceFlow(flow, signal) {
       return {
         provider: "github-copilot",
         enterpriseUrl: flow.enterpriseUrl,
-        baseUrl: copilotApiBase(flow.enterpriseUrl)
+        baseUrl: copilotToken.copilotApiBaseUrl
       };
     }
     if (body.error === "authorization_pending") continue;
@@ -3855,7 +4160,7 @@ var init_copilot_auth = __esm({
   "src/copilot-auth.ts"() {
     "use strict";
     init_provider_auth();
-    init_copilot();
+    init_copilot_token();
     OAUTH_POLLING_SAFETY_MARGIN_MS = 3e3;
     __name(isOAuthAbortError, "isOAuthAbortError");
     __name(oauthDomain, "oauthDomain");
@@ -21921,11 +22226,31 @@ async function runCopilotResponsesSearch(input, llm, startedAt) {
   if (!credential || credential.type !== "oauth") {
     throw new Error("GitHub Copilot is not connected. Run /connect github-copilot first.");
   }
-  const baseUrl = llm.base_url?.replace(/\/+$/, "") ?? copilotApiBase(credential.enterpriseUrl);
+  let copilotAccess = credential.copilotAccess;
+  let copilotApiBaseUrl = credential.copilotApiBaseUrl;
+  if (!copilotAccess || !credential.copilotExpires || credential.copilotExpires <= Date.now() + COPILOT_TOKEN_EXPIRY_SAFETY_MARGIN_MS2) {
+    const exchanged = await exchangeGitHubTokenForCopilotToken(
+      credential.githubAccess || credential.refresh || credential.access,
+      credential.enterpriseUrl
+    );
+    copilotAccess = exchanged.copilotAccess;
+    copilotApiBaseUrl = exchanged.copilotApiBaseUrl;
+    saveProviderCredential({
+      ...credential,
+      access: exchanged.copilotAccess,
+      refresh: exchanged.githubAccess,
+      expires: exchanged.copilotExpires,
+      githubAccess: exchanged.githubAccess,
+      copilotAccess: exchanged.copilotAccess,
+      copilotExpires: exchanged.copilotExpires,
+      copilotApiBaseUrl: exchanged.copilotApiBaseUrl
+    });
+  }
+  const baseUrl = llm.base_url?.replace(/\/+$/, "") ?? copilotApiBaseUrl?.replace(/\/+$/, "") ?? copilotApiBase(credential.enterpriseUrl);
   const headers = {
-    "Authorization": `Bearer ${credential.access || credential.refresh}`,
+    "Authorization": `Bearer ${copilotAccess}`,
     "Content-Type": "application/json",
-    "User-Agent": COPILOT_USER_AGENT,
+    "User-Agent": COPILOT_USER_AGENT2,
     "Editor-Version": "OpenJaw/0.1.0",
     "Editor-Plugin-Version": "OpenJaw/0.1.0",
     "Copilot-Integration-Id": "vscode-chat",
@@ -22152,15 +22477,16 @@ function limitAndDedupe(results, max) {
 function truncate(text) {
   return text.length > 200 ? text.slice(0, 200) + "\u2026" : text;
 }
-var COPILOT_USER_AGENT, DEFAULT_TIMEOUT_MS;
+var COPILOT_USER_AGENT2, DEFAULT_TIMEOUT_MS, COPILOT_TOKEN_EXPIRY_SAFETY_MARGIN_MS2;
 var init_web_search = __esm({
   "src/web-search.ts"() {
     "use strict";
     init_web_search_types();
+    init_copilot_token();
     init_provider_auth();
-    init_copilot();
-    COPILOT_USER_AGENT = "openjaw-agent/0.1.0";
+    COPILOT_USER_AGENT2 = "openjaw-agent/0.1.0";
     DEFAULT_TIMEOUT_MS = 45e3;
+    COPILOT_TOKEN_EXPIRY_SAFETY_MARGIN_MS2 = 6e4;
     __name(createWebSearchExecutor, "createWebSearchExecutor");
     __name(runCopilotResponsesSearch, "runCopilotResponsesSearch");
     __name(runOpenAIResponsesSearch, "runOpenAIResponsesSearch");