@opeoginni/opencode-copilot-auto 0.1.5 → 0.1.7

package/README.md

@@ -17,6 +17,12 @@ Restart OpenCode, authenticate GitHub Copilot if necessary with `opencode auth l
 
 The plugin uses the existing OpenCode GitHub Copilot authentication and sends the prompt to Copilot's routing endpoint solely to select a model.
 
+## Commands
+
+- `/copilot-refresh`: Clears the routing cache so the next prompt selects a fresh model.
+- `/copilot-autorefresh`: Toggles fresh model selection for every prompt. Run it again to resume using the cached routing session.
+- `/copilot-notify`: Toggles notifications between a toast and the projection bus.
+
 ## Development
 
 ```sh

package/dist/index.js

@@ -1,15 +1,88 @@
 // @bun
 // src/index.ts
 var COPILOT_BASE_URL = "https://api.individual.githubcopilot.com";
-var COPILOT_API_VERSION = "2026-06-01";
+var COPILOT_API_VERSION = "2026-07-01";
 var SESSION_REFRESH_BUFFER_SECONDS = 30;
+var HYDRA_ROUTING = false;
+var PROJECTION_KEY = "copilot-auto";
+var notifyMode = "toast";
 var sessions = new Map;
-var CopilotAutoPlugin = async () => {
-  installFetchAdapter();
+var autoRefresh = false;
+function hasToast(client) {
+  return typeof client === "object" && client !== null && "tui" in client && typeof client.tui?.showToast === "function";
+}
+function hasBus(client) {
+  return typeof client === "object" && client !== null && "bus" in client && typeof client.bus?.publish === "function";
+}
+async function notify(client, message) {
+  if (notifyMode === "projection" && hasBus(client)) {
+    await client.bus.publish({
+      topic: "companion.projection",
+      body: { key: PROJECTION_KEY, kind: "markdown", content: message }
+    }).catch(() => {});
+    return;
+  }
+  if (hasToast(client)) {
+    await client.tui.showToast({
+      body: { title: "Copilot Auto", message, variant: "info" }
+    }).catch(() => {});
+  }
+}
+function makeTextPart(sessionID, text) {
+  return {
+    id: crypto.randomUUID(),
+    sessionID,
+    messageID: crypto.randomUUID(),
+    type: "text",
+    text
+  };
+}
+var CopilotAutoPlugin = async (input) => {
+  const client = input.client;
+  installFetchAdapter(client);
+  const notifyClient = (message) => notify(client, message);
   return {
     provider: {
       id: "github-copilot",
       models: async (provider) => ({ ...provider.models, auto: autoModel() })
+    },
+    config: async (input2) => {
+      input2.command ??= {};
+      input2.command["copilot-refresh"] ??= {
+        template: "/copilot-refresh",
+        description: "Clear Copilot Auto routing cache so the next prompt re-selects a model"
+      };
+      input2.command["copilot-autorefresh"] ??= {
+        template: "/copilot-autorefresh",
+        description: "Toggle automatic model re-selection on every prompt"
+      };
+      input2.command["copilot-notify"] ??= {
+        template: "/copilot-notify",
+        description: "Toggle between toast and projection bus notifications"
+      };
+    },
+    "command.execute.before": async (input2, output) => {
+      if (input2.command === "copilot-refresh") {
+        sessions.clear();
+        await notifyClient("Routing cache cleared. Next prompt will select a fresh model.");
+        output.parts.length = 0;
+        output.parts.push(makeTextPart(input2.sessionID, "Copilot Auto routing cache cleared. The next prompt will select a fresh model."));
+        return;
+      }
+      if (input2.command === "copilot-autorefresh") {
+        autoRefresh = !autoRefresh;
+        await notifyClient(autoRefresh ? "Refresh enabled. Every prompt will select a fresh model." : "Refresh disabled. Reusing cached routing session.");
+        output.parts.length = 0;
+        output.parts.push(makeTextPart(input2.sessionID, autoRefresh ? "Copilot Auto refresh enabled. Every prompt will select a fresh model." : "Copilot Auto refresh disabled. Reusing cached routing session."));
+        return;
+      }
+      if (input2.command === "copilot-notify") {
+        notifyMode = notifyMode === "toast" ? "projection" : "toast";
+        await notifyClient(`Notification mode: ${notifyMode}`);
+        output.parts.length = 0;
+        output.parts.push(makeTextPart(input2.sessionID, `Copilot Auto notification mode: ${notifyMode}`));
+        return;
+      }
     }
   };
 };
@@ -42,7 +115,7 @@ function autoModel() {
     variants: {}
   };
 }
