opencode-ext-connector 0.3.3 → 0.5.0

package/dist/providers/command-code/language-model.js

@@ -2,32 +2,32 @@
 // Licensed under MIT. See THIRD_PARTY_NOTICES.md.
 import { AdapterError, OperationCancelledError } from "../../core/errors.js";
 import { parseProviderId } from "../../core/ids.js";
-import { openHttpBody } from "../../http/read-body.js";
 import { createCommandCodeVersionResolver } from "./cli-version.js";
 import { emitCommandCodeChunks } from "./emit-stream.js";
 import { commandCodeMissingBodyError } from "./errors.js";
+import { openCommandCodeGeneration } from "./open-generation.js";
 import { buildBody, buildHeaders, } from "./request.js";
-import { commandCodeHttpError, createCommandCodeRequestLifecycle, readCommandCodeErrorBody, } from "./request-lifecycle.js";
+import { createCommandCodeRequestLifecycle } from "./request-lifecycle.js";
 import { createCommandCodeSessionId } from "./session.js";
-function buildRequestOptions(options, call, token, cliVersion) {
-    const bodyOptions = {
-        modelId: options.modelId,
-        call,
-        sessionId: options.sessionId,
-    };
+function buildRequestOptions(options) {
+    const { runtime, call, token, cliVersion, bodySnapshot } = options;
     const headerOptions = {
         token,
         cliVersion,
-        sessionId: options.sessionId,
+        sessionId: runtime.sessionId,
     };
+    const headers = {};
+    for (const source of [buildHeaders(headerOptions), runtime.headers ?? {}, call.headers ?? {}]) {
+        for (const [name, value] of Object.entries(source)) {
+            if (value !== undefined) {
+                headers[name.toLowerCase()] = value;
+            }
+        }
+    }
     return {
-        url: `${(options.baseURL ?? "https://api.commandcode.ai").replace(/\/+$/, "")}/alpha/generate`,
-        headers: {
-            ...buildHeaders(headerOptions),
-            ...options.headers,
-            ...Object.fromEntries(Object.entries(call.headers ?? {}).filter((entry) => entry[1] !== undefined)),
-        },
-        body: new TextEncoder().encode(JSON.stringify(buildBody(bodyOptions))),
+        url: `${(runtime.baseURL ?? "https://api.commandcode.ai").replace(/\/+$/, "")}/alpha/generate`,
+        headers,
+        body: new Uint8Array(bodySnapshot),
     };
 }
 function createUsage() {
@@ -66,34 +66,41 @@ async function streamCommandCode(options, call) {
             providerId: parseProviderId("command-code"),
         });
     }
-    const requestOptions = buildRequestOptions(options, call, token, cliVersion);
-    let opened;
+    const bodyOptions = {
+        modelId: options.modelId,
+        call,
+        sessionId: options.sessionId,
+    };
+    const bodySnapshot = new TextEncoder().encode(JSON.stringify(buildBody(bodyOptions)));
+    let generation;
     try {
-        opened = await openHttpBody(options.transport, {
-            method: "POST",
-            url: requestOptions.url,
-            headers: requestOptions.headers,
-            body: requestOptions.body,
-        }, lifecycle.signal);
+        generation = await openCommandCodeGeneration({
+            transport: options.transport,
+            lifecycle,
+            initialToken: token,
+            readAccessToken: options.readAccessToken,
+            createRequest: (accessToken) => {
+                const request = buildRequestOptions({
+                    runtime: options,
+                    call,
+                    token: accessToken,
+                    cliVersion,
+                    bodySnapshot,
+                });
+                return {
+                    method: "POST",
+                    url: request.url,
+                    headers: request.headers,
+                    body: request.body,
+                };
+            },
+        });
     }
     catch (error) {
         lifecycle.dispose();
         throw error;
     }
