headroom-opencode 0.39.1 → 0.41.0

package/README.md

@@ -35,32 +35,36 @@ The generated provider uses `@ai-sdk/openai-compatible` and points model request
 
 ## Native OpenCode Plugin
 
-Use `HeadroomPlugin` when OpenCode should intercept provider traffic in-process and expose Headroom tooling from a plugin.
+The package's default export is an OpenCode plugin that loads on both OpenCode 1.x and 2.x. Register it in `opencode.json`:
 
-```ts
-import { HeadroomPlugin } from "headroom-opencode";
-
-export default async function plugin(input) {
-  return HeadroomPlugin(input, {
-    proxyUrl: process.env.HEADROOM_PROXY_URL ?? "http://127.0.0.1:8787",
-  });
+```json
+{
+  "plugin": [
+    ["headroom-opencode", { "proxyUrl": "http://127.0.0.1:8787" }]
+  ]
 }
 ```
 
-`HeadroomPlugin`:
+OpenCode 2.x migrates the 1.x `plugin` key automatically. To configure it the 2.x way, use `"plugins": [{ "package": "headroom-opencode", "options": { ... } }]`.
+
+The default export is `{ id: "headroom", server, setup }`. OpenCode 1.x calls `server` (`HeadroomPlugin`) and 2.x calls `setup` (`headroomSetup`); each ignores the other's field. Both entry points:
+
+- install Headroom transport interception for OpenCode provider traffic.
+- expose the `headroom_retrieve` tool (a direct tool on 2.x, not only through code mode).
+- add `HEADROOM_ACTIVE`, `HEADROOM_PROXY_URL`, `HEADROOM_PROJECT` (and `HEADROOM_BACKEND` when set) to shell command environments.
+- default to `HEADROOM_PROXY_URL`, then `http://127.0.0.1:8787`, when no `proxyUrl` option is supplied.
+- skip routing for hosts listed in `excludeHosts` (or `HEADROOM_OPENCODE_EXCLUDE_HOSTS`); those requests go straight upstream with no compression or telemetry.
+
+On 2.x, setup returns a cleanup that releases the transport, so hot reloads do not stack interceptors.
 
-- installs Headroom transport interception for OpenCode provider traffic.
-- exposes the `headroom_retrieve` tool.
-- publishes `HEADROOM_PROXY_URL` in the plugin output env.
-- defaults to `http://127.0.0.1:8787` when no proxy URL is supplied.
-- skips routing for hosts listed in `excludeHosts` (or `HEADROOM_OPENCODE_EXCLUDE_HOSTS`); those requests go straight upstream with no compression or telemetry.
+OpenCode 2.x keeps its own reference to `fetch` from before plugins load, so patching `fetch` alone does not catch its model traffic. On 2.x the plugin also rewrites each remote model that uses the OpenAI chat-completions or responses format so that it points at the proxy. Headers name the real upstream, as the transport does. Models on other formats (Anthropic messages, Google) are left alone. `headroom wrap opencode` routes native Anthropic and OpenAI through the proxy separately, via their `baseURL`.
 
 To keep a provider off the proxy, list its host. An entry matches the host and all of its subdomains, and `.example.com` / `*.example.com` are accepted as spellings of `example.com`:
 
 ```jsonc
 // opencode.json
 {
-  "plugin": [["/path/to/headroom/providers/opencode/_dist/entry.opencode.js", { "excludeHosts": ["opencode.ai"] }]]
+  "plugin": [["/path/to/headroom/providers/opencode/_dist", { "excludeHosts": ["opencode.ai"] }]]
 }
 ```
 

package/dist/{chunk-6I5ODRCW.js → chunk-XS6Z2EJR.js}

