opencode-ext-connector 0.3.2 → 0.4.0

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,

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

@@ -1,8 +1,10 @@
 import type { OllamaCatalogState } from "./catalog-state.js";
+import { type OllamaEndpoints } from "./endpoints.js";
 import { type OllamaFetch } from "./http.js";
 import { type OllamaChatRequest } from "./protocol.js";
 export type OllamaRuntimeOptions = {
     readonly catalog: OllamaCatalogState;
+    readonly endpoints?: OllamaEndpoints;
     readonly fetch?: OllamaFetch;
 };
 export interface OllamaRuntime {

package/dist/providers/ollama/runtime.js

@@ -1,11 +1,10 @@
 import { OperationCancelledError } from "../../core/errors.js";
+import { parseOllamaEndpoints } from "./endpoints.js";
 import { OllamaGenerationError } from "./errors.js";
 import { productionOllamaFetch } from "./http.js";
 import { listLocalOllamaModels } from "./local-catalog.js";
 import { parseOllamaNdjson } from "./ndjson.js";
 import { OllamaPullChunkSchema } from "./protocol.js";
-const PULL_URL = "http://localhost:11434/api/pull";
-const CHAT_URL = "http://localhost:11434/api/chat";
 const JSON_HEADERS = {
     accept: "application/x-ndjson",
     "content-type": "application/json",
@@ -43,6 +42,7 @@ async function post(fetch, url, body, signal, operation) {
 }
 export function createOllamaRuntime(options) {
     const fetch = options.fetch ?? productionOllamaFetch;
+    const endpoints = options.endpoints ?? parseOllamaEndpoints(undefined);
     const pulls = new Map();
     const pull = (modelId) => {
         const existing = pulls.get(modelId);
@@ -50,7 +50,7 @@ export function createOllamaRuntime(options) {
             return existing;
         const controller = new AbortController();
         const promise = (async () => {
-            const response = await post(fetch, PULL_URL, { model: modelId, stream: true }, controller.signal, "pull");
+            const response = await post(fetch, endpoints.pullURL, { model: modelId, stream: true }, controller.signal, "pull");
             let succeeded = false;
             for await (const chunk of parseOllamaNdjson(response, OllamaPullChunkSchema, "pull-response")) {
                 if (chunk.error !== undefined)
@@ -109,7 +109,7 @@ export function createOllamaRuntime(options) {
         openChat: async (request, signal) => {
             let local;
             try {
-                local = await listLocalOllamaModels(fetch, signal);
+                local = await listLocalOllamaModels(fetch, signal, endpoints);
             }
             catch (error) {
                 if (error instanceof OperationCancelledError)
@@ -122,7 +122,7 @@ export function createOllamaRuntime(options) {
                 }
                 await waitForPull(request.model, pull(request.model), signal);
             }
-            return post(fetch, CHAT_URL, request, signal, "chat");
+            return post(fetch, endpoints.chatURL, request, signal, "chat");
         },
     };
 }

package/dist/sdk/ollama.d.ts

@@ -2,4 +2,7 @@ import type { LanguageModelV3 } from "@ai-sdk/provider";
 export type OllamaProvider = {
     readonly languageModel: (modelId: string) => LanguageModelV3;
 };
-export declare function createOllama(options?: Readonly<Record<string, unknown>>): OllamaProvider;
+export type OllamaProviderOptions = {
+    readonly ollamaBaseURL?: string;
+};
+export declare function createOllama(options?: OllamaProviderOptions): OllamaProvider;

package/dist/server.js

@@ -5,11 +5,13 @@ import { parseConnectorOptions } from "./core/options.js";
 import { createFetchHttpTransport } from "./http/fetch-transport.js";
 import { createConsoleLogger } from "./logging/logger.js";
 import { createOpenCodeAuthStore } from "./opencode/auth-store.js";
-import { pickConnectorOptionsInput } from "./opencode/host-options.js";
+import { pickConnectorOptionsInput, pickOllamaBaseURL } from "./opencode/host-options.js";
+import { getProductionOllamaBundle } from "./opencode/ollama-production.js";
 import { createProviderRegistry, selectConfiguredProviders } from "./opencode/providers.js";
 import { disposeV1LanguageRuntime } from "./opencode/v1-language.js";
-import { createV1AuthServer, createV1Server } from "./opencode/v1-module.js";
+import { buildV1AuthHooks, createV1AuthServer, createV1Server } from "./opencode/v1-module.js";
 import { writeClaudeCredentials } from "./providers/claude/writeback.js";
+import { productionOllamaFetch } from "./providers/ollama/http.js";
 const env = process.env;
 const transport = createFetchHttpTransport();
 const authStore = createOpenCodeAuthStore({ env });
@@ -44,7 +46,21 @@ const providerDeps = {
 };
 export const connectorServer = async (input, options) => {
     const connectorOptions = parseConnectorOptions(pickConnectorOptionsInput(options));
-    const providers = selectConfiguredProviders(registry, connectorOptions.providers);
+    const ollama = connectorOptions.providers.includes("ollama")
+        ? getProductionOllamaBundle(pickOllamaBaseURL(options))
+        : undefined;
+    const providers = selectConfiguredProviders(createProviderRegistry({
+        writeClaudeCredentials,
+        ...(ollama === undefined
+            ? {}
+            : {
+                ollama: {
+                    fetch: productionOllamaFetch,
+                    catalog: ollama.catalog,
+                    endpoints: ollama.endpoints,
+                },
+            }),
+    }), connectorOptions.providers);
     const hooks = await createV1Server({
         clock,
         transport,
@@ -74,7 +90,6 @@ export const connectorServer = async (input, options) => {
 const claudeEntry = registry.find((entry) => entry.id === "claude");
 const cursorEntry = registry.find((entry) => entry.id === "cursor");
 const commandCodeEntry = registry.find((entry) => entry.id === "command-code");
-const ollamaEntry = registry.find((entry) => entry.id === "ollama");
 export const claudeAuthServer = claudeEntry === undefined
     ? async () => ({})
     : createV1AuthServer(claudeEntry, providerDeps);
@@ -84,9 +99,20 @@ export const cursorAuthServer = cursorEntry === undefined
 export const commandCodeAuthServer = commandCodeEntry === undefined
     ? async () => ({})
     : createV1AuthServer(commandCodeEntry, providerDeps);
-export const ollamaAuthServer = ollamaEntry === undefined
-    ? async () => ({})
-    : createV1AuthServer(ollamaEntry, providerDeps);
+export const ollamaAuthServer = async (_input, options) => {
+    const connectorOptions = parseConnectorOptions(pickConnectorOptionsInput(options));
+    if (!connectorOptions.providers.includes("ollama"))
+        return {};
+    const ollama = getProductionOllamaBundle(pickOllamaBaseURL(options));
+    const entry = createProviderRegistry({
+        ollama: {
+            fetch: productionOllamaFetch,
+            catalog: ollama.catalog,
+            endpoints: ollama.endpoints,
+        },
+    }).find((candidate) => candidate.id === "ollama");
+    return entry === undefined ? {} : buildV1AuthHooks(entry, providerDeps, options);
+};
 export const plugin = {
     id: "opencode-ext-connector",
     server: connectorServer,