-    if (opened.status < 200 || opened.status >= 300) {
-        let errorBody;
-        try {
-            errorBody = await readCommandCodeErrorBody(opened.chunks);
-        }
-        catch (error) {
-            lifecycle.abort();
-            throw error;
-        }
-        finally {
-            lifecycle.dispose();
-        }
-        throw commandCodeHttpError(opened.status, errorBody);
-    }
+    const { opened, request } = generation;
     if (!opened.bodyPresent) {
         lifecycle.dispose();
         throw commandCodeMissingBodyError(opened.status);
@@ -124,7 +131,7 @@ async function streamCommandCode(options, call) {
     });
     return {
         stream,
-        request: { body: new TextDecoder().decode(requestOptions.body) },
+        request: { body: request.body === null ? undefined : new TextDecoder().decode(request.body) },
         response: { headers: opened.headers },
     };
 }

package/dist/providers/command-code/open-generation.d.ts

@@ -0,0 +1,16 @@
+import type { HttpRequest, HttpTransport } from "../../core/http.js";
+import { type HttpBodyStream } from "../../http/read-body.js";
+import type { CommandCodeRequestLifecycle } from "./request-lifecycle.js";
+type OpenGenerationOptions = {
+    readonly transport: HttpTransport;
+    readonly lifecycle: CommandCodeRequestLifecycle;
+    readonly initialToken: string;
+    readonly readAccessToken: (signal: AbortSignal) => Promise<string | null>;
+    readonly createRequest: (token: string) => HttpRequest;
+};
+export type OpenedCommandCodeGeneration = {
+    readonly opened: HttpBodyStream;
+    readonly request: HttpRequest;
+};
+export declare function openCommandCodeGeneration(options: OpenGenerationOptions): Promise<OpenedCommandCodeGeneration>;
+export {};

package/dist/providers/command-code/open-generation.js

@@ -0,0 +1,45 @@
+// Derived from brent-weatherall/opencode-commandcode-provider src/model.ts.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { OperationCancelledError } from "../../core/errors.js";
+import { openHttpBody } from "../../http/read-body.js";
+import { commandCodeHttpError, readCommandCodeErrorBody } from "./request-lifecycle.js";
+async function openAttempt(options, request) {
+    const opened = await openHttpBody(options.transport, request, options.lifecycle.signal);
+    return { opened, request };
+}
+async function responseError(opened, lifecycle) {
+    try {
+        const body = await readCommandCodeErrorBody(opened.chunks);
+        return commandCodeHttpError(opened.status, body);
+    }
+    catch (error) {
+        lifecycle.abort();
+        throw error;
+    }
+}
+function successful(opened) {
+    return opened.status >= 200 && opened.status < 300;
+}
+export async function openCommandCodeGeneration(options) {
+    const firstRequest = options.createRequest(options.initialToken);
+    const first = await openAttempt(options, firstRequest);
+    if (successful(first.opened))
+        return first;
+    const firstError = await responseError(first.opened, options.lifecycle);
+    if (first.opened.status !== 401)
+        throw firstError;
+    const reloadedToken = await options.readAccessToken(options.lifecycle.signal);
+    if (options.lifecycle.signal.aborted) {
+        throw new OperationCancelledError("command-code-stream");
+    }
+    if (reloadedToken === null)
+        throw firstError;
+    const candidateRequest = options.createRequest(reloadedToken);
+    if (candidateRequest.headers["authorization"] === firstRequest.headers["authorization"]) {
+        throw firstError;
+    }
+    const second = await openAttempt(options, candidateRequest);
+    if (successful(second.opened))
+        return second;
+    throw await responseError(second.opened, options.lifecycle);
+}

package/dist/providers/cursor/credential-retry.d.ts

@@ -0,0 +1,14 @@
+import type { CursorReplayState } from "./recovery.js";
+export declare function isCursorCredentialRetryEligible(input: {
+    readonly error: unknown;
+    readonly replay: CursorReplayState;
+    readonly retryUsed: boolean;
+}): boolean;
+export type CursorCredentialRetry = {
+    readonly currentToken: () => string;
+    readonly reload: (error: unknown, replay: CursorReplayState, signal: AbortSignal) => Promise<boolean>;
+};
+export declare function createCursorCredentialRetry(options: {
+    readonly initialToken: string;
+    readonly reloadAccessToken: (signal: AbortSignal) => Promise<string | null>;
+}): CursorCredentialRetry;