@@ -13,8 +13,13 @@ function setDefaultProxyUrl(url2) {
 function getDefaultProxyUrl() {
   return _proxyUrlCache ?? process.env.HEADROOM_BASE_URL ?? "http://localhost:8787";
 }
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end--;
+  return value.slice(0, end);
+}
 function createHeadroomRetrieveTool(config2) {
-  const origin = config2.proxyBaseUrl.replace(/\/+$/, "");
+  const origin = trimTrailingSlashes(config2.proxyBaseUrl);
   return {
     name: "headroom_retrieve",
     description: "Retrieve original uncompressed content from Headroom's compression store. Use when compressed context mentions a hash and you need the full details. Pass the hash from the compression marker (24 hex characters). Retrieval is by hash and always returns the full original content.",
@@ -78,6 +83,7 @@ var fs = nodeRequire("node:fs");
 var BASE_URL_HEADER = "x-headroom-base-url";
 var ORIGINAL_PATH_HEADER = "x-headroom-original-path";
 var PROJECT_HEADER = "x-headroom-project";
+var SESSION_TOKEN_HEADER = "x-headroom-session-token";
 var PROXY_ENV = "HEADROOM_OPENCODE_TRANSPORT_PROXY_URL";
 var EXCLUDE_HOSTS_ENV = "HEADROOM_OPENCODE_EXCLUDE_HOSTS";
 var STATE_KEY = /* @__PURE__ */ Symbol.for("headroom.opencode.transport");
@@ -134,6 +140,9 @@ function injectOptionsEnv(args, optionIndex, state) {
   const callback = typeof nextArgs.at(-1) === "function" ? nextArgs.pop() : void 0;
   const existing = isOptions(nextArgs[optionIndex]) ? { ...nextArgs[optionIndex] } : {};
   existing.env = withShimEnv(existing.env, state.proxyUrl, state.excludeHosts);
+  if (process.platform === "win32" && existing.windowsHide === void 0) {
+    existing.windowsHide = true;
+  }
   if (isOptions(nextArgs[optionIndex])) {
     nextArgs[optionIndex] = existing;
   } else {
@@ -204,7 +213,10 @@ function isExcludedHost(hostname3, excludeHosts) {
   const normalized = hostname3.toLowerCase().replace(/^\[|\]$/g, "");
   return excludeHosts.some((host) => normalized === host || normalized.endsWith(`.${host}`));
 }
-function shouldRoute(url2, proxy, excludeHosts) {
+function isLlmEndpointPath(pathname) {
+  return pathname.endsWith("/chat/completions") || pathname.endsWith("/responses") || pathname.endsWith("/messages") || pathname.endsWith(":generateContent") || pathname.endsWith(":streamGenerateContent");
+}
+function isRoutableUpstream(url2, proxy, excludeHosts) {
   if (url2.protocol !== "http:" && url2.protocol !== "https:") {
     return false;
   }
@@ -219,6 +231,16 @@ function shouldRoute(url2, proxy, excludeHosts) {
   }
   return true;
 }
+function shouldRoute(url2, proxy, excludeHosts) {
+  return isRoutableUpstream(url2, proxy, excludeHosts) && isLlmEndpointPath(url2.pathname);
+}
+function modelBaseRoutesThroughProxy(baseUrl, proxyUrl, excludeHosts = []) {
+  try {
+    return isRoutableUpstream(new URL(baseUrl), normalizeProxyUrl(proxyUrl), excludeHosts);
+  } catch {
+    return false;
+  }
+}
 function routedUrl(upstream, proxy) {
   return new URL(`${upstream.pathname}${upstream.search}`, proxy.origin);
 }
@@ -253,7 +275,7 @@ function requestUrl(input) {
   }
   return new URL(String(input));
 }
-function mergeFetchHeaders(input, init, upstream, originalPath = void 0, project = void 0) {
+function mergeFetchHeaders(input, init, upstream, originalPath = void 0, project = void 0, sessionToken = void 0) {
   const headers = new Headers(input instanceof Request ? input.headers : void 0);
   if (init?.headers) {
     new Headers(init.headers).forEach((value, key) => headers.set(key, value));
@@ -268,9 +290,12 @@ function mergeFetchHeaders(input, init, upstream, originalPath = void 0, project
   if (project) {
     headers.set(PROJECT_HEADER, project);
   }
+  if (sessionToken) {
+    headers.set(SESSION_TOKEN_HEADER, sessionToken);
+  }
   return headers;
 }
-function withRoutedFetchInput(input, init, proxy, project, excludeHosts) {
+function withRoutedFetchInput(input, init, proxy, project, excludeHosts, sessionToken) {
   const upstream = requestUrl(input);
   if (!shouldRoute(upstream, proxy, excludeHosts)) {
     return [input, init];
@@ -278,7 +303,7 @@ function withRoutedFetchInput(input, init, proxy, project, excludeHosts) {
   const { url: nextUrl, originalPath } = routedUrlForOpenCode(upstream, proxy);
   const nextInit = {
     ...init,
-    headers: mergeFetchHeaders(input, init, upstream, originalPath, project)
+    headers: mergeFetchHeaders(input, init, upstream, originalPath, project, sessionToken)
   };
   if (input instanceof Request) {
     return [new Request(nextUrl, input), nextInit];
@@ -324,7 +349,7 @@ function urlFromRequestOptions(options) {
     return void 0;
   }
 }
-function headersForNodeRequest(options, upstream, originalPath, project) {
+function headersForNodeRequest(options, upstream, originalPath, project, sessionToken) {
   const headers = new Headers(options.headers);
   headers.set(BASE_URL_HEADER, upstream.origin);
   if (originalPath) {
@@ -333,6 +358,9 @@ function headersForNodeRequest(options, upstream, originalPath, project) {
   if (project) {
     headers.set(PROJECT_HEADER, project);
   }
+  if (sessionToken) {
+    headers.set(SESSION_TOKEN_HEADER, sessionToken);
+  }
   headers.delete("host");
   const result = {};
   headers.forEach((value, key) => {
@@ -340,7 +368,7 @@ function headersForNodeRequest(options, upstream, originalPath, project) {
   });
   return result;
 }
-function routedNodeOptions(parts, proxy, project, excludeHosts) {
+function routedNodeOptions(parts, proxy, project, excludeHosts, sessionToken) {
   if (!parts.url || !shouldRoute(parts.url, proxy, excludeHosts)) {
     return void 0;
   }
@@ -371,7 +399,7 @@ function routedNodeOptions(parts, proxy, project, excludeHosts) {
     hostname: nextUrl.hostname,
     port: nextUrl.port || void 0,
     path: `${nextUrl.pathname}${nextUrl.search}`,
-    headers: headersForNodeRequest(parts.options, parts.url, originalPath, project)
+    headers: headersForNodeRequest(parts.options, parts.url, originalPath, project, sessionToken)
   };
 }
 function wrapRequest(originalHttpRequest, originalHttpsRequest, originalRequest) {
@@ -382,7 +410,7 @@ function wrapRequest(originalHttpRequest, originalHttpsRequest, originalRequest)
     }
     const proxy = normalizeProxyUrl(state.proxyUrl);
     const parts = splitNodeArgs(args);
-    const nextOptions = routedNodeOptions(parts, proxy, state.project, state.excludeHosts);
+    const nextOptions = routedNodeOptions(parts, proxy, state.project, state.excludeHosts, state.sessionToken);
     if (!nextOptions) {
       return Reflect.apply(originalRequest, this, args);
     }
@@ -399,18 +427,8 @@ function wrapGet(request) {
   };
 }
 function wrapHttp2Connect(originalConnect) {
-  return function headroomHttp2Connect(authority, ...args) {
-    const state = getState();
-    if (state) {
-      const proxy = normalizeProxyUrl(state.proxyUrl);
-      const upstream = authority instanceof URL ? authority : new URL(String(authority));
-      if (shouldRoute(upstream, proxy, state.excludeHosts)) {
-        throw new Error(
-          `Headroom OpenCode wrap blocked direct HTTP/2 connection to ${upstream.origin}. Use fetch, http, or https so traffic can be routed through Headroom.`
-        );
-      }
-    }
-    return Reflect.apply(originalConnect, this, [authority, ...args]);
+  return function headroomHttp2Connect(...args) {
+    return Reflect.apply(originalConnect, this, args);
   };
 }
 function installHeadroomTransport(options) {
@@ -422,6 +440,7 @@ function installHeadroomTransport(options) {
     existing.project = options.project;
     existing.excludeHosts = excludeHosts;
     existing.debug = Boolean(options.debug);
+    existing.sessionToken = options.sessionToken;
     installProcessEnv(options.proxyUrl, excludeHosts);
     return () => uninstallHeadroomTransport();
   }
@@ -431,6 +450,7 @@ function installHeadroomTransport(options) {
     project: options.project,
     excludeHosts,
     debug: Boolean(options.debug),
+    sessionToken: options.sessionToken,
     originalFetch: globalThis.fetch,
     originalHttpRequest: http.request,
     originalHttpGet: http.get,
@@ -450,7 +470,7 @@ function installHeadroomTransport(options) {
       return state.originalFetch(...args);
     }
     const proxy = normalizeProxyUrl(current.proxyUrl);
-    const [nextInput, nextInit] = withRoutedFetchInput(args[0], args[1], proxy, current.project, current.excludeHosts);
+    const [nextInput, nextInit] = withRoutedFetchInput(args[0], args[1], proxy, current.project, current.excludeHosts, current.sessionToken);
     return state.originalFetch(nextInput, nextInit);
   };
   http.request = wrapRequest(state.originalHttpRequest, state.originalHttpsRequest, state.originalHttpRequest);
@@ -12908,14 +12928,59 @@ function date4(params) {
 config(en_default());
 
 // src/plugin.ts
+var HEADROOM_PLUGIN_ID = "headroom";
 function normalizeProxyUrl2(url2) {
-  return url2.replace(/\/+$/, "");
+  return trimTrailingSlashes(url2);
 }
 function resolveProxyUrl(options) {
   return normalizeProxyUrl2(
     options?.proxyUrl ?? process.env.HEADROOM_PROXY_URL ?? process.env.HEADROOM_BASE_URL ?? getDefaultProxyUrl()
   );
 }
+function resolveSessionToken(options) {
+  return options?.sessionToken ?? process.env.HEADROOM_OPENCODE_SESSION_TOKEN;
+}
+function resolveExcludeHosts(options) {
+  return normalizeExcludeHosts(options?.excludeHosts ?? process.env[EXCLUDE_HOSTS_ENV] ?? "");
+}
+function headroomShellEnv(proxyUrl, project, options) {
+  return {
+    HEADROOM_ACTIVE: "1",
+    HEADROOM_PROXY_URL: proxyUrl,
+    HEADROOM_PROJECT: project,
+    ...options.backend ? { HEADROOM_BACKEND: options.backend } : {}
+  };
+}
+function openAiWireSuffix(pkg) {
+  if (!pkg?.startsWith("@opencode/ai/providers/")) return void 0;
+  if (pkg === "@opencode/ai/providers/openai-compatible" || pkg.endsWith("/chat")) {
+    return "/chat/completions";
+  }
+  if (pkg.endsWith("-responses") || pkg.endsWith("/responses")) return "/responses";
+  return void 0;
+}
+function routeModelsThroughProxy(models, proxyUrl, project, excludeHosts, sessionToken) {
+  for (const model of models.list()) {
+    const providerID = String(model.providerID);
+    const modelID = String(model.id);
+    const provider = models.provider.get(providerID)?.provider;
+    const suffix = openAiWireSuffix(model.package ?? provider?.package);
+    const baseURL = model.settings?.baseURL ?? provider?.settings?.baseURL;
+    if (!suffix || typeof baseURL !== "string") continue;
+    if (!modelBaseRoutesThroughProxy(baseURL, proxyUrl, excludeHosts)) continue;
+    const upstream = new URL(baseURL);
+    models.update(providerID, modelID, (draft) => {
+      draft.settings = { ...draft.settings, baseURL: `${proxyUrl}/v1` };
+      draft.headers = {
+        ...draft.headers,
+        [BASE_URL_HEADER]: upstream.origin,
+        [ORIGINAL_PATH_HEADER]: `${trimTrailingSlashes(upstream.pathname)}${suffix}`,
+        [PROJECT_HEADER]: project,
+        ...sessionToken ? { [SESSION_TOKEN_HEADER]: sessionToken } : {}
+      };
+    });
+  }
+}
 var HeadroomPlugin = async (input, options = {}) => {
   const pluginOptions = options;
   const proxyUrl = resolveProxyUrl(pluginOptions);
@@ -12925,7 +12990,8 @@ var HeadroomPlugin = async (input, options = {}) => {
     proxyUrl,
     project,
     excludeHosts: pluginOptions.excludeHosts,
-    debug: pluginOptions.debug
+    debug: pluginOptions.debug,
+    sessionToken: resolveSessionToken(pluginOptions)
   });
   return {
     dispose: async () => {
@@ -12943,24 +13009,70 @@ var HeadroomPlugin = async (input, options = {}) => {
       })
     },
     "shell.env": async (_input, output) => {
-      output.env.HEADROOM_ACTIVE = "1";
-      output.env.HEADROOM_PROXY_URL = proxyUrl;
-      output.env.HEADROOM_PROJECT = project;
-      if (pluginOptions.backend) {
-        output.env.HEADROOM_BACKEND = pluginOptions.backend;
-      }
+      Object.assign(output.env, headroomShellEnv(proxyUrl, project, pluginOptions));
     }
   };
 };
-var plugin_default = HeadroomPlugin;
+var headroomSetup = async (ctx) => {
+  const pluginOptions = ctx.options;
+  const proxyUrl = resolveProxyUrl(pluginOptions);
+  const project = pluginOptions.project ?? ctx.location.project.id ?? ctx.location.directory;
+  const retrieveTool = createHeadroomRetrieveTool({ proxyBaseUrl: proxyUrl });
+  const excludeHosts = resolveExcludeHosts(pluginOptions);
+  const sessionToken = resolveSessionToken(pluginOptions);
+  const uninstallTransport = installHeadroomTransport({
+    proxyUrl,
+    project,
+    excludeHosts,
+    debug: pluginOptions.debug,
+    sessionToken
+  });
+  try {
+    await ctx.model.transform((models) => {
+      routeModelsThroughProxy(models, proxyUrl, project, excludeHosts, sessionToken);
+    });
+    await ctx.tool.transform((editor) => {
+      editor.add({
+        name: retrieveTool.name,
+        description: retrieveTool.description,
+        input: retrieveTool.parameters,
+        // Offer the tool directly, like OpenCode's built-ins, rather than only
+        // through the code-mode `execute` tool.
+        options: { codemode: false },
+        async execute(args) {
+          return { content: await retrieveTool.execute(args) };
+        }
+      });
+    });
+    await ctx.shell.hook("create.before", (shell) => {
+      Object.assign(shell.env, headroomShellEnv(proxyUrl, project, pluginOptions));
+    });
+  } catch (error45) {
+    uninstallTransport();
+    throw error45;
+  }
+  return () => {
+    uninstallTransport();
+  };
+};
+var HeadroomOpenCodePlugin = {
+  id: HEADROOM_PLUGIN_ID,
+  server: HeadroomPlugin,
+  setup: headroomSetup
+};
+var plugin_default = HeadroomOpenCodePlugin;
 
 export {
   setDefaultProxyUrl,
   getDefaultProxyUrl,
+  trimTrailingSlashes,
   createHeadroomRetrieveTool,
   compressWithHeadroom,
   installHeadroomTransport,
+  HEADROOM_PLUGIN_ID,
   HeadroomPlugin,
+  headroomSetup,
+  HeadroomOpenCodePlugin,
   plugin_default
 };
-//# sourceMappingURL=chunk-6I5ODRCW.js.map
+//# sourceMappingURL=chunk-XS6Z2EJR.js.map