opencode-ext-connector 0.3.0

package/dist/providers/cursor/tool-stream.js

@@ -0,0 +1,220 @@
+// Derived from Nomadcxx/opencode-cursor@8e14a26c1e080382f471a729436092ef72edf34e.
+// Licensed under BSD-3-Clause. See THIRD_PARTY_NOTICES.md.
+const TOOL_ALIASES = {
+    runcommand: "bash",
+    executecommand: "bash",
+    runterminalcommand: "bash",
+    terminalcommand: "bash",
+    shellcommand: "bash",
+    shell: "bash",
+    terminal: "bash",
+    bashcommand: "bash",
+    runbash: "bash",
+    executebash: "bash",
+    strreplace: "edit",
+    writefile: "write",
+    findfiles: "glob",
+    searchfiles: "glob",
+    globfiles: "glob",
+    fileglob: "glob",
+    matchfiles: "glob",
+    createdirectory: "mkdir",
+    makedirectory: "mkdir",
+    mkdirp: "mkdir",
+    createdir: "mkdir",
+    makefolder: "mkdir",
+    delete: "rm",
+    deletefile: "rm",
+    deletepath: "rm",
+    deletedirectory: "rm",
+    remove: "rm",
+    removefile: "rm",
+    removepath: "rm",
+    unlink: "rm",
+    rmdir: "rm",
+    getfileinfo: "stat",
+    fileinfo: "stat",
+    filestat: "stat",
+    pathinfo: "stat",
+    listdirectory: "ls",
+    listfiles: "ls",
+    listdir: "ls",
+    readdir: "ls",
+    updatetodos: "todowrite",
+    updatetodostoolcall: "todowrite",
+    todowritetoolcall: "todowrite",
+    writetodos: "todowrite",
+    todowritefn: "todowrite",
+    readtodos: "todoread",
+    readtodostoolcall: "todoread",
+    todoreadtoolcall: "todoread",
+    callomoagent: "call_omo_agent",
+    callagent: "call_omo_agent",
+    invokeagent: "call_omo_agent",
+    delegatetask: "task",
+    delegate: "task",
+    runtask: "task",
+    subagent: "task",
+    useskill: "skill",
+    invokeskill: "skill",
+    runskill: "skill",
+    skillmcp: "skill_mcp",
+    runmcpskill: "skill_mcp",
+    invokeskillmcp: "skill_mcp",
+    askquestion: "question",
+    askuser: "question",
+    askuserquestion: "question",
+    askquestions: "question",
+    promptuser: "question",
+};
+const ARGUMENT_ALIASES = {
+    filepath: "path",
+    filename: "path",
+    file: "path",
+    targetpath: "path",
+    directorypath: "path",
+    dir: "path",
+    folder: "path",
+    directory: "path",
+    targetdirectory: "path",
+    targetfile: "path",
+    globpattern: "pattern",
+    filepattern: "pattern",
+    searchpattern: "pattern",
+    includepattern: "include",
+    workingdirectory: "cwd",
+    workdir: "cwd",
+    currentdirectory: "cwd",
+    cmd: "command",
+    script: "command",
+    shellcommand: "command",
+    terminalcommand: "command",
+    contents: "content",
+    text: "content",
+    body: "content",
+    data: "content",
+    payload: "content",
+    streamcontent: "content",
+    recursive: "force",
+    oldstring: "old_string",
+    newstring: "new_string",
+    subagenttype: "subagent_type",
+};
+function stringField(value, key) {
+    if (!(key in value)) {
+        return null;
+    }
+    const field = Reflect.get(value, key);
+    return typeof field === "string" && field.length > 0 ? field : null;
+}
+function toolNameFromKey(key) {
+    return key.endsWith("ToolCall") ? key.slice(0, -"ToolCall".length) : key;
+}
+function normalizeToolName(name) {
+    return name.toLowerCase().replaceAll(/[^a-z0-9]/g, "");
+}
+function resolveToolName(name, allowed) {
+    if (allowed.has(name)) {
+        return name;
+    }
+    const normalized = normalizeToolName(name);
+    const alias = normalizeToolName(TOOL_ALIASES[normalized] ?? normalized);
+    for (const candidate of allowed.keys()) {
+        const normalizedCandidate = normalizeToolName(candidate);
+        if (normalizedCandidate === normalized ||
+            normalizedCandidate === alias ||
+            normalizedCandidate === normalizeToolName(`oc_${alias}`)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function objectRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return null;
+    }
+    const result = {};
+    for (const key of Object.keys(value)) {
+        result[key] = Reflect.get(value, key);
+    }
+    return result;
+}
+function normalizeArguments(args, schema) {
+    const input = objectRecord(args);
+    const schemaRecord = objectRecord(schema);
+    const properties = objectRecord(schemaRecord?.["properties"]);
+    if (input === null || properties === null) {
+        return args;
+    }
+    const propertyByNormalized = new Map();
+    for (const property of Object.keys(properties)) {
+        const normalizedProperty = normalizeToolName(property);
+        propertyByNormalized.set(ARGUMENT_ALIASES[normalizedProperty] ?? normalizedProperty, property);
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(input)) {
+        const normalizedKey = normalizeToolName(key);
+        const alias = ARGUMENT_ALIASES[normalizedKey] ?? normalizedKey;
+        const target = (key in properties ? key : undefined) ?? propertyByNormalized.get(alias) ?? key;
+        if (!(target in normalized)) {
+            normalized[target] = value;
+        }
+    }
+    if (schemaRecord?.["additionalProperties"] === false) {
+        for (const key of Object.keys(normalized)) {
+            if (!(key in properties)) {
+                delete normalized[key];
+            }
+        }
+    }
+    return normalized;
+}
+function nestedToolCall(value) {
+    if (!("tool_call" in value)) {
+        return null;
+    }
+    const payload = Reflect.get(value, "tool_call");
+    if (typeof payload !== "object" || payload === null) {
+        return null;
+    }
+    const entries = Object.entries(payload);
+    const first = entries.at(0);
+    if (first === undefined) {
+        return null;
+    }
+    const [key, nested] = first;
+    if (typeof nested !== "object" || nested === null) {
+        return { name: toolNameFromKey(key), args: {} };
+    }
+    const args = "args" in nested ? Reflect.get(nested, "args") : nested;
+    return { name: toolNameFromKey(key), args };
+}
+export function cursorToolParts(parsed, allowedTools) {
+    const type = stringField(parsed, "type");
+    if (type !== "tool_call") {
+        return [];
+    }
+    const subtype = stringField(parsed, "subtype") ?? "started";
+    const id = stringField(parsed, "call_id") ?? stringField(parsed, "id") ?? "tool-1";
+    const flatName = stringField(parsed, "name") ?? stringField(parsed, "toolName");
+    const nested = nestedToolCall(parsed);
+    const rawToolName = flatName ?? nested?.name ?? "unknown";
+    const toolName = resolveToolName(rawToolName, allowedTools);
+    const args = "arguments" in parsed ? Reflect.get(parsed, "arguments") : nested?.args;
+    if (toolName === null) {
+        return [];
+    }
+    const input = JSON.stringify(normalizeArguments(args ?? {}, allowedTools.get(toolName)));
+    if (subtype === "delta") {
+        return [{ type: "tool-input-delta", id, delta: input }];
+    }
+    if (subtype === "completed") {
+        return [{ type: "tool-input-end", id }];
+    }
+    return [
+        { type: "tool-input-start", id, toolName },
+        { type: "tool-input-delta", id, delta: input },
+        { type: "tool-input-end", id },
+        { type: "tool-call", toolCallId: id, toolName, input, providerExecuted: false },
+    ];
+}

package/dist/providers/cursor/usage.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageModelV3Usage } from "@ai-sdk/provider";
+export declare function emptyCursorUsage(): LanguageModelV3Usage;
+export declare function cursorUsage(value: object): LanguageModelV3Usage | null;