package/dist/providers/cursor/credential-retry.js

@@ -0,0 +1,26 @@
+import { CursorDirectStreamError } from "./direct-stream.js";
+export function isCursorCredentialRetryEligible(input) {
+    return (!input.retryUsed &&
+        input.error instanceof CursorDirectStreamError &&
+        input.error.bridgeCode === "http-401" &&
+        input.replay.outputEpoch === 0 &&
+        input.replay.checkpointEpoch === null &&
+        !input.replay.toolBoundary);
+}
+export function createCursorCredentialRetry(options) {
+    let currentToken = options.initialToken;
+    let retryUsed = false;
+    return {
+        currentToken: () => currentToken,
+        reload: async (error, replay, signal) => {
+            if (!isCursorCredentialRetryEligible({ error, replay, retryUsed }))
+                return false;
+            retryUsed = true;
+            const reloadedToken = await options.reloadAccessToken(signal);
+            if (reloadedToken === null || reloadedToken === currentToken)
+                return false;
+            currentToken = reloadedToken;
+            return true;
+        },
+    };
+}

package/dist/providers/cursor/direct-run-failure.d.ts

@@ -0,0 +1,8 @@
+import type { CursorDirectSetupCleanup } from "./direct-run-types.js";
+import type { CursorRunSession } from "./run-session.js";
+import type { CursorStreamAdapter } from "./stream-adapter.js";
+export declare function retireCursorSessionForRetry(session: CursorRunSession, cause: unknown): Promise<void>;
+export declare function failCursorDirectRun(logical: {
+    readonly adapter: CursorStreamAdapter;
+    readonly cleanup: CursorDirectSetupCleanup;
+}, session: CursorRunSession | null, error: unknown): Promise<void>;

package/dist/providers/cursor/direct-run-failure.js

@@ -0,0 +1,26 @@
+export async function retireCursorSessionForRetry(session, cause) {
+    try {
+        const retireForRetry = session.retireForRetry;
+        if (retireForRetry === undefined)
+            throw new TypeError("retry retirement is unavailable");
+        await retireForRetry();
+    }
+    catch (retirementError) {
+        throw new AggregateError([cause, retirementError], "Cursor retry retirement failed");
+    }
+}
+export async function failCursorDirectRun(logical, session, error) {
+    try {
+        if (session === null) {
+            logical.cleanup.invalidateCheckpoint();
+            logical.cleanup.invalidateSession();
+        }
+        else
+            await session.abort();
+    }
+    catch (cleanupError) {
+        logical.adapter.fail(new AggregateError([error, cleanupError], "Cursor recovery cleanup failed"));
+        return;
+    }
+    logical.adapter.fail(error);
+}

package/dist/providers/cursor/direct-run-types.d.ts

@@ -25,6 +25,7 @@ export type CursorDirectRunOptions = {
     readonly createSetupCleanup?: (resources: CursorDirectSetupCleanupResources) => CursorDirectSetupCleanup;
     readonly idleTimeoutMs: number;
     readonly modelId: string;
+    readonly reloadAccessToken: (signal: AbortSignal) => Promise<string | null>;
     readonly registry: CursorRunSessionRegistry;
     readonly signal: AbortSignal;
     readonly token: string;

package/dist/providers/cursor/direct-run.js

@@ -3,6 +3,8 @@ import { parseModelId } from "../../core/ids.js";
 import { createCursorBlobStore } from "./blob-store.js";
 import { createCursorCheckpointStore } from "./checkpoint-store.js";
 import { encodeConnectFrame } from "./connect-frame.js";
+import { createCursorCredentialRetry } from "./credential-retry.js";
+import { failCursorDirectRun, retireCursorSessionForRetry } from "./direct-run-failure.js";
 import { consumeCursorDirectAttempt, isCursorRetryableStreamError } from "./direct-stream.js";
 import { cursorMcpDefinitions } from "./exec-reply.js";
 import { cursorPromptText } from "./prompt.js";
@@ -76,13 +78,13 @@ function buildRequest(options, logical, mode) {
             },
     });
 }