-function installFetchAdapter() {
+function installFetchAdapter(client) {
   const marker = Symbol.for("opeoginni.opencode-copilot-auto.fetch-adapter");
   const runtime = globalThis;
   if (runtime[marker])
@@ -57,18 +130,24 @@ function installFetchAdapter() {
     const payload = parseJson(body);
     if (!payload || payload.model !== "auto")
       return originalFetch(input, init);
+    if (autoRefresh)
+      sessions.clear();
     const session = await getSession(originalFetch, request.headers);
     const model = await route(originalFetch, request.headers, session, payload);
+    await notify(client, `Routed to ${model}`);
+    const useResponses = usesResponses(model);
     const headers = new Headers(request.headers);
     headers.set("copilot-session-token", session.token);
-    const next = usesResponses(model) ? toResponsesRequest(payload, model) : { ...payload, model };
-    const url = usesResponses(model) ? toResponsesUrl(request.url) : request.url;
-    return originalFetch(new Request(url, {
+    headers.set("X-GitHub-Api-Version", COPILOT_API_VERSION);
+    const next = useResponses ? toResponsesRequest(payload, model) : { ...payload, model };
+    const url = useResponses ? toResponsesUrl(request.url) : request.url;
+    const response = await originalFetch(new Request(url, {
       method: request.method,
       headers,
       body: JSON.stringify(next),
       signal: request.signal
     }));
+    return useResponses ? wrapResponsesResponse(response) : response;
   };
   globalThis.fetch = Object.assign(adapter, originalFetch);
 }
@@ -78,25 +157,164 @@ function isAutoRequest(request) {
 }
 function usesResponses(modelID) {
   const match = /^gpt-(\d+)/.exec(modelID);
-  return Boolean(match && Number(match[1]) >= 5 && !modelID.startsWith("gpt-5-mini"));
+  return Boolean(match && Number(match[1]) >= 5);
 }
 function toResponsesUrl(url) {
   return url.replace(/\/chat\/completions\/?$/, "/responses");
 }
 function toResponsesRequest(payload, model) {
-  const messages = Array.isArray(payload.messages) ? payload.messages : undefined;
-  const input = messages ? promptText(messages) : typeof payload.input === "string" ? payload.input : promptText(payload.input);
+  const messages = Array.isArray(payload.messages) ? payload.messages : [];
+  const instructions = messages.filter((m) => isRecord(m) && m.role === "system").map((m) => isRecord(m) && typeof m.content === "string" ? m.content : "").filter(Boolean).join(`
+`);
+  const input = messages.filter((m) => isRecord(m) && m.role !== "system").flatMap((m) => {
+    const msg = m;
+    const role = msg.role;
+    const content = msg.content;
+    if (role === "tool") {
+      return [{
+        type: "function_call_output",
+        call_id: msg.tool_call_id,
+        output: typeof content === "string" ? content : JSON.stringify(content)
+      }];
+    }
+    if (role === "assistant" && Array.isArray(msg.tool_calls)) {
+      const items = msg.tool_calls.map((tc) => {
+        if (!isRecord(tc) || !isRecord(tc.function))
+          return null;
+        return {
+          type: "function_call",
+          call_id: tc.id,
+          name: tc.function.name,
+          arguments: tc.function.arguments
+        };
+      }).filter((x) => x !== null);
+      if (typeof content === "string" && content) {
+        items.unshift({
+          role: "assistant",
+          content: [{ type: "output_text", text: content }]
+        });
+      }
+      return items;
+    }
+    const text = typeof content === "string" ? content : Array.isArray(content) ? content.map((part) => isRecord(part) && typeof part.text === "string" ? part.text : "").filter(Boolean).join(`
+`) : "";
+    return [{
+      role,
+      content: [{ type: role === "user" ? "input_text" : "output_text", text }]
+    }];
+  });
   return {
     model,
     input,
     stream: payload.stream === true,
+    ...instructions ? { instructions } : {},
     ...typeof payload.temperature === "number" ? { temperature: payload.temperature } : {},
     ...typeof payload.top_p === "number" ? { top_p: payload.top_p } : {},
     ...typeof payload.max_tokens === "number" ? { max_output_tokens: payload.max_tokens } : typeof payload.max_completion_tokens === "number" ? { max_output_tokens: payload.max_completion_tokens } : {},
-    ...Array.isArray(payload.tools) ? { tools: payload.tools } : {},
-    ...payload.tool_choice !== undefined ? { tool_choice: payload.tool_choice } : {}
+    ...Array.isArray(payload.tools) ? { tools: payload.tools.map(unwrapFunction) } : {},
+    ...payload.tool_choice !== undefined ? { tool_choice: unwrapFunction(payload.tool_choice) } : {}
   };
 }
+function unwrapFunction(value) {
+  if (!isRecord(value) || !isRecord(value.function))
+    return value;
+  const { function: fn, ...rest } = value;
+  return { ...fn, ...rest };
+}
+function wrapResponsesResponse(response) {
+  const chunkId = `chatcmpl-auto-${Date.now()}`;
+  const decoder = new TextDecoder;
+  const encoder = new TextEncoder;
+  let buffer = "";
+  let toolCallIndex = -1;
+  const transformed = new ReadableStream({
+    start(controller) {
+      const reader = response.body?.getReader();
+      if (!reader) {
+        controller.close();
+        return;
+      }
+      const stream = reader;
+      function emitChunk(delta, finishReason) {
+        const chunk = {
+          id: chunkId,
+          object: "chat.completion.chunk",
+          choices: [{ index: 0, delta, ...finishReason ? { finish_reason: finishReason } : {} }]
+        };
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
+
+`));
+      }
+      function processLine(line) {
+        if (line.startsWith("event:"))
+          return;
+        if (!line.startsWith("data:"))
+          return;
+        const data = line.slice(5).trim();
+        if (data === "[DONE]")
+          return;
+        try {
+          const event = JSON.parse(data);
+          const type = event.type;
+          if (type === "response.output_text.delta") {
+            emitChunk({ content: event.delta });
+          } else if (type === "response.output_item.added" && event.item?.type === "function_call") {
+            toolCallIndex++;
+            emitChunk({
+              tool_calls: [{
+                index: toolCallIndex,
+                id: event.item.call_id,
+                type: "function",
+                function: { name: event.item.name, arguments: "" }
+              }]
+            });
+          } else if (type === "response.function_call_arguments.delta") {
+            emitChunk({
+              tool_calls: [{
+                index: toolCallIndex,
+                function: { arguments: event.delta }
+              }]
+            });
+          } else if (type === "response.completed") {
+            emitChunk({}, "stop");
+            controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+          }
+        } catch {}
+      }
+      function pump() {
+        return stream.read().then(({ done, value }) => {
+          if (done) {
+            if (buffer) {
+              for (const line of buffer.split(`
+`))
+                processLine(line);
+            }
+            controller.close();
+            return;
+          }
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split(`
+`);
+          buffer = lines.pop() ?? "";
+          for (const line of lines)
+            processLine(line);
+          return pump();
+        });
+      }
+      pump().catch(() => controller.close());
+    }
+  });
+  return new Response(transformed, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: new Headers({
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache"
+    })
+  });
+}
 async function getSession(fetcher, requestHeaders) {
   const key = requestHeaders.get("authorization") ?? "anonymous";
   const cached = sessions.get(key);
@@ -131,12 +349,15 @@ async function route(fetcher, requestHeaders, session, payload) {
     body: JSON.stringify({
       prompt,
       available_models: session.availableModels,
-      session_id: "opencode-session://auto",
-      reference_count: 0,
-      prompt_char_count: prompt.length,
-      turn_number: userTurns(messages),
-      routing_method: "hydra",
-      copilot_plan: "individual"
+      has_image: false,
+      ...HYDRA_ROUTING ? {
+        session_id: "opencode-session://auto",
+        reference_count: 0,
+        prompt_char_count: prompt.length,
+        turn_number: userTurns(messages),
+        routing_method: "hydra",
+        copilot_plan: "individual"
+      } : {}
     }),
     signal: AbortSignal.timeout(5000)
   });
@@ -147,7 +368,7 @@ async function route(fetcher, requestHeaders, session, payload) {
 }
 function copilotHeaders(requestHeaders) {
   const headers = new Headers(requestHeaders);
-  headers.set("Content-Type", "text/plain;charset=UTF-8");
+  headers.set("Content-Type", "application/json");
   headers.set("X-GitHub-Api-Version", COPILOT_API_VERSION);
   return headers;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opeoginni/opencode-copilot-auto",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Add GitHub Copilot Auto model routing to OpenCode",
   "keywords": [
     "opencode",