cartethyia 2.7.1 → 2.7.2

package/src/network/outbound-fetch.ts

@@ -1,226 +1,281 @@
-// Validated fetch: SSRF-guarded outbound fetch with optional pool-agent support.
-import { GatewayError } from "../protocol/gateway-error";
-import { Agent as HttpAgent } from "node:http";
-import { Agent as HttpsAgent } from "node:https";
-import { resolveAllAddresses, validateResolvedAddresses } from "./ssrf";
-import type { SsrfPolicy } from "../config/network";
-import { isProxyAgentPair, type ProxyAgentPair } from "./pool/agent";
-import { metrics } from "../observability/metrics";
-import { trackNetworkCall } from "../observability/performance-metrics";
-// Validated fetch — single egress with ProxyAgent support
-export interface ValidatedFetchOptions {
-  readonly fetchFn?: typeof fetch;
-  readonly policy?: SsrfPolicy;
-  readonly maxRedirects?: number;
-  readonly resolveFn?: (hostname: string, signal: AbortSignal) => Promise<readonly string[]>;
-  readonly agent?: HttpAgent | HttpsAgent | ProxyAgentPair;
-  /**
-   * Proxy URL to route the dial through, forwarded to the runtime-native fetch
-   * (`proxy` option). Pool egress passes the pool's endpoint here; without it
-   * a request that should leave through a proxy leaves directly.
-   */
-  readonly proxyUrl?: string;
-}
-export type ValidatedFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-
-/**
- * Whether a configured pool/relay agent owns this dial. When it does, the
- * proxy resolves the upstream target itself, so the local resolve below is an
- * advisory SSRF check rather than a prerequisite for egress.
- */
-
-/**
- * Builds the application-relay request used by hosted relay front doors.
- * These endpoints intentionally do not receive CONNECT: they accept the
- * target origin/path in headers and perform the upstream fetch themselves,
- * matching the 21-beta relay contract.
- */
-function relayRequest(
-  relayEndpoint: URL,
-  target: URL,
-  init: RequestInit,
-): { url: URL; init: RequestInit } {
-  const relayUrl = new URL(relayEndpoint.toString());
-  const headers = new Headers(init.headers);
-  headers.delete("host");
-  headers.set("x-relay-target", target.origin);
-  headers.set("x-relay-path", `${target.pathname}${target.search}`);
-  if (relayUrl.username || relayUrl.password) {
-    const credentials = `${decodeURIComponent(relayUrl.username)}:${decodeURIComponent(relayUrl.password)}`;
-    headers.set("x-relay-auth", `Basic ${Buffer.from(credentials).toString("base64")}`);
-    relayUrl.username = "";
-    relayUrl.password = "";
-  }
-  return { url: relayUrl, init: { ...init, headers } };
-}
-
-const CREDENTIAL_HEADERS = ["authorization", "cookie", "proxy-authorization"] as const;
-
-function stripCredentialsOnCrossOrigin(
-  headersInit: HeadersInit | undefined,
-): Headers {
-  const headers = new Headers(headersInit);
-  for (const name of CREDENTIAL_HEADERS) headers.delete(name);
-  return headers;
-}
-
-/**
- * The injected dialer. `fetchFn` is the seam offline suites use to record
- * requests without a socket; the runtime fetch is the only other dialer.
- */
-function dialer(options: ValidatedFetchOptions): typeof fetch {
-  return options.fetchFn ?? fetch;
-}
-
-/**
- * One dial, always through `fetch`.
- *
- * The runtime's own fetch (Bun/Undici) is the transport the clients this
- * gateway impersonates actually use, and several upstreams meter per client
- * transport fingerprint — OpenCode's anonymous free tier refuses a
- * Node-stack dial with 429 FreeUsageLimitError while accepting the identical
- * bytes over this one. There is no Node `http`/`https` path to choose
- * between: the SSRF resolve/validate pass that runs before this dial is the
- * security boundary, and it is identical for every caller.
- *
- * A configured pool/relay agent is still honored through `dispatcher` when the
- * runtime supports it (Bun and Undici both do); when it is not supported the
- * agent is ignored rather than silently replaced by an unvalidated dial.
- *
- * `content-length` is set for a known-length body only when the caller did not
- * set it: without the header the request falls back to chunked encoding, and
- * some upstream gateways wait for the complete chunked stream before routing
- * the request — an avoidable round trip per dial.
- */
-async function dial(
-  url: URL,
-  init: RequestInit,
-  fetchFn: typeof fetch,
-  proxyUrl: string | undefined,
-): Promise<Response> {
-  const headers = new Headers(init.headers);
-  const rawBody = init.body;
-  if (rawBody !== undefined && rawBody !== null && !headers.has("content-length")) {
-    const bytes =
-      typeof rawBody === "string"
-        ? Buffer.byteLength(rawBody, "utf8")
-        : Buffer.isBuffer(rawBody) || rawBody instanceof Uint8Array
-          ? rawBody.byteLength
-          : (await new Response(rawBody).arrayBuffer()).byteLength;
-    headers.set("content-length", String(bytes));
-  }
-  return await fetchFn(url, {
-    ...init,
-    headers,
-    ...(proxyUrl === undefined ? {} : { proxy: proxyUrl }),
-  });
-}
-
-export function createValidatedFetch(options: ValidatedFetchOptions = {}): ValidatedFetch {
-  const policy = options.policy ?? {};
-  const maxRedirects = options.maxRedirects ?? policy.maxRedirects ?? 3;
-  const resolveFn = options.resolveFn ?? resolveAllAddresses;
-  const fetchFn = dialer(options);
-  const configuredAgent = options.agent;
-  const relayEndpoint = isProxyAgentPair(configuredAgent)
-    ? configuredAgent.relayEndpoint
-    : undefined;
-  const proxyUrl =
-    options.proxyUrl ?? (isProxyAgentPair(configuredAgent) ? configuredAgent.proxyUrl : undefined);
-  return async (input, init = {}) => {
-    const startedAt = performance.now();
-    let url = input instanceof Request ? new URL(input.url) : new URL(input.toString());
-    let requestInit: RequestInit = { ...init, redirect: "manual" };
-    if (input instanceof Request && init.headers === undefined) {
-      requestInit.headers = new Headers(input.headers);
-    }
-    for (let hop = 0; hop <= maxRedirects; hop += 1) {
-      if (url.protocol !== "http:" && url.protocol !== "https:")
-        throw new TypeError("unsupported outbound URL protocol");
-      const signal = requestInit.signal ?? new AbortController().signal;
-      // Every hop — including proxied dials and redirect targets — is resolved
-      // and checked against the SSRF policy. When a proxy agent owns the dial,
-      // the proxy still resolves its own answer, so the check is advisory there;
-      // it deterministically rejects targets whose *advertised* addresses fall
-      // in blocked ranges (literal-IP redirects, private-space DNS, relay abuse).
-      // For a pool/relay-owned dial, the upstream *target* is resolved by the
-      // proxy/relay itself, so local DNS for it is an advisory SSRF check,
-      // not a prerequisite for egress. Operator VPNs routinely break the
-      // system resolver (tunnel DNS that is unreachable or drops queries);
-      const poolDialsTarget = Boolean(configuredAgent || relayEndpoint);
-      let resolvedAddress: string | undefined;
-      let relayResolvedAddress: string | undefined;
-      if (poolDialsTarget) {
-        // The egress dials the pool/relay, which resolves the target itself.
-        // Counting these lets ops confirm how much traffic depends on
-        // proxy-resolved DNS rather than the local system resolver.
-        metrics.cartethyia_proxy_dial_proxy_resolved_total.inc();
-      }
-      try {
-        if (!poolDialsTarget) {
-          const addresses = await resolveFn(url.hostname, signal);
-          validateResolvedAddresses(addresses, policy);
-          resolvedAddress = addresses[0];
-        }
-        if (relayEndpoint) {
-          const relayAddresses = await resolveFn(relayEndpoint.hostname, signal);
-          validateResolvedAddresses(relayAddresses, policy);
-          relayResolvedAddress = relayAddresses[0];
-          if (!relayResolvedAddress)
-            throw new TypeError(`no validated address for ${relayEndpoint.hostname}`);
-        }
-      } catch (error) {
-        // A pool/relay-owned dial still needs its egress host locally; only
-        // the advisory target lookup may degrade.
-        if (relayEndpoint && !relayResolvedAddress) throw error;
-        if (!poolDialsTarget) throw new TypeError(`no validated address for ${url.hostname}`);
-      }
-      if (!poolDialsTarget && !resolvedAddress)
-        throw new TypeError(`no validated address for ${url.hostname}`);
-      let response: Response;
-      if (relayEndpoint) {
-        const relay = relayRequest(relayEndpoint, url, requestInit);
-        // The relay front door is reached directly: it reads the target from
-        // `x-relay-target`/`x-relay-path` and performs the upstream fetch
-        // itself, so the runtime fetch must NOT be given `proxy` here — that
-        // would make it attempt a CONNECT tunnel against the relay, which a
-        // serverless front door refuses (400).
-        response = await dial(relay.url, relay.init, fetchFn, undefined);
-      } else {
-        response = await dial(url, requestInit, fetchFn, proxyUrl);
-      }
-      if (response.status < 300 || response.status >= 400) {
-        trackNetworkCall(url.hostname, performance.now() - startedAt);
-        return response;
-      }
-      const location = response.headers.get("location");
-      if (!location) {
-        trackNetworkCall(url.hostname, performance.now() - startedAt);
-        return response;
-      }
-      // The redirect response body is never consumed: release its socket
-      // before following the next hop instead of leaving it open.
-      await response.body?.cancel().catch(() => undefined);
-      const nextUrl = new URL(location, url);
-      const isCrossOriginRedirect = nextUrl.origin !== url.origin;
-      if (isCrossOriginRedirect) {
-        requestInit = { ...requestInit, headers: stripCredentialsOnCrossOrigin(requestInit.headers) };
-      }
-      if (isCrossOriginRedirect && (response.status === 307 || response.status === 308)) {
-        const method = (requestInit.method ?? "GET").toUpperCase();
-        if (method !== "GET" && method !== "HEAD" && requestInit.body !== undefined) {
-          throw new GatewayError("invalid_request", 400, "cross-origin redirect with body blocked");
-        }
-      }
-      url = nextUrl;
-      if (response.status === 301 || response.status === 302 || response.status === 303) {
-        const method = (requestInit.method ?? "GET").toUpperCase();
-        if (method !== "GET" && method !== "HEAD") {
-          const { body: _body, ...withoutBody } = requestInit;
-          requestInit = { ...withoutBody, method: "GET" };
-        }
-      }
-    }
-    throw new Error("outbound redirect limit exceeded");
-  };
-}
+// Validated fetch: SSRF-guarded outbound fetch with optional pool-agent support.
+import { GatewayError } from "../protocol/gateway-error";
+import { Agent as HttpAgent } from "node:http";
+import { Agent as HttpsAgent } from "node:https";
+import { Agent as UndiciAgent, fetch as undiciFetch, type UndiciRequestInit } from "undici";
+import { SocksProxyAgent } from "socks-proxy-agent";
+import { resolveAllAddresses, validateResolvedAddresses } from "./ssrf";
+import type { SsrfPolicy } from "../config/network";
+import { isProxyAgentPair, type ProxyAgentPair } from "./pool/agent";
+import { metrics } from "../observability/metrics";
+import { trackNetworkCall } from "../observability/performance-metrics";
+// Validated fetch — single egress with ProxyAgent support
+export interface ValidatedFetchOptions {
+  readonly fetchFn?: typeof fetch;
+  readonly policy?: SsrfPolicy;
+  readonly maxRedirects?: number;
+  readonly resolveFn?: (hostname: string, signal: AbortSignal) => Promise<readonly string[]>;
+  readonly agent?: HttpAgent | HttpsAgent | ProxyAgentPair;
+  /**
+   * Proxy URL to route the dial through, forwarded to the runtime-native fetch
+   * (`proxy` option). Pool egress passes the pool's endpoint here; without it
+   * a request that should leave through a proxy leaves directly.
+   */
+  readonly proxyUrl?: string;
+  /**
+   * Fetch implementation used for SOCKS5 dials (via the undici dispatcher).
+   * Defaults to undici's fetch; injectable for offline tests.
+   */
+  readonly socksFetch?: (input: RequestInfo | URL, init?: UndiciRequestInit) => Promise<Response>;
+}
+export type ValidatedFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+
+/**
+ * Whether a configured pool/relay agent owns this dial. When it does, the
+ * proxy resolves the upstream target itself, so the local resolve below is an
+ * advisory SSRF check rather than a prerequisite for egress.
+ */
+
+/**
+ * Builds the application-relay request used by hosted relay front doors.
+ * These endpoints intentionally do not receive CONNECT: they accept the
+ * target origin/path in headers and perform the upstream fetch themselves,
+ * matching the 21-beta relay contract.
+ */
+function relayRequest(
+  relayEndpoint: URL,
+  target: URL,
+  init: RequestInit,
+): { url: URL; init: RequestInit } {
+  const relayUrl = new URL(relayEndpoint.toString());
+  const headers = new Headers(init.headers);
+  headers.delete("host");
+  headers.set("x-relay-target", target.origin);
+  headers.set("x-relay-path", `${target.pathname}${target.search}`);
+  if (relayUrl.username || relayUrl.password) {
+    const credentials = `${decodeURIComponent(relayUrl.username)}:${decodeURIComponent(relayUrl.password)}`;
+    headers.set("x-relay-auth", `Basic ${Buffer.from(credentials).toString("base64")}`);
+    relayUrl.username = "";
+    relayUrl.password = "";
+  }
+  return { url: relayUrl, init: { ...init, headers } };
+}
+
+const CREDENTIAL_HEADERS = ["authorization", "cookie", "proxy-authorization"] as const;
+
+function stripCredentialsOnCrossOrigin(
+  headersInit: HeadersInit | undefined,
+): Headers {
+  const headers = new Headers(headersInit);
+  for (const name of CREDENTIAL_HEADERS) headers.delete(name);
+  return headers;
+}
+
+/**
+ * The injected dialer. `fetchFn` is the seam offline suites use to record
+ * requests without a socket; the runtime fetch is the only other dialer.
+ */
+function dialer(options: ValidatedFetchOptions): typeof fetch {
+  return options.fetchFn ?? fetch;
+}
+
+/**
+ * Builds the `undici` dispatcher that routes a dial through a SOCKS5 pool
+ * agent. The runtime-native fetch does not support `socks5://` proxies
+ * (`UnsupportedProxyProtocol`), so the socks pair drives the transport via
+ * undici's dispatcher instead — no node `http`/`https` adapter is involved.
+ */
+let socksDispatcherCache: WeakMap<SocksProxyAgent, UndiciAgent> | undefined;
+function socksDispatcherFor(agent: SocksProxyAgent): UndiciAgent {
+  socksDispatcherCache ??= new WeakMap();
+  let dispatcher = socksDispatcherCache.get(agent);
+  if (!dispatcher) {
+    dispatcher = new UndiciAgent({
+      connect: async (opts) => {
+        const o = opts as {
+          hostname?: string;
+          port?: number | string;
+          family?: number;
+          lookup?: (hostname: string, options: unknown, cb: (err: Error | null, addresses: unknown) => void) => void;
+        };
+        return await agent.connect(
+          {} as never,
+          {
+            host: o.hostname ?? "localhost",
+            port: Number(o.port ?? 80),
+            ...(o.family === undefined ? {} : { family: o.family }),
+            ...(o.lookup === undefined ? {} : { lookup: o.lookup }),
+          } as never,
+        );
+      },
+    });
+    socksDispatcherCache.set(agent, dispatcher);
+  }
+  return dispatcher;
+}
+
+/**
+ * One dial, always through `fetch`.
+ *
+ * The runtime's own fetch (Bun/Undici) is the transport the clients this
+ * gateway impersonates actually use, and several upstreams meter per client
+ * transport fingerprint — OpenCode's anonymous free tier refuses a
+ * Node-stack dial with 429 FreeUsageLimitError while accepting the identical
+ * bytes over this one. There is no Node `http`/`https` path to choose
+ * between: the SSRF resolve/validate pass that runs before this dial is the
+ * security boundary, and it is identical for every caller.
+ *
+ * A configured pool/relay agent is still honored through `dispatcher` when the
+ * runtime supports it (Bun and Undici both do); when it is not supported the
+ * agent is ignored rather than silently replaced by an unvalidated dial.
+ *
+ * `content-length` is set for a known-length body only when the caller did not
+ * set it: without the header the request falls back to chunked encoding, and
+ * some upstream gateways wait for the complete chunked stream before routing
+ * the request — an avoidable round trip per dial.
+ */
+async function dial(
+  url: URL,
+  init: RequestInit,
+  fetchFn: typeof fetch,
+  proxyUrl: string | undefined,
+  dispatcher?: UndiciAgent,
+  socksFetch: (input: RequestInfo | URL, init?: UndiciRequestInit) => Promise<Response> = undiciFetch,
+): Promise<Response> {
+  const headers = new Headers(init.headers);
+  const rawBody = init.body;
+  if (rawBody !== undefined && rawBody !== null && !headers.has("content-length")) {
+    const bytes =
+      typeof rawBody === "string"
+        ? Buffer.byteLength(rawBody, "utf8")
+        : Buffer.isBuffer(rawBody) || rawBody instanceof Uint8Array
+          ? rawBody.byteLength
+          : (await new Response(rawBody).arrayBuffer()).byteLength;
+    headers.set("content-length", String(bytes));
+  }
+  if (dispatcher !== undefined) {
+    return await socksFetch(url, {
+      ...init,
+      headers,
+      dispatcher,
+    });
+  }
+  return await fetchFn(url, {
+    ...init,
+    headers,
+    ...(proxyUrl === undefined ? {} : { proxy: proxyUrl }),
+  });
+}
+
+export function createValidatedFetch(options: ValidatedFetchOptions = {}): ValidatedFetch {
+  const policy = options.policy ?? {};
+  const maxRedirects = options.maxRedirects ?? policy.maxRedirects ?? 3;
+  const resolveFn = options.resolveFn ?? resolveAllAddresses;
+  const fetchFn = dialer(options);
+  const configuredAgent = options.agent;
+  const relayEndpoint = isProxyAgentPair(configuredAgent)
+    ? configuredAgent.relayEndpoint
+    : undefined;
+  const socksAgent = isProxyAgentPair(configuredAgent)
+    ? configuredAgent.socks
+    : undefined;
+  const socksFetch = options.socksFetch ?? undiciFetch;
+  const proxyUrl =
+    options.proxyUrl ?? (isProxyAgentPair(configuredAgent) ? configuredAgent.proxyUrl : undefined);
+  return async (input, init = {}) => {
+    const startedAt = performance.now();
+    let url = input instanceof Request ? new URL(input.url) : new URL(input.toString());
+    let requestInit: RequestInit = { ...init, redirect: "manual" };
+    if (input instanceof Request && init.headers === undefined) {
+      requestInit.headers = new Headers(input.headers);
+    }
+    for (let hop = 0; hop <= maxRedirects; hop += 1) {
+      if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new TypeError("unsupported outbound URL protocol");
+      const signal = requestInit.signal ?? new AbortController().signal;
+      // Every hop — including proxied dials and redirect targets — is resolved
+      // and checked against the SSRF policy. When a proxy agent owns the dial,
+      // the proxy still resolves its own answer, so the check is advisory there;
+      // it deterministically rejects targets whose *advertised* addresses fall
+      // in blocked ranges (literal-IP redirects, private-space DNS, relay abuse).
+      // For a pool/relay-owned dial, the upstream *target* is resolved by the
+      // proxy/relay itself, so local DNS for it is an advisory SSRF check,
+      // not a prerequisite for egress. Operator VPNs routinely break the
+      // system resolver (tunnel DNS that is unreachable or drops queries);
+      const poolDialsTarget = Boolean(configuredAgent || relayEndpoint);
+      let resolvedAddress: string | undefined;
+      let relayResolvedAddress: string | undefined;
+      if (poolDialsTarget) {
+        // The egress dials the pool/relay, which resolves the target itself.
+        // Counting these lets ops confirm how much traffic depends on
+        // proxy-resolved DNS rather than the local system resolver.
+        metrics.cartethyia_proxy_dial_proxy_resolved_total.inc();
+      }
+      try {
+        if (!poolDialsTarget) {
+          const addresses = await resolveFn(url.hostname, signal);
+          validateResolvedAddresses(addresses, policy);
+          resolvedAddress = addresses[0];
+        }
+        if (relayEndpoint) {
+          const relayAddresses = await resolveFn(relayEndpoint.hostname, signal);
+          validateResolvedAddresses(relayAddresses, policy);
+          relayResolvedAddress = relayAddresses[0];
+          if (!relayResolvedAddress)
+            throw new TypeError(`no validated address for ${relayEndpoint.hostname}`);
+        }
+      } catch (error) {
+        // A pool/relay-owned dial still needs its egress host locally; only
+        // the advisory target lookup may degrade.
+        if (relayEndpoint && !relayResolvedAddress) throw error;
+        if (!poolDialsTarget) throw new TypeError(`no validated address for ${url.hostname}`);
+      }
+      if (!poolDialsTarget && !resolvedAddress)
+        throw new TypeError(`no validated address for ${url.hostname}`);
+      let response: Response;
+      if (relayEndpoint) {
+        const relay = relayRequest(relayEndpoint, url, requestInit);
+        // The relay front door is reached directly: it reads the target from
+        // `x-relay-target`/`x-relay-path` and performs the upstream fetch
+        // itself, so the runtime fetch must NOT be given `proxy` here — that
+        // would make it attempt a CONNECT tunnel against the relay, which a
+        // serverless front door refuses (400).
+        response = await dial(relay.url, relay.init, fetchFn, undefined);
+      } else {
+        response = await dial(url, requestInit, fetchFn, proxyUrl, socksAgent ? socksDispatcherFor(socksAgent) : undefined, socksFetch);
+      }
+      if (response.status < 300 || response.status >= 400) {
+        trackNetworkCall(url.hostname, performance.now() - startedAt);
+        return response;
+      }
+      const location = response.headers.get("location");
+      if (!location) {
+        trackNetworkCall(url.hostname, performance.now() - startedAt);
+        return response;
+      }
+      // The redirect response body is never consumed: release its socket
+      // before following the next hop instead of leaving it open.
+      await response.body?.cancel().catch(() => undefined);
+      const nextUrl = new URL(location, url);
+      const isCrossOriginRedirect = nextUrl.origin !== url.origin;
+      if (isCrossOriginRedirect) {
+        requestInit = { ...requestInit, headers: stripCredentialsOnCrossOrigin(requestInit.headers) };
+      }
+      if (isCrossOriginRedirect && (response.status === 307 || response.status === 308)) {
+        const method = (requestInit.method ?? "GET").toUpperCase();
+        if (method !== "GET" && method !== "HEAD" && requestInit.body !== undefined) {
+          throw new GatewayError("invalid_request", 400, "cross-origin redirect with body blocked");
+        }
+      }
+      url = nextUrl;
+      if (response.status === 301 || response.status === 302 || response.status === 303) {
+        const method = (requestInit.method ?? "GET").toUpperCase();
+        if (method !== "GET" && method !== "HEAD") {
+          const { body: _body, ...withoutBody } = requestInit;
+          requestInit = { ...withoutBody, method: "GET" };
+        }
+      }
+    }
+    throw new Error("outbound redirect limit exceeded");
+  };
+}