-async function openAttempt(options, logical, mode) {
-    const request = buildRequest(options, logical, mode);
+async function openAttempt(options, logical, attempt) {
+    const request = buildRequest(options, logical, attempt.mode);
     let stream = null;
     try {
         stream = await options.bridge.open({
             id: options.createId(),
-            accessToken: options.token,
+            accessToken: attempt.token,
             path: CURSOR_RUN_PATH,
             headers: { "content-type": "application/connect+proto", "connect-protocol-version": "1" },
             signal: options.signal,
@@ -123,27 +125,19 @@ async function openAttempt(options, logical, mode) {
         throw error;
     }
 }
-async function failRun(logical, session, error) {
-    try {
-        if (session === null) {
-            logical.cleanup.invalidateCheckpoint();
-            logical.cleanup.invalidateSession();
-        }
-        else
-            await session.abort();
-    }
-    catch (cleanupError) {
-        logical.adapter.fail(new AggregateError([error, cleanupError], "Cursor recovery cleanup failed"));
-        return;
-    }
-    logical.adapter.fail(error);
-}
 export async function startCursorDirectRun(options) {
     const logical = createLogicalRun(options);
     const planner = createCursorRecoveryPlanner();
+    const credential = createCursorCredentialRetry({
+        initialToken: options.token,
+        reloadAccessToken: options.reloadAccessToken,
+    });
     let session;
     try {
-        session = await openAttempt(options, logical, "initial");
+        session = await openAttempt(options, logical, {
+            mode: "initial",
+            token: credential.currentToken(),
+        });
     }
     catch (error) {
         logical.cleanup.releaseOwnership();
@@ -177,7 +171,25 @@ export async function startCursorDirectRun(options) {
                 const idle = watchdog.expired();
                 watchdog.dispose();
                 if (options.signal.aborted) {
-                    await failRun(logical, session, new OperationCancelledError("cursor-direct-stream"));
+                    await failCursorDirectRun(logical, session, new OperationCancelledError("cursor-direct-stream"));
+                    return;
+                }
+                try {
+                    const changed = await credential.reload(error, logical.adapter.replayState(), options.signal);
+                    if (options.signal.aborted)
+                        throw new OperationCancelledError("cursor-direct-stream");
+                    if (changed) {
+                        await retireCursorSessionForRetry(session, error);
+                        session = null;
+                        session = await openAttempt(options, logical, {
+                            mode: "initial",
+                            token: credential.currentToken(),
+                        });
+                        continue;
+                    }
+                }
+                catch (retryError) {
+                    await failCursorDirectRun(logical, session, retryError);
                     return;
                 }
                 const decision = planner.next({
@@ -190,20 +202,21 @@ export async function startCursorDirectRun(options) {
                         planner.requireRetry(decision, error);
                     }
                     catch (recoveryError) {
-                        await failRun(logical, session, recoveryError);
+                        await failCursorDirectRun(logical, session, recoveryError);
                     }
                     return;
                 }
                 try {
-                    const retireForRetry = session.retireForRetry;
-                    if (retireForRetry === undefined)
-                        throw new TypeError("retry retirement is unavailable");
-                    await retireForRetry();
+                    await retireCursorSessionForRetry(session, error);
+                    session = null;
                     logical.adapter.suspendForRetry();
-                    session = await openAttempt(options, logical, decision.mode);
+                    session = await openAttempt(options, logical, {
+                        mode: decision.mode,
+                        token: credential.currentToken(),
+                    });
                 }
                 catch (retryError) {
-                    await failRun(logical, session, retryError);
+                    await failCursorDirectRun(logical, session, retryError);
                     return;
                 }
             }

package/dist/providers/cursor/direct-runtime.js

@@ -41,7 +41,9 @@ export function createCursorDirectRuntime(options) {
         return bridgeClient;
     };
     const doStream = async (call, modelId) => {
-        const signal = call.abortSignal ?? new AbortController().signal;
+        const signal = call.abortSignal === undefined
+            ? lifecycle.signal
+            : AbortSignal.any([lifecycle.signal, call.abortSignal]);
         if (signal.aborted)
             throw new OperationCancelledError("cursor-direct-stream");
         const resultCallIds = [];
@@ -59,46 +61,31 @@ export function createCursorDirectRuntime(options) {
             await existing.writeContinuations(continuations, signal);
             return { stream: await consumeCursorDirectSession({ session: existing, signal, registry }) };
         }
-        const setup = new AbortController();
-        const cancel = () => {
-            if (!setup.signal.aborted) {
-                setup.abort(new OperationCancelledError("cursor-direct-stream"));
-            }
-        };
-        lifecycle.signal.addEventListener("abort", cancel, { once: true });
-        call.abortSignal?.addEventListener("abort", cancel, { once: true });
-        if (lifecycle.signal.aborted || signal.aborted)
-            cancel();
-        try {
-            const token = await options.readAccessToken(setup.signal);
-            if (setup.signal.aborted)
-                throw new OperationCancelledError("cursor-direct-stream");
-            if (token === null)
-                throw cursorFailure("cursor-auth-unavailable");
-            return await startCursorDirectRun({
-                bridge: await bridge(),
-                call,
-                clock: options.clock,
-                createId,
-                idleTimeoutMs: options.idleTimeoutMs ?? 60_000,
-                modelId,
-                registry,
-                signal,
-                token,
-                tools: toolsFromCall(call),
-                ttlMs: options.ttlMs ?? 300_000,
-                ...(options.createSetupCleanup === undefined
-                    ? {}
-                    : { createSetupCleanup: options.createSetupCleanup }),
-            });
-        }
-        finally {
-            lifecycle.signal.removeEventListener("abort", cancel);
-            call.abortSignal?.removeEventListener("abort", cancel);
-        }
+        const token = await options.readAccessToken(signal);
+        if (signal.aborted)
+            throw new OperationCancelledError("cursor-direct-stream");
+        if (token === null)
+            throw cursorFailure("cursor-auth-unavailable");
+        return await startCursorDirectRun({
+            bridge: await bridge(),
+            call,
+            clock: options.clock,
+            createId,
+            idleTimeoutMs: options.idleTimeoutMs ?? 60_000,
+            modelId,
+            reloadAccessToken: options.readAccessToken,
+            registry,
+            signal,
+            token,
+            tools: toolsFromCall(call),
+            ttlMs: options.ttlMs ?? 300_000,
+            ...(options.createSetupCleanup === undefined
+                ? {}
+                : { createSetupCleanup: options.createSetupCleanup }),
+        });
     };
     const disposal = createAsyncDisposable(async () => {
-        lifecycle.abort();
+        lifecycle.abort(new OperationCancelledError("cursor-direct-stream"));
         await settleCursorCleanup([
             registry.dispose,
             async () => {

package/dist/providers/cursor/run-session.js

@@ -150,12 +150,12 @@ export function createCursorRunSessionRegistry(_options) {
             retireForRetry: async () => {
                 if (resources.dispatcher.parkedCalls.size > 0 || reserved.size > 0)
                     throw new CursorRunSessionError("retry-boundary");
-                retired = true;
                 cancelTimer();
                 sessions.delete(identity.sessionId);
                 removeOwnership(identity.sessionId);
                 resources.dispatcher.parkedCalls.clear();
                 await settleCursorCleanup([resources.stream.abort, resources.ownership.release]);
+                retired = true;
             },
             dispose: disposal.dispose,
         };

package/dist/providers/ollama/adapter.d.ts

@@ -1,8 +1,10 @@
 import type { ProviderAdapter } from "../../core/adapter.js";
 import type { OllamaCatalogState } from "./catalog-state.js";
+import { type OllamaEndpoints } from "./endpoints.js";
 import type { OllamaFetch } from "./http.js";
 export type OllamaAdapterOptions = {
     readonly fetch: OllamaFetch;
     readonly catalog: OllamaCatalogState;
+    readonly endpoints?: OllamaEndpoints;
 };
 export declare function createOllamaAdapter(options: OllamaAdapterOptions): ProviderAdapter;

package/dist/providers/ollama/adapter.js

@@ -1,6 +1,7 @@
 import { OperationCancelledError } from "../../core/errors.js";
 import { parseProviderId } from "../../core/ids.js";
 import { createAsyncDisposable } from "../../core/lifecycle.js";
+import { parseOllamaEndpoints } from "./endpoints.js";
 import { OllamaCatalogError } from "./errors.js";
 import { listLocalOllamaModels } from "./local-catalog.js";
 function mergeModels(local, cloud) {
@@ -23,6 +24,7 @@ function catalogFailure(error) {
 }
 export function createOllamaAdapter(options) {
     const providerId = parseProviderId("ollama");
+    const endpoints = options.endpoints ?? parseOllamaEndpoints(undefined);
     const lease = options.catalog.acquire();
     const disposal = createAsyncDisposable(() => lease.dispose());
     let lastMergedModels = null;
@@ -33,7 +35,7 @@ export function createOllamaAdapter(options) {
                 throw new OperationCancelledError("ollama-snapshot");
             let local;
             try {
-                local = await listLocalOllamaModels(options.fetch, signal);
+                local = await listLocalOllamaModels(options.fetch, signal, endpoints);
             }
             catch (error) {
                 const failure = catalogFailure(error);

package/dist/providers/ollama/endpoints.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
+export type OllamaEndpoints = {
+    readonly baseURL: string;
+    readonly tagsURL: string;
+    readonly pullURL: string;
+    readonly chatURL: string;
+};
+export declare function parseOllamaEndpoints(input: unknown): OllamaEndpoints;

package/dist/providers/ollama/endpoints.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export const DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
+const DirectApiPaths = ["/api/tags", "/api/pull", "/api/chat"];
+const OllamaBaseURLSchema = z
+    .string()
+    .refine((value) => value.length > 0 &&
+    value === value.trim() &&
+    /^https?:\/\//iu.test(value) &&
+    !/[\t\r\n\\]/u.test(value) &&
+    !/^https?:\/\/[^/?#]*@/iu.test(value) &&
+    !/[?#]$/u.test(value) &&
+    URL.canParse(value))
+    .transform((value) => new URL(value))
+    .superRefine((url, context) => {
+    const cloudHostname = url.hostname.toLowerCase().replace(/\.+$/u, "");
+    const path = url.pathname.replace(/\/+$/u, "") || "/";
+    if ((url.protocol !== "http:" && url.protocol !== "https:") ||
+        url.hostname.length === 0 ||
+        url.username.length > 0 ||
+        url.password.length > 0 ||
+        url.search.length > 0 ||
+        url.hash.length > 0 ||
+        cloudHostname === "ollama.com" ||
+        cloudHostname.endsWith(".ollama.com") ||
+        DirectApiPaths.some((apiPath) => path.endsWith(apiPath))) {
+        context.addIssue({ code: "custom", message: "invalid Ollama daemon base URL" });
+    }
+})
+    .transform((url) => `${url.origin}${url.pathname.replace(/\/+$/u, "")}`);
+export function parseOllamaEndpoints(input) {
+    const baseURL = OllamaBaseURLSchema.parse(input === undefined ? DEFAULT_OLLAMA_BASE_URL : input);
+    return Object.freeze({
+        baseURL,
+        tagsURL: `${baseURL}/api/tags`,
+        pullURL: `${baseURL}/api/pull`,
+        chatURL: `${baseURL}/api/chat`,
+    });
+}

package/dist/providers/ollama/index.d.ts

@@ -1,6 +1,7 @@
 export { createOllamaAdapter, type OllamaAdapterOptions } from "./adapter.js";
 export { createOllamaCatalogState, type OllamaCatalogLease, type OllamaCatalogState, type OllamaCatalogStateOptions, } from "./catalog-state.js";
 export { discoverOllamaCloudModels } from "./cloud-catalog.js";
+export { DEFAULT_OLLAMA_BASE_URL, type OllamaEndpoints, parseOllamaEndpoints, } from "./endpoints.js";
 export { OllamaCatalogError, type OllamaCatalogErrorKind, OllamaGenerationError, type OllamaGenerationOperation, } from "./errors.js";
 export { type OllamaFetch, productionOllamaFetch } from "./http.js";
 export { createOllamaLanguageModel, type OllamaLanguageModelOptions, } from "./language-model.js";

package/dist/providers/ollama/index.js

@@ -1,6 +1,7 @@
 export { createOllamaAdapter } from "./adapter.js";
 export { createOllamaCatalogState, } from "./catalog-state.js";
 export { discoverOllamaCloudModels } from "./cloud-catalog.js";
+export { DEFAULT_OLLAMA_BASE_URL, parseOllamaEndpoints, } from "./endpoints.js";
 export { OllamaCatalogError, OllamaGenerationError, } from "./errors.js";
 export { productionOllamaFetch } from "./http.js";
 export { createOllamaLanguageModel, } from "./language-model.js";

package/dist/providers/ollama/language-model.d.ts

@@ -1,5 +1,6 @@
 import type { LanguageModelV3 } from "@ai-sdk/provider";
 import type { OllamaCatalogState } from "./catalog-state.js";
+import { type OllamaEndpoints } from "./endpoints.js";
 import type { OllamaFetch } from "./http.js";
 import { type OllamaRuntime } from "./runtime.js";
 export type OllamaLanguageModelOptions = {
@@ -7,5 +8,6 @@ export type OllamaLanguageModelOptions = {
     readonly runtime?: OllamaRuntime;
     readonly catalog?: OllamaCatalogState;
     readonly fetch?: OllamaFetch;
+    readonly endpoints?: OllamaEndpoints;
 };
 export declare function createOllamaLanguageModel(options: OllamaLanguageModelOptions): LanguageModelV3;

package/dist/providers/ollama/language-model.js

@@ -1,4 +1,5 @@
 import { OperationCancelledError } from "../../core/errors.js";
+import { parseOllamaEndpoints } from "./endpoints.js";
 import { generateFromOllamaStream } from "./generate.js";
 import { buildOllamaCall } from "./prompt.js";
 import { createOllamaRuntime } from "./runtime.js";
@@ -10,6 +11,7 @@ function runtimeFromOptions(options) {
         throw new TypeError("Ollama catalog state is required");
     return createOllamaRuntime({
         catalog: options.catalog,
+        endpoints: options.endpoints ?? parseOllamaEndpoints(undefined),
         ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
     });
 }

package/dist/providers/ollama/local-catalog.d.ts

@@ -1,3 +1,4 @@
 import type { AdapterModel } from "../../core/models.js";
+import { type OllamaEndpoints } from "./endpoints.js";
 import { type OllamaFetch } from "./http.js";
-export declare function listLocalOllamaModels(fetch: OllamaFetch, signal: AbortSignal): Promise<readonly AdapterModel[]>;
+export declare function listLocalOllamaModels(fetch: OllamaFetch, signal: AbortSignal, endpoints?: OllamaEndpoints): Promise<readonly AdapterModel[]>;

package/dist/providers/ollama/local-catalog.js

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { parseAdapterModel } from "../../core/models.js";
+import { parseOllamaEndpoints } from "./endpoints.js";
 import { OllamaCatalogError } from "./errors.js";
 import { requestOllamaCatalog } from "./http.js";
-const LOCAL_TAGS_URL = "http://localhost:11434/api/tags";
 const LocalModelSchema = z
     .object({ model: z.string().optional(), name: z.string().optional() })
     .superRefine((value, context) => {
@@ -17,9 +17,9 @@ const LocalModelSchema = z
 })
     .transform(({ model, name }) => (model?.length === 0 ? undefined : model) ?? name ?? "");
 const LocalTagsSchema = z.object({ models: z.array(LocalModelSchema) }).readonly();
-export async function listLocalOllamaModels(fetch, signal) {
+export async function listLocalOllamaModels(fetch, signal, endpoints = parseOllamaEndpoints(undefined)) {
     const text = await requestOllamaCatalog({
-        url: LOCAL_TAGS_URL,
+        url: endpoints.tagsURL,
         accept: "application/json",
         operation: "local-tags",
         fetch,