opencode-cursor-provider 0.2.0 → 0.3.1

package/README.md

@@ -47,8 +47,9 @@ The plugin gets the model list and the model variants from Cursor. The fallback
 ## How the plugin works
 
 - Cursor runs its own tools and changes the workspace.
-- OpenCode tools stay off for Cursor models.
 - OpenCode shows Cursor tools as provider-executed tool calls.
+- The plugin exposes OpenCode tools to Cursor with an `opencode__` prefix for each run.
+- OpenCode executes bridged tools through its normal permissions, hooks, and MCP connections.
 - The plugin keeps one Cursor agent for each OpenCode session.
 - The plugin starts a new Cursor agent after a model, directory, mode, conversation, or Cursor agent option change.
 - OpenCode cancellation stops the active Cursor run.
@@ -69,7 +70,7 @@ providerOptions: {
 }
 ```
 
-The `tools` and `disallowedTools` options apply only to Cursor tools. They do not add OpenCode tools.
+The `tools` and `disallowedTools` options apply only to Cursor tools. OpenCode controls its bridged tools separately.
 
 Because Cursor settings can load MCP servers, select only settings layers that you trust.
 
@@ -78,10 +79,12 @@ Because Cursor settings can load MCP servers, select only settings layers that y
 - The plugin supports text and local image input. It supports text output.
 - The plugin rejects image URLs and non-image file input. It does not discard the input.
 - The plugin rejects structured output requests.
-- The plugin rejects OpenCode tools and explicit tool choice.
+- The plugin rejects explicit tool choice.
+- Tool bridging requires an OpenCode session. One-shot model calls cannot use OpenCode tools.
 - OpenCode sampling settings do not change Cursor model parameters. The plugin reports those settings as unsupported.
 - Cursor controls tool access and tool approval for its tools.
-- The plugin does not expose Cursor MCP servers, custom tools, extra workspace roots, or a replacement system prompt.
+- OpenCode controls permission checks for bridged OpenCode tools.
+- The plugin does not accept user-defined Cursor custom tools, extra workspace roots, or a replacement system prompt.
 
 ## Credentials
 

package/dist/bridge/bridge.d.ts

@@ -1,5 +1,6 @@
 import type { CursorLink } from "../auth/link.ts";
 import type { CursorModelDescriptor } from "../catalog/catalog.ts";
+import type { OpencodeSessionID } from "../ids.ts";
 import { type BindingStore, type TurnScope } from "./binding.ts";
 import { type TurnRequest } from "./turn.ts";
 import type { TurnEvent } from "./translate.ts";
@@ -7,6 +8,8 @@ export type { TurnRequest } from "./turn.ts";
 export interface SessionAgentBridge {
     annotate(system: string[], scope: TurnScope): string[];
     turn(request: TurnRequest): AsyncIterable<TurnEvent>;
+    cancel(sessionID: OpencodeSessionID, reason: string): Promise<void>;
+    dispose(): Promise<void>;
 }
 export declare function createSessionAgentBridge(input: {
     link: CursorLink;

package/dist/bridge/bridge.js

@@ -17,5 +17,11 @@ export function createSessionAgentBridge(input) {
         turn(request) {
             return runTurn(request);
         },
+        cancel(sessionID, reason) {
+            return runTurn.cancel(sessionID, reason);
+        },
+        dispose() {
+            return runTurn.dispose();
+        },
     };
 }

package/dist/bridge/conversation.d.ts

@@ -61,4 +61,10 @@ export declare function resumeTurn(conversation: Conversation, checkpoint: Conve
     role: "user";
 }> | undefined;
 export declare function extendsCheckpoint(conversation: Conversation, checkpoint: ConversationCheckpoint): boolean;
+export declare function toolResultsAfter(conversation: Conversation, checkpoint: ConversationCheckpoint, calls: readonly {
+    readonly id: string;
+    readonly name: string;
+}[]): readonly Extract<ToolPart, {
+    type: "tool-result";
+}>[] | undefined;
 export declare function canonicalJson(value: unknown): string;

package/dist/bridge/conversation.js

@@ -28,6 +28,36 @@ export function resumeTurn(conversation, checkpoint) {
 export function extendsCheckpoint(conversation, checkpoint) {
     return resumeTurn(conversation, checkpoint) !== undefined;
 }
+export function toolResultsAfter(conversation, checkpoint, calls) {
+    if (digest(conversation.system) !== checkpoint.system)
+        return undefined;
+    if (conversation.turns.length !== checkpoint.turns.length + 1)
+        return undefined;
+    for (let index = 0; index < checkpoint.turns.length; index += 1) {
+        const turn = conversation.turns[index];
+        if (turn === undefined || digest(turn) !== checkpoint.turns[index])
+            return undefined;
+    }
+    const suffix = conversation.turns.at(-1);
+    if (suffix?.role !== "tool")
+        return undefined;
+    if (suffix.parts.length !== calls.length)
+        return undefined;
+    const expected = new Map(calls.map((call) => [call.id, call.name]));
+    if (expected.size !== calls.length)
+        return undefined;
+    const found = new Set();
+    const results = [];
+    for (const part of suffix.parts) {
+        if (part.type !== "tool-result")
+            return undefined;
+        if (expected.get(part.id) !== part.name || found.has(part.id))
+            return undefined;
+        found.add(part.id);
+        results.push(part);
+    }
+    return results;
+}
 export function canonicalJson(value) {
     return JSON.stringify(ordered(value)) ?? "null";
 }

package/dist/bridge/response-journal.js

@@ -15,7 +15,7 @@ export function createResponseJournal() {
                 }
                 return event;
             }
-            if (event.type === "tool-call") {
+            if (event.type === "tool-call" || event.type === "tool-request") {
                 if (toolCalls.has(event.id))
                     return undefined;
                 toolCalls.add(event.id);

package/dist/bridge/tool-bridge.d.ts

@@ -0,0 +1,26 @@
+import type { SDKCustomTool, SDKJsonValue } from "@cursor/sdk";
+import type { UserPart } from "./conversation.ts";
+export interface OpenCodeToolRequest {
+    readonly id: string;
+    readonly name: string;
+    readonly input: Record<string, SDKJsonValue>;
+}
+export interface OpenCodeToolDefinition {
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema: Record<string, SDKJsonValue>;
+}
+export interface OpenCodeToolResult {
+    readonly id: string;
+    readonly output: readonly UserPart[];
+    readonly isError: boolean;
+}
+export interface OpenCodeToolBridge {
+    readonly customTools: Record<string, SDKCustomTool>;
+    waitForCalls(): Promise<void>;
+    takeCalls(): readonly OpenCodeToolRequest[];
+    resolve(results: readonly OpenCodeToolResult[]): number;
+    isCursorCall(id: string): boolean;
+    cancel(reason: string): void;
+}
+export declare function createOpenCodeToolBridge(tools: readonly OpenCodeToolDefinition[], bridgeID?: string): OpenCodeToolBridge;

package/dist/bridge/tool-bridge.js

@@ -0,0 +1,92 @@
+import { randomUUID } from "node:crypto";
+const TOOL_PREFIX = "opencode__";
+const CODE_MODE_DISCOVERY = [
+    "OpenCode MCP tools are available only inside this Code Mode tool.",
+    "Do not search for them with Cursor GetDynamicTools.",
+    'To find an MCP tool, call this tool with code such as `return await tools.$codemode.search({ query: "posthog" })`.',
+].join("\n");
+export function createOpenCodeToolBridge(tools, bridgeID = randomUUID()) {
+    const queued = [];
+    const pending = new Map();
+    const cursorCallIDs = new Set();
+    let sequence = 0;
+    let waiter;
+    let wake;
+    const entries = tools
+        .map((tool) => [
+        `${TOOL_PREFIX}${tool.name}`,
+        {
+            ...(tool.description === undefined && tool.name !== "execute"
+                ? {}
+                : {
+                    description: tool.name === "execute"
+                        ? [CODE_MODE_DISCOVERY, tool.description].filter((item) => item !== undefined).join("\n\n")
+                        : tool.description,
+                }),
+            inputSchema: tool.inputSchema,
+            execute(args, context) {
+                sequence += 1;
+                if (context.toolCallId !== undefined)
+                    cursorCallIDs.add(context.toolCallId);
+                const id = `${bridgeID}-${sequence}`;
+                const request = { id, name: tool.name, input: args };
+                queued.push(request);
+                const waiting = new Promise((resolve, reject) => {
+                    pending.set(id, { request, resolve, reject });
+                });
+                wake?.();
+                wake = undefined;
+                waiter = undefined;
+                return waiting;
+            },
+        },
+    ]);
+    return {
+        customTools: Object.fromEntries(entries),
+        waitForCalls() {
+            if (queued.length > 0)
+                return Promise.resolve();
+            if (waiter !== undefined)
+                return waiter;
+            waiter = new Promise((resolve) => {
+                wake = resolve;
+            });
+            return waiter;
+        },
+        takeCalls() {
+            return queued.splice(0);
+        },
+        resolve(results) {
+            let resolved = 0;
+            for (const result of results) {
+                const call = pending.get(result.id);
+                if (call === undefined)
+                    continue;
+                pending.delete(result.id);
+                resolved += 1;
+                call.resolve({
+                    content: result.output.map((part) => {
+                        if (part.type === "text")
+                            return { type: "text", text: part.text };
+                        return { type: "image", data: part.image.data, mimeType: part.image.mimeType };
+                    }),
+                    ...(result.isError ? { isError: true } : {}),
+                });
+            }
+            return resolved;
+        },
+        isCursorCall(id) {
+            return cursorCallIDs.has(id);
+        },
+        cancel(reason) {
+            const error = new Error(reason);
+            for (const call of pending.values())
+                call.reject(error);
+            pending.clear();
+            queued.splice(0);
+            wake?.();
+            wake = undefined;
+            waiter = undefined;
+        },
+    };
+}

package/dist/bridge/translate.d.ts

@@ -19,6 +19,11 @@ export type TurnEvent = {
     readonly id: string;
     readonly name: string;
     readonly input: JsonValue;
+} | {
+    readonly type: "tool-request";
+    readonly id: string;
+    readonly name: string;
+    readonly input: JsonValue;
 } | {
     readonly type: "tool-result";
     readonly id: string;
@@ -35,7 +40,7 @@ export type TurnEvent = {
     readonly total: number;
 } | {
     readonly type: "done";
-    readonly reason: "stop" | "length" | "aborted";
+    readonly reason: "stop" | "length" | "aborted" | "tool-calls";
     readonly metadata?: {
         readonly runId: string;
         readonly requestId?: string;

package/dist/bridge/turn.d.ts

@@ -1,17 +1,19 @@
 import { type AgentModeOption, type ModelParameterValue } from "@cursor/sdk";
 import type { CursorLink } from "../auth/link.ts";
 import { type CursorModelDescriptor } from "../catalog/catalog.ts";
-import { type CatalogModelID } from "../ids.ts";
+import { type CatalogModelID, type OpencodeSessionID } from "../ids.ts";
 import type { CursorAgentOptions } from "../model/provider-options.ts";
 import { openCursorAgent } from "./agent.ts";
 import { type BindingStore, type TurnScope } from "./binding.ts";
 import { type Conversation } from "./conversation.ts";
 import type { KeyedLock } from "./lock.ts";
+import { type OpenCodeToolDefinition } from "./tool-bridge.ts";
 import { type TurnEvent } from "./translate.ts";
 export interface TurnRequest {
     readonly modelID: CatalogModelID;
     readonly scope: TurnScope | undefined;
     readonly conversation: Conversation;
+    readonly tools?: readonly OpenCodeToolDefinition[];
     readonly params?: readonly ModelParameterValue[];
     readonly mode?: AgentModeOption;
     readonly agentOptions?: CursorAgentOptions;
@@ -26,4 +28,8 @@ export interface TurnRunnerContext {
     readonly lock: KeyedLock;
     readonly openAgent?: typeof openCursorAgent;
 }
-export declare function createTurnRunner(ctx: TurnRunnerContext): (request: TurnRequest) => AsyncIterable<TurnEvent>;
+export declare function createTurnRunner(ctx: TurnRunnerContext): ((request: TurnRequest) => AsyncGenerator<TurnEvent, any, any>) & {
+    cancel(sessionID: OpencodeSessionID, reason: string): Promise<void>;
+    dispose(): Promise<void>;
+};
+export type TurnRunner = ReturnType<typeof createTurnRunner>;

package/dist/bridge/turn.js

@@ -3,16 +3,81 @@ import { resolveWireId } from "../catalog/catalog.js";
 import { nowMs } from "../ids.js";
 import { isAgentLost, openCursorAgent } from "./agent.js";
 import { route } from "./binding.js";
-import { checkpointOf, cursorMessage, resumeTurn, } from "./conversation.js";
+import { canonicalJson, checkpointOf, cursorMessage, resumeTurn, toolResultsAfter, } from "./conversation.js";
 import { createResponseJournal } from "./response-journal.js";
+import { createOpenCodeToolBridge, } from "./tool-bridge.js";
 import { createMessageTranslator } from "./translate.js";
 export function createTurnRunner(ctx) {
-    return (request) => runTurn(ctx, request);
+    const liveRuns = new Map();
+    return Object.assign((request) => runTurn(ctx, request, liveRuns), {
+        async cancel(sessionID, reason) {
+            const release = await ctx.lock.acquire(sessionID);
+            try {
+                const live = liveRuns.get(sessionID);
+                if (live === undefined)
+                    return;
+                liveRuns.delete(sessionID);
+                await closeLiveRun(live, reason);
+            }
+            finally {
+                release();
+            }
+        },
+        async dispose() {
+            await Promise.all([...liveRuns.values()].map((live) => closeLiveRun(live, "Cursor provider stopped")));
+            liveRuns.clear();
+        },
+    });
 }
-async function* runTurn(ctx, request) {
+async function* runTurn(ctx, request, liveRuns) {
     const lockKey = request.scope?.sessionID ?? "one-shot";
     const release = await ctx.lock.acquire(lockKey);
     try {
+        const scope = request.scope;
+        if (scope === undefined && (request.tools?.length ?? 0) > 0) {
+            yield { type: "failed", error: { kind: "unsupported-request", reason: "tools-requested" } };
+            return;
+        }
+        const suspended = scope === undefined ? undefined : liveRuns.get(scope.sessionID);
+        if (scope !== undefined && suspended !== undefined) {
+            if (suspended.identity !== liveIdentity(request)) {
+                await closeLiveRun(suspended, "The OpenCode request changed while a tool call was pending");
+                liveRuns.delete(scope.sessionID);
+                ctx.bindings.drop(scope.sessionID);
+            }
+            else {
+                const continuation = suspended.continuation;
+                const parts = continuation === undefined
+                    ? undefined
+                    : toolResultsAfter(request.conversation, continuation.checkpoint, continuation.calls);
+                const resolved = parts === undefined
+                    ? 0
+                    : suspended.toolBridge?.resolve(parts.map((part) => ({ id: part.id, output: part.output, isError: part.isError }))) ?? 0;
+                if (resolved !== continuation?.calls.length) {
+                    await closeLiveRun(suspended, "OpenCode did not return the pending tool result");
+                    liveRuns.delete(scope.sessionID);
+                    ctx.bindings.drop(scope.sessionID);
+                }
+                else {
+                    let outcome;
+                    try {
+                        outcome = yield* drainLiveRun(ctx, request, suspended);
+                    }
+                    catch (error) {
+                        liveRuns.delete(scope.sessionID);
+                        ctx.bindings.drop(scope.sessionID);
+                        await closeLiveRun(suspended, "The Cursor run failed");
+                        yield failedFromCaught(error, request.signal, ctx.link.reject);
+                        return;
+                    }
+                    if (outcome === "suspended")
+                        return;
+                    liveRuns.delete(scope.sessionID);
+                    await suspended.session.dispose();
+                    return;
+                }
+            }
+        }
         const apiKey = await ctx.link.resolve();
         if (apiKey === undefined) {
             yield { type: "failed", error: { kind: "not-linked" } };
@@ -49,7 +114,13 @@ async function* runTurn(ctx, request) {
                     yield { type: "failed", error: { kind: "cancelled" } };
                     return;
                 }
-                const run = await session.send(plan.prompt, request.mode === undefined ? undefined : { mode: request.mode });
+                const toolBridge = request.scope === undefined ? undefined : createOpenCodeToolBridge(request.tools ?? []);
+                const customTools = toolBridge === undefined ? {} : toolBridge.customTools;
+                const sendOptions = {
+                    ...(request.mode === undefined ? {} : { mode: request.mode }),
+                    ...(Object.keys(customTools).length === 0 ? {} : { local: { customTools } }),
+                };
+                const run = await session.send(plan.prompt, Object.keys(sendOptions).length === 0 ? undefined : sendOptions);
                 emitted = true;
                 yield {
                     type: "response-metadata",
@@ -57,82 +128,24 @@ async function* runTurn(ctx, request) {
                     ...(run.createdAt === undefined ? {} : { timestamp: run.createdAt }),
                     modelId: run.model?.id ?? plan.wireID,
                 };
-                let cancelPromise;
-                const cancel = () => {
-                    if (cancelPromise !== undefined || !run.supports("cancel"))
-                        return;
-                    cancelPromise = run.cancel().catch(() => { });
+                const live = {
+                    identity: liveIdentity(request),
+                    session,
+                    run,
+                    messages: run.stream()[Symbol.asyncIterator](),
+                    toolBridge,
+                    translate: createMessageTranslator(),
+                    plan,
+                    nextMessage: undefined,
+                    continuation: undefined,
+                    sawUsage: false,
                 };
-                request.signal?.addEventListener("abort", cancel);
-                if (request.signal?.aborted)
-                    cancel();
-                let sawUsage = false;
-                const response = createResponseJournal();
-                const translate = createMessageTranslator();
-                try {
-                    for await (const message of run.stream()) {
-                        if (request.signal?.aborted) {
-                            yield { type: "failed", error: { kind: "cancelled" } };
-                            return;
-                        }
-                        if (request.includeRawChunks === true)
-                            yield { type: "raw", value: message };
-                        for (const candidate of translate(message)) {
-                            const event = response.accept(candidate);
-                            if (event === undefined)
-                                continue;
-                            if (event.type === "usage")
-                                sawUsage = true;
-                            yield event;
-                        }
-                    }
-                    if (request.signal?.aborted) {
-                        yield { type: "failed", error: { kind: "cancelled" } };
-                        return;
-                    }
-                    const result = await run.wait();
-                    if (result.status === "cancelled") {
-                        yield { type: "failed", error: { kind: "cancelled" } };
-                        return;
-                    }
-                    if (!sawUsage && result.usage !== undefined)
-                        yield usageEvent(result.usage);
-                    if (result.status === "error") {
-                        yield {
-                            type: "failed",
-                            error: { kind: "agent-run-failed", detail: result.error?.message ?? result.id },
-                        };
-                        return;
-                    }
-                    if (request.scope && plan.kind !== "ONE_SHOT") {
-                        ctx.bindings.put({
-                            sessionID: request.scope.sessionID,
-                            agentID: session.id,
-                            modelID: request.modelID,
-                            cwd: request.scope.cwd,
-                            checkpoint: checkpointOf(withResponse(request.conversation, response.parts())),
-                            params: request.params,
-                            mode: request.mode,
-                            agentOptions: request.agentOptions,
-                            lastUsedAt: nowMs(ctx.clock),
-                        });
-                    }
-                    yield {
-                        type: "done",
-                        reason: "stop",
-                        metadata: {
-                            runId: result.id,
-                            ...(result.requestId === undefined ? {} : { requestId: result.requestId }),
-                            ...(result.durationMs === undefined ? {} : { durationMs: result.durationMs }),
-                            ...(result.model === undefined ? {} : { modelId: result.model.id }),
-                        },
-                    };
-                    return;
-                }
-                finally {
-                    request.signal?.removeEventListener("abort", cancel);
-                    await cancelPromise;
+                const outcome = yield* drainLiveRun(ctx, request, live);
+                if (outcome === "suspended" && request.scope !== undefined) {
+                    liveRuns.set(request.scope.sessionID, live);
+                    session = undefined;
                 }
+                return;
             }
             catch (error) {
                 if (retryLost && !emitted && plan.kind === "RESUME" && request.scope && isAgentLost(error)) {
@@ -158,6 +171,125 @@ async function* runTurn(ctx, request) {
         release();
     }
 }
+function liveIdentity(request) {
+    return canonicalJson({
+        modelID: request.modelID,
+        cwd: request.scope?.cwd,
+        params: request.params,
+        mode: request.mode,
+        agentOptions: request.agentOptions,
+        tools: request.tools,
+    });
+}
+async function* drainLiveRun(ctx, request, live) {
+    let cancelPromise;
+    const cancel = () => {
+        live.toolBridge?.cancel("The OpenCode request was cancelled");
+        if (cancelPromise !== undefined || !live.run.supports("cancel"))
+            return;
+        cancelPromise = live.run.cancel().catch(() => { });
+    };
+    request.signal?.addEventListener("abort", cancel);
+    if (request.signal?.aborted)
+        cancel();
+    const response = createResponseJournal();
+    try {
+        while (true) {
+            if (request.signal?.aborted) {
+                yield { type: "failed", error: { kind: "cancelled" } };
+                return "finished";
+            }
+            const nextMessage = live.nextMessage ?? live.messages.next();
+            live.nextMessage = nextMessage;
+            const next = live.toolBridge === undefined
+                ? { type: "message", value: await nextMessage }
+                : await Promise.race([
+                    nextMessage.then((value) => ({ type: "message", value })),
+                    live.toolBridge.waitForCalls().then(() => ({ type: "tools" })),
+                ]);
+            if (next.type === "tools") {
+                const calls = live.toolBridge?.takeCalls() ?? [];
+                if (calls.length === 0)
+                    continue;
+                for (const call of calls) {
+                    const event = { type: "tool-request", ...call };
+                    response.accept(event);
+                    yield event;
+                }
+                live.continuation = {
+                    checkpoint: checkpointOf(withResponse(request.conversation, response.parts())),
+                    calls: calls.map((call) => ({ id: call.id, name: call.name })),
+                };
+                yield { type: "done", reason: "tool-calls" };
+                return "suspended";
+            }
+            live.nextMessage = undefined;
+            if (next.value.done)
+                break;
+            const message = next.value.value;
+            if (request.includeRawChunks === true)
+                yield { type: "raw", value: message };
+            for (const candidate of live.translate(message)) {
+                if ((candidate.type === "tool-call" || candidate.type === "tool-result") &&
+                    live.toolBridge?.isCursorCall(candidate.id)) {
+                    continue;
+                }
+                const event = response.accept(candidate);
+                if (event === undefined)
+                    continue;
+                if (event.type === "usage")
+                    live.sawUsage = true;
+                yield event;
+            }
+        }
+        const result = await live.run.wait();
+        if (result.status === "cancelled") {
+            yield { type: "failed", error: { kind: "cancelled" } };
+            return "finished";
+        }
+        if (!live.sawUsage && result.usage !== undefined)
+            yield usageEvent(result.usage);
+        if (result.status === "error") {
+            yield { type: "failed", error: { kind: "agent-run-failed", detail: result.error?.message ?? result.id } };
+            return "finished";
+        }
+        if (request.scope && live.plan.kind !== "ONE_SHOT") {
+            ctx.bindings.put({
+                sessionID: request.scope.sessionID,
+                agentID: live.session.id,
+                modelID: request.modelID,
+                cwd: request.scope.cwd,
+                checkpoint: checkpointOf(withResponse(request.conversation, response.parts())),
+                params: request.params,
+                mode: request.mode,
+                agentOptions: request.agentOptions,
+                lastUsedAt: nowMs(ctx.clock),
+            });
+        }
+        yield {
+            type: "done",
+            reason: "stop",
+            metadata: {
+                runId: result.id,
+                ...(result.requestId === undefined ? {} : { requestId: result.requestId }),
+                ...(result.durationMs === undefined ? {} : { durationMs: result.durationMs }),
+                ...(result.model === undefined ? {} : { modelId: result.model.id }),
+            },
+        };
+        return "finished";
+    }
+    finally {
+        request.signal?.removeEventListener("abort", cancel);
+        await cancelPromise;
+    }
+}
+async function closeLiveRun(live, reason) {
+    live.toolBridge?.cancel(reason);
+    if (live.run.supports("cancel"))
+        await live.run.cancel().catch(() => { });
+    await live.nextMessage?.catch(() => { });
+    await live.session.dispose();
+}
 function withResponse(conversation, parts) {
     if (parts.length === 0)
         return conversation;

package/dist/catalog/catalog.js

@@ -47,7 +47,7 @@ function writeModel(draft, catalogID, model) {
         entry.modelID = Model.ID.make(model.wireID);
         entry.providerID = defaults.providerID;
         entry.name = model.name;
-        entry.capabilities = { tools: false, input: ["text", "image"], output: ["text"] };
+        entry.capabilities = { tools: true, input: ["text", "image"], output: ["text"] };
         entry.variants = toCatalogVariants(model);
         entry.time = defaults.time;
         entry.cost = defaults.cost;

package/dist/model/language-model.js

@@ -95,9 +95,6 @@ function appendReasoning(content, delta) {
     content.push({ type: "reasoning", text: delta });
 }
 function parseCall(options, modelID, params) {
-    if (options.tools !== undefined && options.tools.length > 0) {
-        refuse({ kind: "unsupported-request", reason: "tools-requested" });
-    }
     if (options.toolChoice !== undefined && options.toolChoice.type !== "auto") {
         refuse({ kind: "unsupported-request", reason: "tool-choice" });
     }
@@ -132,16 +129,51 @@ function parseCall(options, modelID, params) {
     const extracted = extractScope(system);
     const conversation = { system: extracted.system, turns };
     const cursor = parseCursorOptions(options.providerOptions?.cursor);
+    const tools = parseTools(options.tools);
     return {
         modelID,
         scope: extracted.scope,
         conversation,
+        ...(tools.length === 0 ? {} : { tools }),
         ...cursor,
         ...(options.includeRawChunks === true ? { includeRawChunks: true } : {}),
         ...(params === undefined ? {} : { params }),
         ...(options.abortSignal === undefined ? {} : { signal: options.abortSignal }),
     };
 }
+function parseTools(tools) {
+    if (tools === undefined)
+        return [];
+    const parsed = [];
+    for (const tool of tools) {
+        if (tool.type !== "function")
+            refuse({ kind: "unsupported-request", reason: "tools-requested" });
+        const inputSchema = sdkJsonValue(tool.inputSchema);
+        if (typeof inputSchema !== "object" || inputSchema === null || Array.isArray(inputSchema)) {
+            refuse({ kind: "unsupported-request", reason: "tools-requested" });
+        }
+        parsed.push({
+            name: tool.name,
+            ...(tool.description === undefined ? {} : { description: tool.description }),
+            inputSchema,
+        });
+    }
+    return parsed;
+}
+function sdkJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : String(value);
+    if (Array.isArray(value))
+        return value.map(sdkJsonValue);
+    if (typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .filter((entry) => entry[1] !== undefined)
+            .map(([key, item]) => [key, sdkJsonValue(item)]));
+    }
+    return String(value);
+}
 function assistantParts(content) {
     const parts = [];
     for (const part of content) {
@@ -352,6 +384,18 @@ function toStreamParts(events, abort, warnings) {
                             });
                             tools.set(event.id, "called");
                             break;
+                        case "tool-request":
+                            if (tools.has(event.id))
+                                break;
+                            closeOpenParts();
+                            controller.enqueue({
+                                type: "tool-call",
+                                toolCallId: event.id,
+                                toolName: event.name,
+                                input: JSON.stringify(event.input),
+                            });
+                            tools.set(event.id, "called");
+                            break;
                         case "tool-result":
                             if (tools.get(event.id) === "completed")
                                 break;
@@ -535,5 +579,7 @@ function reasonFrom(reason) {
         return { unified: "stop", raw: reason };
     if (reason === "length")
         return { unified: "length", raw: reason };
+    if (reason === "tool-calls")
+        return { unified: "tool-calls", raw: reason };
     return { unified: "other", raw: reason };
 }

package/dist/plugin.d.ts

@@ -4,7 +4,12 @@ export interface ModelWatcherDependencies {
     onLinked(listener: () => void): () => void;
     subscribe(signal: AbortSignal): AsyncIterable<{
         readonly type: string;
+        readonly data?: unknown;
     }>;
+    onEvent?(event: {
+        readonly type: string;
+        readonly data?: unknown;
+    }): Promise<void> | void;
     refresh(): Promise<void>;
     close(): Promise<void>;
 }

package/dist/plugin.js

@@ -4,7 +4,7 @@ import { createSessionAgentBridge } from "./bridge/bridge.js";
 import { sessionFromId } from "./bridge/correlation.js";
 import { applyModels, applyProvider, modelParamsFromOptions } from "./catalog/catalog.js";
 import { createModelSource } from "./catalog/source.js";
-import { asCatalogModelID, PROVIDER_ID } from "./ids.js";
+import { asCatalogModelID, asSessionID, PROVIDER_ID } from "./ids.js";
 import { toLanguageModel } from "./model/language-model.js";
 import { bindRuntime } from "./runtime.js";
 const REFRESH_EVERY_MS = 5_000;
@@ -42,7 +42,6 @@ export const plugin = Plugin.define({
                 applyModels(draft, models.list());
             }),
             await ctx.session.hook("context", async (event) => {
-                event.tools = {};
                 if (String(event.agent) === "compaction" || String(event.agent) === "title")
                     return;
                 const stamped = bridge.annotate(event.system.map((part) => part.text), sessionFromId(event.sessionID, await sessionCwd(ctx, event.sessionID)));
@@ -62,11 +61,17 @@ export const plugin = Plugin.define({
         const stopRefresh = watchModels({
             onLinked: (listener) => link.onLinked(listener),
             subscribe: (signal) => ctx.event.subscribe({ signal }),
+            onEvent: async (event) => {
+                const sessionID = endedSessionID(event);
+                if (sessionID !== undefined)
+                    await bridge.cancel(asSessionID(sessionID), "The OpenCode session stopped");
+            },
             refresh: () => models.refresh(),
             close: () => models.close(),
         });
         return async () => {
             await stopRefresh();
+            await bridge.dispose();
             for (const registration of registrations.toReversed()) {
                 await registration.dispose();
             }
@@ -118,6 +123,7 @@ export function watchModels(dependencies) {
     const eventTask = (async () => {
         try {
             for await (const event of dependencies.subscribe(events.signal)) {
+                await dependencies.onEvent?.(event);
                 if (event.type === "credential.updated" || event.type === "credential.switched")
                     refresh();
             }
@@ -147,3 +153,10 @@ export function watchModels(dependencies) {
         return cleanup;
     };
 }
+function endedSessionID(event) {
+    if (event.type !== "session.idle" && event.type !== "session.deleted")
+        return undefined;
+    if (typeof event.data !== "object" || event.data === null || !("sessionID" in event.data))
+        return undefined;
+    return typeof event.data.sessionID === "string" ? event.data.sessionID : undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-cursor-provider",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "OpenCode 2 plugin that connects Cursor via the official SDK",
   "type": "module",
   "license": "Apache-2.0",