package/src/network/pool/agent.ts

@@ -315,6 +315,12 @@ export interface ProxyAgentPair {
    * the URL is what carries the pool egress.
    */
   readonly proxyUrl?: string;
+  /**
+   * The SOCKS5 agent instance for socks pools. The runtime-native fetch does
+   * not support `socks5://` proxies, so the validated fetcher drives this via
+   * the `undici` dispatcher when the pool is a socks pair.
+   */
+  readonly socks?: SocksProxyAgent;
 }
 
 export function isProxyAgentPair(value: unknown): value is ProxyAgentPair {
@@ -479,6 +485,7 @@ export function createSocks5Agent(
   return {
     http: http as unknown as HttpAgent,
     https: https as unknown as HttpsAgent,
+    socks: http,
     proxyUrl: withCredential(url, credential).toString(),
   };
 }

package/src/providers/default-registry.ts

@@ -714,6 +714,7 @@ export const PROVIDER_CAPABILITIES = {
       responses: "/responses",
     },
     loadAdapter: async () => createApiKeyAdapter(GENERIC_API_KEY_SPECS.ollamacloud),
+    loadModels: async () => (await import("./integrations/ollamacloud-models")).OLLAMACLOUD_MODELS,
     loadQuotaCollector: quotaCapability(() => import("./integrations/ollamacloud-quota"), "fetchOllamaQuota"),
     loadModelDiscovery: openAIModelDiscovery("ollamacloud", { headers: (credential) => ({ authorization: `Bearer ${credential}` }) }),
   },