package/dist/providers/cursor/usage.js

@@ -0,0 +1,35 @@
+export function emptyCursorUsage() {
+    return {
+        inputTokens: {
+            total: undefined,
+            noCache: undefined,
+            cacheRead: undefined,
+            cacheWrite: undefined,
+        },
+        outputTokens: { total: undefined, text: undefined, reasoning: undefined },
+    };
+}
+export function cursorUsage(value) {
+    if (!("usage" in value)) {
+        return null;
+    }
+    const rawUsage = value.usage;
+    if (typeof rawUsage !== "object" || rawUsage === null) {
+        return null;
+    }
+    const numberField = (key) => {
+        const field = Reflect.get(rawUsage, key);
+        return typeof field === "number" ? field : undefined;
+    };
+    const input = numberField("inputTokens");
+    const output = numberField("outputTokens");
+    return {
+        inputTokens: {
+            total: input,
+            noCache: input,
+            cacheRead: numberField("cacheReadTokens"),
+            cacheWrite: numberField("cacheWriteTokens"),
+        },
+        outputTokens: { total: output, text: output, reasoning: undefined },
+    };
+}

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

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

package/dist/providers/ollama/adapter.js

@@ -0,0 +1,65 @@
+import { OperationCancelledError } from "../../core/errors";
+import { parseProviderId } from "../../core/ids";
+import { createAsyncDisposable } from "../../core/lifecycle";
+import { OllamaCatalogError } from "./errors";
+import { listLocalOllamaModels } from "./local-catalog";
+function mergeModels(local, cloud) {
+    const ids = new Set();
+    const merged = [];
+    for (const model of [...local, ...cloud]) {
+        if (ids.has(model.id))
+            continue;
+        ids.add(model.id);
+        merged.push(model);
+    }
+    return merged;
+}
+function catalogFailure(error) {
+    if (error instanceof OperationCancelledError)
+        throw error;
+    if (error instanceof OllamaCatalogError)
+        return error;
+    throw error;
+}
+export function createOllamaAdapter(options) {
+    const providerId = parseProviderId("ollama");
+    const lease = options.catalog.acquire();
+    const disposal = createAsyncDisposable(() => lease.dispose());
+    let lastMergedModels = null;
+    return {
+        providerId,
+        snapshot: async (signal) => {
+            if (signal.aborted)
+                throw new OperationCancelledError("ollama-snapshot");
+            let local;
+            try {
+                local = await listLocalOllamaModels(options.fetch, signal);
+            }
+            catch (error) {
+                const failure = catalogFailure(error);
+                return lastMergedModels === null
+                    ? { status: "unavailable", providerId, reason: failure.kind }
+                    : { status: "stale", providerId, models: lastMergedModels, reason: failure.kind };
+            }
+            try {
+                const models = mergeModels(local, await lease.refresh(signal));
+                lastMergedModels = models;
+                return { status: "ready", providerId, models };
+            }
+            catch (error) {
+                const failure = catalogFailure(error);
+                const previousCloud = lease.models();
+                if (previousCloud.length === 0) {
+                    return lastMergedModels === null
+                        ? { status: "unavailable", providerId, reason: failure.kind }
+                        : { status: "stale", providerId, models: lastMergedModels, reason: failure.kind };
+                }
+                const models = mergeModels(local, previousCloud);
+                lastMergedModels = models;
+                return { status: "stale", providerId, models, reason: failure.kind };
+            }
+        },
+        dispose: disposal.dispose,
+        [Symbol.asyncDispose]: disposal[Symbol.asyncDispose],
+    };
+}

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

