opencode-ext-connector 0.3.0

package/dist/providers/ollama/http.js

@@ -0,0 +1,67 @@
+import { OperationCancelledError } from "../../core/errors";
+import { OllamaCatalogError } from "./errors";
+const MAX_BODY_BYTES = 256 * 1024;
+export const productionOllamaFetch = (url, init) => fetch(url, init);
+function failureKind(status) {
+    return status >= 500 ? "transport-error" : "invalid-data";
+}
+async function readBoundedBody(response, operation) {
+    if (response.body === null)
+        return new Uint8Array();
+    const reader = response.body.getReader();
+    const chunks = [];
+    let length = 0;
+    while (true) {
+        const result = await reader.read();
+        if (result.done)
+            break;
+        length += result.value.byteLength;
+        if (length > MAX_BODY_BYTES) {
+            await reader.cancel();
+            throw new OllamaCatalogError(operation, "invalid-data");
+        }
+        chunks.push(result.value);
+    }
+    const body = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        body.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return body;
+}
+export async function requestOllamaCatalog(request) {
+    if (request.signal.aborted)
+        throw new OperationCancelledError(request.operation);
+    let response;
+    try {
+        response = await request.fetch(request.url, {
+            method: "GET",
+            headers: { accept: request.accept },
+            signal: request.signal,
+            redirect: "error",
+            credentials: "omit",
+        });
+    }
+    catch {
+        if (request.signal.aborted)
+            throw new OperationCancelledError(request.operation);
+        throw new OllamaCatalogError(request.operation, "transport-error");
+    }
+    if (!response.ok) {
+        throw new OllamaCatalogError(request.operation, failureKind(response.status));
+    }
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(await readBoundedBody(response, request.operation));
+    }
+    catch (error) {
+        if (request.signal.aborted)
+            throw new OperationCancelledError(request.operation);
+        if (error instanceof OllamaCatalogError)
+            throw error;
+        if (error instanceof TypeError || error instanceof DOMException) {
+            throw new OllamaCatalogError(request.operation, "invalid-data");
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +1,8 @@
+export { createOllamaAdapter, type OllamaAdapterOptions } from "./adapter";
+export { createOllamaCatalogState, type OllamaCatalogLease, type OllamaCatalogState, type OllamaCatalogStateOptions, } from "./catalog-state";
+export { discoverOllamaCloudModels } from "./cloud-catalog";
+export { OllamaCatalogError, type OllamaCatalogErrorKind, OllamaGenerationError, type OllamaGenerationOperation, } from "./errors";
+export { type OllamaFetch, productionOllamaFetch } from "./http";
+export { createOllamaLanguageModel, type OllamaLanguageModelOptions, } from "./language-model";
+export { listLocalOllamaModels } from "./local-catalog";
+export { createOllamaRuntime, type OllamaRuntime, type OllamaRuntimeOptions } from "./runtime";

package/dist/providers/ollama/index.js

@@ -0,0 +1,8 @@
+export { createOllamaAdapter } from "./adapter";
+export { createOllamaCatalogState, } from "./catalog-state";
+export { discoverOllamaCloudModels } from "./cloud-catalog";
+export { OllamaCatalogError, OllamaGenerationError, } from "./errors";
+export { productionOllamaFetch } from "./http";
+export { createOllamaLanguageModel, } from "./language-model";
+export { listLocalOllamaModels } from "./local-catalog";
+export { createOllamaRuntime } from "./runtime";

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

@@ -0,0 +1,11 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { OllamaCatalogState } from "./catalog-state";
+import type { OllamaFetch } from "./http";
+import { type OllamaRuntime } from "./runtime";
+export type OllamaLanguageModelOptions = {
+    readonly modelId: string;
+    readonly runtime?: OllamaRuntime;
+    readonly catalog?: OllamaCatalogState;
+    readonly fetch?: OllamaFetch;
+};
+export declare function createOllamaLanguageModel(options: OllamaLanguageModelOptions): LanguageModelV3;

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

@@ -0,0 +1,62 @@
+import { OperationCancelledError } from "../../core/errors";
+import { generateFromOllamaStream } from "./generate";
+import { buildOllamaCall } from "./prompt";
+import { createOllamaRuntime } from "./runtime";
+import { createOllamaChatStream } from "./stream";
+function runtimeFromOptions(options) {
+    if (options.runtime !== undefined)
+        return options.runtime;
+    if (options.catalog === undefined)
+        throw new TypeError("Ollama catalog state is required");
+    return createOllamaRuntime({
+        catalog: options.catalog,
+        ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+    });
+}
+export function createOllamaLanguageModel(options) {
+    const runtime = runtimeFromOptions(options);
+    const doStream = async (call) => {
+        const built = buildOllamaCall(options.modelId, call);
+        if (call.abortSignal?.aborted === true)
+            throw new OperationCancelledError("ollama-chat");
+        const lifecycle = new AbortController();
+        let finalized = false;
+        const finalize = () => {
+            if (finalized)
+                return;
+            finalized = true;
+            call.abortSignal?.removeEventListener("abort", cancel);
+        };
+        const cancel = () => {
+            if (!lifecycle.signal.aborted) {
+                lifecycle.abort(new OperationCancelledError("ollama-chat"));
+            }
+        };
+        call.abortSignal?.addEventListener("abort", cancel, { once: true });
+        try {
+            const response = await runtime.openChat(built.request, lifecycle.signal);
+            return {
+                stream: createOllamaChatStream({
+                    response,
+                    warnings: built.warnings,
+                    includeRawChunks: call.includeRawChunks === true,
+                    cancel,
+                    finalize,
+                }),
+                request: { body: built.request },
+            };
+        }
+        catch (error) {
+            finalize();
+            throw error;
+        }
+    };
+    return {
+        specificationVersion: "v3",
+        provider: "ollama",
+        modelId: options.modelId,
+        supportedUrls: {},
+        doStream,
+        doGenerate: async (call) => generateFromOllamaStream((await doStream(call)).stream),
+    };
+}

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

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

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { parseAdapterModel } from "../../core/models";
+import { OllamaCatalogError } from "./errors";
+import { requestOllamaCatalog } from "./http";
+const LOCAL_TAGS_URL = "http://localhost:11434/api/tags";
+const LocalModelSchema = z
+    .object({ model: z.string().optional(), name: z.string().optional() })
+    .superRefine((value, context) => {
+    const model = value.model?.length === 0 ? undefined : value.model;
+    const name = value.name?.length === 0 ? undefined : value.name;
+    if (model === undefined && name === undefined) {
+        context.addIssue({ code: "custom", message: "missing local model ID" });
+    }
+    if (model !== undefined && name !== undefined && model !== name) {
+        context.addIssue({ code: "custom", message: "conflicting local model IDs" });
+    }
+})
+    .transform(({ model, name }) => (model?.length === 0 ? undefined : model) ?? name ?? "");
+const LocalTagsSchema = z.object({ models: z.array(LocalModelSchema) }).readonly();
+export async function listLocalOllamaModels(fetch, signal) {
+    const text = await requestOllamaCatalog({
+        url: LOCAL_TAGS_URL,
+        accept: "application/json",
+        operation: "local-tags",
+        fetch,
+        signal,
+    });
+    try {
+        const value = JSON.parse(text);
+        return LocalTagsSchema.parse(value).models.map((id) => parseAdapterModel({ id }));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError || error instanceof z.ZodError) {
+            throw new OllamaCatalogError("local-tags", "invalid-data");
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { z } from "zod";
+import { type OllamaGenerationOperation } from "./errors";
+export declare function parseOllamaNdjson<T>(response: Response, schema: z.ZodType<T>, operation: OllamaGenerationOperation): AsyncGenerator<T>;

package/dist/providers/ollama/ndjson.js

@@ -0,0 +1,51 @@
+import { OllamaGenerationError } from "./errors";
+const MAX_LINE_BYTES = 1024 * 1024;
+function appendLine(buffered, chunk, operation) {
+    if (buffered.byteLength + chunk.byteLength > MAX_LINE_BYTES) {
+        throw new OllamaGenerationError(operation);
+    }
+    const joined = new Uint8Array(buffered.byteLength + chunk.byteLength);
+    joined.set(buffered);
+    joined.set(chunk, buffered.byteLength);
+    return joined;
+}
+export async function* parseOllamaNdjson(response, schema, operation) {
+    if (response.body === null)
+        throw new OllamaGenerationError(operation);
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let buffered = new Uint8Array();
+    try {
+        for (;;) {
+            const result = await reader.read();
+            if (result.done)
+                break;
+            let start = 0;
+            for (let index = 0; index < result.value.byteLength; index += 1) {
+                if (result.value[index] !== 0x0a)
+                    continue;
+                const lineBytes = appendLine(buffered, result.value.subarray(start, index), operation);
+                buffered = new Uint8Array();
+                start = index + 1;
+                const line = decoder.decode(lineBytes);
+                if (line.trim().length === 0)
+                    continue;
+                yield schema.parse(JSON.parse(line));
+            }
+            buffered = appendLine(buffered, result.value.subarray(start), operation);
+        }
+        if (buffered.byteLength > 0) {
+            const line = decoder.decode(buffered);
+            if (line.trim().length > 0)
+                yield schema.parse(JSON.parse(line));
+        }
+    }
+    catch (error) {
+        if (error instanceof OllamaGenerationError)
+            throw error;
+        throw new OllamaGenerationError(operation);
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { LanguageModelV3CallOptions, SharedV3Warning } from "@ai-sdk/provider";
+import type { OllamaChatRequest } from "./protocol";
+type BuiltOllamaCall = {
+    readonly request: OllamaChatRequest;
+    readonly warnings: SharedV3Warning[];
+};
+export declare function buildOllamaCall(modelId: string, call: LanguageModelV3CallOptions): BuiltOllamaCall;
+export {};

package/dist/providers/ollama/prompt.js

@@ -0,0 +1,141 @@
+import { OllamaGenerationError } from "./errors";
+function unsupported() {
+    throw new OllamaGenerationError("prompt");
+}
+function resultText(output) {
+    switch (output.type) {
+        case "text":
+        case "error-text":
+            return output.value;
+        case "json":
+        case "error-json":
+            return JSON.stringify(output.value);
+        case "execution-denied":
+            return output.reason ?? "Tool execution denied";
+        case "content":
+            return unsupported();
+    }
+}
+function messagesFromCall(call) {
+    const messages = [];
+    const pendingCalls = new Map();
+    for (const message of call.prompt) {
+        if (pendingCalls.size > 0 && message.role !== "tool")
+            unsupported();
+        switch (message.role) {
+            case "system":
+                messages.push({ role: "system", content: message.content });
+                break;
+            case "user":
+                messages.push({
+                    role: "user",
+                    content: message.content
+                        .map((part) => (part.type === "text" ? part.text : unsupported()))
+                        .join(""),
+                });
+                break;
+            case "assistant": {
+                const text = [];
+                const thinking = [];
+                const calls = [];
+                for (const part of message.content) {
+                    switch (part.type) {
+                        case "text":
+                            text.push(part.text);
+                            break;
+                        case "reasoning":
+                            thinking.push(part.text);
+                            break;
+                        case "tool-call":
+                            if (part.providerExecuted === true ||
+                                part.toolCallId.length === 0 ||
+                                part.toolName.length === 0 ||
+                                pendingCalls.has(part.toolCallId) ||
+                                typeof part.input !== "object" ||
+                                part.input === null ||
+                                Array.isArray(part.input))
+                                unsupported();
+                            calls.push({
+                                function: {
+                                    name: part.toolName,
+                                    arguments: Object.fromEntries(Object.entries(part.input)),
+                                },
+                            });
+                            pendingCalls.set(part.toolCallId, part.toolName);
+                            break;
+                        case "tool-result":
+                            return unsupported();
+                        case "file":
+                            return unsupported();
+                    }
+                }
+                messages.push({
+                    role: "assistant",
+                    content: text.join(""),
+                    ...(thinking.length === 0 ? {} : { thinking: thinking.join("") }),
+                    ...(calls.length === 0 ? {} : { tool_calls: calls }),
+                });
+                break;
+            }
+            case "tool":
+                for (const part of message.content) {
+                    if (part.type !== "tool-result")
+                        unsupported();
+                    if (pendingCalls.get(part.toolCallId) !== part.toolName)
+                        unsupported();
+                    messages.push({
+                        role: "tool",
+                        content: resultText(part.output),
+                        tool_name: part.toolName,
+                    });
+                    pendingCalls.delete(part.toolCallId);
+                }
+                break;
+        }
+    }
+    return messages;
+}
+export function buildOllamaCall(modelId, call) {
+    const warnings = [];
+    if (call.presencePenalty !== undefined)
+        warnings.push({ type: "unsupported", feature: "presencePenalty" });
+    if (call.frequencyPenalty !== undefined)
+        warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
+    if (call.toolChoice !== undefined)
+        warnings.push({ type: "unsupported", feature: "toolChoice" });
+    if (call.headers !== undefined)
+        warnings.push({ type: "unsupported", feature: "headers" });
+    const tools = call.tools?.map((tool) => {
+        if (tool.type !== "function")
+            return unsupported();
+        return {
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description ?? "",
+                parameters: tool.inputSchema,
+            },
+        };
+    });
+    const requestOptions = {
+        ...(call.maxOutputTokens === undefined ? {} : { num_predict: call.maxOutputTokens }),
+        ...(call.temperature === undefined ? {} : { temperature: call.temperature }),
+        ...(call.topP === undefined ? {} : { top_p: call.topP }),
+        ...(call.topK === undefined ? {} : { top_k: call.topK }),
+        ...(call.seed === undefined ? {} : { seed: call.seed }),
+        ...(call.stopSequences === undefined ? {} : { stop: call.stopSequences }),
+    };
+    return {
+        request: {
+            model: modelId,
+            stream: true,
+            messages: messagesFromCall(call),
+            ...(tools === undefined ? {} : { tools }),
+            ...(call.responseFormat?.type === "json"
+                ? { format: call.responseFormat.schema ?? "json" }
+                : {}),
+            ...(Object.keys(requestOptions).length === 0 ? {} : { options: requestOptions }),
+        },
+        warnings,
+    };
+}

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

@@ -0,0 +1,56 @@
+import { z } from "zod";
+type OllamaJson = boolean | null | number | string | readonly OllamaJson[] | {
+    readonly [key: string]: OllamaJson;
+};
+export type OllamaPullChunk = {
+    readonly status?: string | undefined;
+    readonly error?: string | undefined;
+};
+export declare const OllamaPullChunkSchema: z.ZodType<OllamaPullChunk>;
+type OllamaToolCall = {
+    readonly function: {
+        readonly name: string;
+        readonly arguments: Record<string, OllamaJson>;
+    };
+};
+export type OllamaChatChunk = {
+    readonly message: {
+        readonly role?: string | undefined;
+        readonly content: string;
+        readonly thinking?: string | undefined;
+        readonly tool_calls?: readonly OllamaToolCall[] | undefined;
+    };
+    readonly done: boolean;
+    readonly done_reason?: string | undefined;
+    readonly prompt_eval_count?: number | undefined;
+    readonly eval_count?: number | undefined;
+};
+export declare const OllamaChatChunkSchema: z.ZodType<OllamaChatChunk>;
+export type OllamaMessage = {
+    readonly role: "assistant" | "system" | "tool" | "user";
+    readonly content: string;
+    readonly thinking?: string;
+    readonly tool_name?: string;
+    readonly tool_calls?: readonly {
+        readonly function: {
+            readonly name: string;
+            readonly arguments: Readonly<Record<string, unknown>>;
+        };
+    }[];
+};
+export type OllamaChatRequest = {
+    readonly model: string;
+    readonly stream: true;
+    readonly messages: readonly OllamaMessage[];
+    readonly tools?: readonly {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+            readonly description: string;
+            readonly parameters: object;
+        };
+    }[];
+    readonly format?: object | "json";
+    readonly options?: Readonly<Record<string, number | readonly string[]>>;
+};
+export {};

package/dist/providers/ollama/protocol.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+const JsonObjectSchema = z.record(z.string(), z.json());
+export const OllamaPullChunkSchema = z
+    .object({ status: z.string().optional(), error: z.string().optional() })
+    .readonly();
+const OllamaToolCallSchema = z
+    .object({
+    function: z.object({ name: z.string().min(1), arguments: JsonObjectSchema }),
+})
+    .readonly();
+export const OllamaChatChunkSchema = z
+    .object({
+    message: z
+        .object({
+        role: z.string().optional(),
+        content: z.string().default(""),
+        thinking: z.string().optional(),
+        tool_calls: z.array(OllamaToolCallSchema).optional(),
+    })
+        .readonly(),
+    done: z.boolean(),
+    done_reason: z.string().optional(),
+    prompt_eval_count: z.number().int().nonnegative().optional(),
+    eval_count: z.number().int().nonnegative().optional(),
+})
+    .readonly();

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

@@ -0,0 +1,11 @@
+import type { OllamaCatalogState } from "./catalog-state";
+import { type OllamaFetch } from "./http";
+import { type OllamaChatRequest } from "./protocol";
+export type OllamaRuntimeOptions = {
+    readonly catalog: OllamaCatalogState;
+    readonly fetch?: OllamaFetch;
+};
+export interface OllamaRuntime {
+    openChat(request: OllamaChatRequest, signal: AbortSignal): Promise<Response>;
+}
+export declare function createOllamaRuntime(options: OllamaRuntimeOptions): OllamaRuntime;

package/dist/providers/ollama/runtime.js

@@ -0,0 +1,128 @@
+import { OperationCancelledError } from "../../core/errors";
+import { OllamaGenerationError } from "./errors";
+import { productionOllamaFetch } from "./http";
+import { listLocalOllamaModels } from "./local-catalog";
+import { parseOllamaNdjson } from "./ndjson";
+import { OllamaPullChunkSchema } from "./protocol";
+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",
+};
+function cancelled(operation) {
+    return new OperationCancelledError(`ollama-${operation}`);
+}
+async function post(fetch, url, body, signal, operation) {
+    if (signal.aborted)
+        throw cancelled(operation);
+    try {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: JSON_HEADERS,
+            body: JSON.stringify(body),
+            signal,
+            credentials: "omit",
+            redirect: "error",
+        });
+        if (signal.aborted)
+            throw cancelled(operation);
+        if (!response.ok)
+            throw new OllamaGenerationError(operation);
+        return response;
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw cancelled(operation);
+        if (error instanceof OperationCancelledError)
+            throw error;
+        if (error instanceof OllamaGenerationError)
+            throw error;
+        throw new OllamaGenerationError(operation);
+    }
+}
+export function createOllamaRuntime(options) {
+    const fetch = options.fetch ?? productionOllamaFetch;
+    const pulls = new Map();
+    const pull = (modelId) => {
+        const existing = pulls.get(modelId);
+        if (existing !== undefined)
+            return existing;
+        const controller = new AbortController();
+        const promise = (async () => {
+            const response = await post(fetch, PULL_URL, { model: modelId, stream: true }, controller.signal, "pull");
+            let succeeded = false;
+            for await (const chunk of parseOllamaNdjson(response, OllamaPullChunkSchema, "pull-response")) {
+                if (chunk.error !== undefined)
+                    throw new OllamaGenerationError("pull-response");
+                if (chunk.status === "success")
+                    succeeded = true;
+            }
+            if (!succeeded)
+                throw new OllamaGenerationError("pull-response");
+        })();
+        const flight = { controller, promise, waiters: 0 };
+        pulls.set(modelId, flight);
+        const settle = () => {
+            if (pulls.get(modelId) === flight)
+                pulls.delete(modelId);
+        };
+        promise.then(settle, settle);
+        return flight;
+    };
+    const waitForPull = (modelId, flight, signal) => {
+        flight.waiters += 1;
+        const deferred = Promise.withResolvers();
+        let settled = false;
+        const release = () => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener("abort", onAbort);
+            flight.waiters -= 1;
+            if (flight.waiters === 0 && pulls.get(modelId) === flight) {
+                pulls.delete(modelId);
+                flight.controller.abort(cancelled("pull"));
+            }
+        };
+        const onAbort = () => {
+            release();
+            deferred.reject(cancelled("pull-wait"));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+        flight.promise.then(() => {
+            if (settled)
+                return;
+            release();
+            deferred.resolve();
+        }, (error) => {
+            if (settled)
+                return;
+            release();
+            deferred.reject(error);
+        });
+        return deferred.promise;
+    };
+    return {
+        openChat: async (request, signal) => {
+            let local;
+            try {
+                local = await listLocalOllamaModels(fetch, signal);
+            }
+            catch (error) {
+                if (error instanceof OperationCancelledError)
+                    throw error;
+                throw new OllamaGenerationError("tags");
+            }
+            if (!local.some(({ id }) => id === request.model)) {
+                if (!options.catalog.authorizesCloudPull(request.model)) {
+                    throw new OllamaGenerationError("model-unavailable");
+                }
+                await waitForPull(request.model, pull(request.model), signal);
+            }
+            return post(fetch, CHAT_URL, request, signal, "chat");
+        },
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { LanguageModelV3StreamPart, SharedV3Warning } from "@ai-sdk/provider";
+export declare function createOllamaChatStream(options: {
+    readonly response: Response;
+    readonly warnings: SharedV3Warning[];
+    readonly includeRawChunks: boolean;
+    readonly cancel: () => void;
+    readonly finalize: () => void;
+}): ReadableStream<LanguageModelV3StreamPart>;