package/src/providers/integrations/ollamacloud-models.ts

@@ -0,0 +1,50 @@
+/**
+ * Ollama Cloud (`ollamacloud`) model catalog.
+ *
+ * The provider is discovery-backed: live `/v1/models` on `https://ollama.com/v1`
+ * is the primary source and publishes every model's real context window. This
+ * static floor keeps the models an operator most likely wants routable before
+ * any account sync — and pins the verified live limits so a cold process never
+ * falls back to the invented 200k/64k defaults.
+ *
+ * Limits below are taken from the live `/v1/models` roster (verified 2026-10):
+ * - `gemma4:31b` -> 262144 ctx, text+image, thinking none/medium
+ * - `gpt-oss:20b` / `gpt-oss:120b` -> 131072 ctx, text, reasoning low/med/high
+ * - `nemotron-3-nano:30b` / `nemotron-3-super` / `nemotron-3-ultra`
+ *   -> 262144 ctx, text, thinking none/medium
+ *
+ * All six serve the chat wire (none is a Responses-native id), and all report
+ * `supported_in_api: true` on the live roster.
+ */
+import { defineModel } from "../provider-model-definition";
+import type { ModelDefinition } from "../provider-model-definition";
+
+export const OLLAMACLOUD_PROVIDER_ID = "ollamacloud" as const;
+
+/** Chat path below the `/v1`-rooted base. */
+const CHAT_ENDPOINT = "/chat/completions";
+
+type CatalogRow = readonly [id: string, ctx: number, vision: boolean, reasoning: boolean];
+
+function ollamaCloudModel([id, ctx, vision, reasoning]: CatalogRow): ModelDefinition {
+  return defineModel({
+    id,
+    providerId: OLLAMACLOUD_PROVIDER_ID,
+    wireFamily: "chat",
+    endpoint: CHAT_ENDPOINT,
+    ctx,
+    vision,
+    reasoning,
+    toolCall: true,
+  });
+}
+
+/** Static Ollama Cloud floor; live discovery adds to it per account. */
+export const OLLAMACLOUD_MODELS: readonly ModelDefinition[] = [
+  ["gemma4:31b", 262_144, true, true] as const,
+  ["gpt-oss:20b", 131_072, false, true] as const,
+  ["gpt-oss:120b", 131_072, false, true] as const,
+  ["nemotron-3-nano:30b", 262_144, false, true] as const,
+  ["nemotron-3-super", 262_144, false, true] as const,
+  ["nemotron-3-ultra", 262_144, false, true] as const,
+].map(ollamaCloudModel);

package/src/providers/integrations/qoder/qoder-oauth.ts

@@ -150,7 +150,18 @@ export interface QoderOAuthState {
 
 /** Reads the persisted Qoder identity; `undefined` when the account predates it. */
 export function parseQoderOAuthState(value: unknown): QoderOAuthState | undefined {
-  const root = record(value);
+  let root = record(value);
+  if (root === undefined && typeof value === "string") {
+    // The credential loader stores `auth_state` as JSON text in SQLite, so
+    // the resolver hands the adapter a string when the cache was cold. Parse
+    // it before giving up — a login that works once must work again after the
+    // cache is evicted.
+    try {
+      root = record(JSON.parse(value));
+    } catch {
+      return undefined;
+    }
+  }
   if (root === undefined) return undefined;
   const userId = nonEmptyTrimmedString(root.userId);
   const machineId = nonEmptyTrimmedString(root.machineId);