@@ -0,0 +1,17 @@
+import type { AsyncDisposableHandle } from "../../core/lifecycle";
+import type { AdapterModel } from "../../core/models";
+import { type OllamaFetch } from "./http";
+export interface OllamaCatalogLease extends AsyncDisposableHandle {
+    refresh(signal: AbortSignal): Promise<readonly AdapterModel[]>;
+    models(): readonly AdapterModel[];
+}
+export interface OllamaCatalogState {
+    acquire(): OllamaCatalogLease;
+    activeLeaseCount(): number;
+    authorizesCloudPull(modelId: string): boolean;
+}
+export type OllamaCatalogStateOptions = {
+    readonly fetch?: OllamaFetch;
+    readonly familyConcurrency?: number;
+};
+export declare function createOllamaCatalogState(options?: OllamaCatalogStateOptions): OllamaCatalogState;

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

@@ -0,0 +1,40 @@
+import { ResourceDisposedError } from "../../core/errors";
+import { createAsyncDisposable } from "../../core/lifecycle";
+import { discoverOllamaCloudModels } from "./cloud-catalog";
+import { productionOllamaFetch } from "./http";
+export function createOllamaCatalogState(options = {}) {
+    const fetch = options.fetch ?? productionOllamaFetch;
+    const concurrency = options.familyConcurrency ?? 4;
+    let completeModels = null;
+    let authorizedIds = new Set();
+    let activeLeases = 0;
+    return {
+        acquire: () => {
+            activeLeases += 1;
+            let released = false;
+            const disposal = createAsyncDisposable(() => {
+                released = true;
+                activeLeases -= 1;
+                if (activeLeases === 0) {
+                    completeModels = null;
+                    authorizedIds = new Set();
+                }
+            });
+            return {
+                refresh: async (signal) => {
+                    if (released)
+                        throw new ResourceDisposedError("ollama-catalog-lease");
+                    const discovered = await discoverOllamaCloudModels(fetch, signal, concurrency);
+                    completeModels = discovered;
+                    authorizedIds = new Set(discovered.map(({ id }) => id));
+                    return discovered;
+                },
+                models: () => completeModels ?? [],
+                dispose: disposal.dispose,
+                [Symbol.asyncDispose]: disposal[Symbol.asyncDispose],
+            };
+        },
+        activeLeaseCount: () => activeLeases,
+        authorizesCloudPull: (modelId) => activeLeases > 0 && authorizedIds.has(modelId),
+    };
+}

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

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

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

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { parseAdapterModel } from "../../core/models";
+import { OllamaCatalogError } from "./errors";
+import { extractOfficialLibraryPaths } from "./html-links";
+import { requestOllamaCatalog } from "./http";
+const CLOUD_SEARCH_URL = "https://ollama.com/search?c=cloud";
+const FAMILY_CONCURRENCY = 4;
+const FamilySchema = z.string().regex(/^[A-Za-z0-9._-]+$/);
+const TagSchema = z.string().min(1).max(256);
+function searchFamilies(html) {
+    const families = [];
+    const seen = new Set();
+    for (const path of extractOfficialLibraryPaths(html)) {
+        const match = /^\/library\/([^/:]+)$/.exec(path);
+        const parsed = FamilySchema.safeParse(match?.[1]);
+        if (parsed.success && !seen.has(parsed.data)) {
+            seen.add(parsed.data);
+            families.push(parsed.data);
+        }
+    }
+    if (families.length === 0)
+        throw new OllamaCatalogError("cloud-search", "invalid-data");
+    return families;
+}
+function familyModels(family, html) {
+    const models = [];
+    const seen = new Set();
+    for (const path of extractOfficialLibraryPaths(html)) {
+        const match = /^\/library\/([^/:]+):([^/]+)$/.exec(path);
+        if (match?.[1] !== family)
+            continue;
+        const tag = TagSchema.safeParse(match[2]);
+        if (!tag.success || (tag.data !== "cloud" && !tag.data.endsWith("-cloud")))
+            continue;
+        const id = `${family}:${tag.data}`;
+        if (!seen.has(id)) {
+            seen.add(id);
+            models.push(parseAdapterModel({ id }));
+        }
+    }
+    if (models.length === 0)
+        throw new OllamaCatalogError("cloud-family", "invalid-data");
+    return models;
+}
+async function discoverFamily(family, fetch, signal) {
+    const html = await requestOllamaCatalog({
+        url: `https://ollama.com/library/${family}`,
+        accept: "text/html",
+        operation: "cloud-family",
+        fetch,
+        signal,
+    });
+    return familyModels(family, html);
+}
+export async function discoverOllamaCloudModels(fetch, signal, concurrency = FAMILY_CONCURRENCY) {
+    const workerCount = z.number().int().min(1).max(8).parse(concurrency);
+    const searchHtml = await requestOllamaCatalog({
+        url: CLOUD_SEARCH_URL,
+        accept: "text/html",
+        operation: "cloud-search",
+        fetch,
+        signal,
+    });
+    const families = searchFamilies(searchHtml);
+    const results = Array.from({ length: families.length }, () => []);
+    let nextFamily = 0;
+    const worker = async () => {
+        while (nextFamily < families.length) {
+            const index = nextFamily;
+            nextFamily += 1;
+            const family = families[index];
+            if (family === undefined)
+                return;
+            results[index] = await discoverFamily(family, fetch, signal);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(workerCount, families.length) }, worker));
+    const models = results.flat();
+    if (models.length === 0)
+        throw new OllamaCatalogError("cloud-search", "invalid-data");
+    return models;
+}

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

@@ -0,0 +1,14 @@
+export type OllamaCatalogErrorKind = "invalid-data" | "transport-error";
+export declare class OllamaCatalogError extends Error {
+    readonly operation: "cloud-family" | "cloud-search" | "local-tags";
+    readonly kind: OllamaCatalogErrorKind;
+    readonly name = "OllamaCatalogError";
+    constructor(operation: "cloud-family" | "cloud-search" | "local-tags", kind: OllamaCatalogErrorKind);
+}
+export type OllamaGenerationOperation = "chat" | "chat-response" | "model-unavailable" | "prompt" | "pull" | "pull-response" | "tags";
+export declare class OllamaGenerationError extends Error {
+    readonly operation: OllamaGenerationOperation;
+    readonly name = "OllamaGenerationError";
+    readonly code = "OLLAMA_GENERATION_ERROR";
+    constructor(operation: OllamaGenerationOperation);
+}

package/dist/providers/ollama/errors.js

@@ -0,0 +1,19 @@
+export class OllamaCatalogError extends Error {
+    operation;
+    kind;
+    name = "OllamaCatalogError";
+    constructor(operation, kind) {
+        super("Ollama catalog request failed");
+        this.operation = operation;
+        this.kind = kind;
+    }
+}
+export class OllamaGenerationError extends Error {
+    operation;
+    name = "OllamaGenerationError";
+    code = "OLLAMA_GENERATION_ERROR";
+    constructor(operation) {
+        super("Ollama generation failed");
+        this.operation = operation;
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { LanguageModelV3GenerateResult, LanguageModelV3StreamPart } from "@ai-sdk/provider";
+export declare function generateFromOllamaStream(stream: ReadableStream<LanguageModelV3StreamPart>): Promise<LanguageModelV3GenerateResult>;

package/dist/providers/ollama/generate.js

@@ -0,0 +1,49 @@
+export async function generateFromOllamaStream(stream) {
+    const content = [];
+    const text = [];
+    const reasoning = [];
+    let warnings = [];
+    let finish = null;
+    const reader = stream.getReader();
+    try {
+        for (;;) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            switch (next.value.type) {
+                case "text-delta":
+                    text.push(next.value.delta);
+                    break;
+                case "reasoning-delta":
+                    reasoning.push(next.value.delta);
+                    break;
+                case "tool-call":
+                    content.push(next.value);
+                    break;
+                case "finish":
+                    finish = next.value;
+                    break;
+                case "stream-start":
+                    warnings = next.value.warnings;
+                    break;
+                case "error":
+                    throw next.value.error;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    if (finish === null)
+        throw new TypeError("Ollama stream ended without a finish part");
+    if (text.length > 0)
+        content.unshift({ type: "text", text: text.join("") });
+    if (reasoning.length > 0)
+        content.unshift({ type: "reasoning", text: reasoning.join("") });
+    return {
+        content,
+        finishReason: finish.finishReason,
+        usage: finish.usage,
+        warnings,
+    };
+}

package/dist/providers/ollama/html-links.d.ts

@@ -0,0 +1 @@
+export declare function extractOfficialLibraryPaths(html: string): readonly string[];

package/dist/providers/ollama/html-links.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+const HtmlSchema = z.string().max(256 * 1024);
+const HrefSchema = z.string().min(1).max(2048);
+const ANCHOR_HREF = /<a\b[^>]*\bhref\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/giu;
+export function extractOfficialLibraryPaths(html) {
+    const source = HtmlSchema.parse(html);
+    const paths = [];
+    for (const match of source.matchAll(ANCHOR_HREF)) {
+        const href = HrefSchema.safeParse(match[1] ?? match[2] ?? match[3]);
+        if (!href.success)
+            continue;
+        let url;
+        try {
+            url = new URL(href.data, "https://ollama.com");
+        }
+        catch (error) {
+            if (error instanceof TypeError)
+                continue;
+            throw error;
+        }
+        if (url.origin === "https://ollama.com" &&
+            url.username === "" &&
+            url.password === "" &&
+            url.search === "" &&
+            url.hash === "") {
+            paths.push(url.pathname);
+        }
+    }
+    return paths;
+}

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

@@ -0,0 +1,12 @@
+export type OllamaFetch = (url: string, init?: RequestInit) => Promise<Response>;
+export type OllamaCatalogOperation = "cloud-family" | "cloud-search" | "local-tags";
+export declare const productionOllamaFetch: OllamaFetch;
+type CatalogRequest = {
+    readonly url: string;
+    readonly accept: "application/json" | "text/html";
+    readonly operation: OllamaCatalogOperation;
+    readonly fetch: OllamaFetch;
+    readonly signal: AbortSignal;
+};
+export declare function requestOllamaCatalog(request: CatalogRequest): Promise<string>;
+export {};