cursor-opencode-provider 0.2.6 → 0.2.8

package/dist/shell-timeout.js

@@ -1,6 +1,6 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, delimiter, join } from "node:path";
 /** Cursor agent.v1 TimeoutBehavior enum values. */
 export const CURSOR_TIMEOUT_CANCEL = 1;
 export const CURSOR_TIMEOUT_BACKGROUND = 2;
@@ -14,9 +14,34 @@ const TIMEOUT_MARKER = "__CURSOR_SHELL_TIMEOUT__";
 export const BACKGROUND_SHELL_MARKER = "__CURSOR_BACKGROUND_SHELL__";
 const policies = new Map();
 const outcomes = new Map();
-/** callIDs that need shell.env injectors (so args.command can stay display-original). */
+/** callIDs that need shell.env injectors or a direct-command fallback. */
 const pendingEnvWraps = new Set();
 const activeEnvWraps = new Map();
+let configuredShell;
+/** Track OpenCode's configured shell from the classic config hook. */
+export function setCursorShellPath(shell) {
+    configuredShell = shell?.trim() || undefined;
+}
+function executableOnPath(name) {
+    for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+        if (dir && existsSync(join(dir, name)))
+            return true;
+    }
+    return false;
+}
+/**
+ * Mirror the relevant part of OpenCode Shell.acceptable(): fish/nu are denied,
+ * then POSIX falls back to bash when installed and `/bin/sh` otherwise.
+ */
+export function resolveCursorShellKind(shell = configuredShell ?? process.env.SHELL) {
+    let name = shell ? basename(shell).toLowerCase().replace(/\.exe$/, "") : "";
+    if (name === "fish" || name === "nu" || !name) {
+        name = executableOnPath("bash") ? "bash" : "sh";
+    }
+    if (name === "bash" || name === "zsh" || name === "sh" || name === "dash")
+        return name;
+    return "other";
+}
 function remember(map, key, value, onEvict) {
     map.delete(key);
     map.set(key, value);
@@ -128,37 +153,12 @@ export function buildBackgroundShellCommand(command) {
         `printf '${BACKGROUND_SHELL_MARKER}%s:%s\\n' "$bg_pid" "$bg_log"`,
     ].join("\n");
 }
-/**
- * Prepare OpenCode Bash args before execution when Cursor requested wrapping.
- *
- * Important: do **not** replace `args.command` with the wrapper script.
- * OpenCode's bash UI renders `state.input.command`, and `ctx.metadata()`
- * persists the execute-time `args` object into that field. Mutating
- * `args.command` therefore leaks the private wrapper into the TUI/GUI.
- *
- * Wrapping is applied later via {@link cursorShellEnvForCall} (`shell.env`),
- * which uses BASH_ENV / ZDOTDIR injectors so bash/zsh `-c <original>` is
- * replaced with the wrapper while the stored/displayed command stays original.
- * Permissions also keep analyzing the real user command.
- */
-export function prepareCursorShellArgs(toolCallId, args) {
-    const policy = policies.get(toolCallId);
-    if (!policy)
-        return;
-    if (policy.backgroundSpawn) {
-        pendingEnvWraps.add(toolCallId);
-        return;
-    }
-    if (policy.timeoutBehavior !== CURSOR_TIMEOUT_BACKGROUND)
-        return;
-    pendingEnvWraps.add(toolCallId);
-    // The wrapper returns just after Cursor's foreground window. OpenCode's own
-    // timeout is only an outer safety net and must not win the race.
-    args.timeout = Math.max(OPENCODE_TIMEOUT_GRACE_MS, policy.timeoutMs + OPENCODE_TIMEOUT_GRACE_MS);
-}
-/** Restore the model-facing command in OpenCode's completed tool title. */
-export function cursorShellOriginalCommand(toolCallId) {
-    return policies.get(toolCallId)?.command || undefined;
+function wrapperBodyForPolicy(policy) {
+    if (policy.backgroundSpawn)
+        return buildBackgroundShellCommand(policy.command);
+    if (policy.timeoutBehavior === CURSOR_TIMEOUT_BACKGROUND)
+        return buildSoftBackgroundCommand(policy);
+    return undefined;
 }
 function writeShellEnvInjector(wrapperBody) {
     const dir = mkdtempSync(join(tmpdir(), "cursor-opencode-wrap-"));
@@ -166,13 +166,8 @@ function writeShellEnvInjector(wrapperBody) {
     const bashEnvPath = join(dir, "bashenv.sh");
     const zshenvPath = join(dir, ".zshenv");
     writeFileSync(wrapperPath, `${wrapperBody}\n`, { mode: 0o700 });
-    // Sourced by non-interactive bash (BASH_ENV) or zsh (.zshenv via ZDOTDIR).
-    // `exec` replaces the host shell so OpenCode's `-c <original>` body never runs.
-    //
-    // Do not gate on a sticky env flag: soft-background children inherit the
-    // wrapper environment, and a leftover CURSOR_OPENCODE_WRAP_ACTIVE=1 would
-    // make later injectors no-op (original `-c` runs unwrapped). Unsetting the
-    // injector vars before `exec` is enough to prevent re-entry.
+    // Sourced by bash (BASH_ENV) or zsh (.zshenv via ZDOTDIR). `exec`
+    // replaces the host shell before OpenCode's `-c <original>` body runs.
     const injector = [
         "unset BASH_ENV ZDOTDIR ENV CURSOR_OPENCODE_WRAP_ACTIVE",
         `exec /bin/sh ${shellQuote(wrapperPath)}`,
@@ -181,6 +176,7 @@ function writeShellEnvInjector(wrapperBody) {
     writeFileSync(bashEnvPath, injector, { mode: 0o600 });
     writeFileSync(zshenvPath, injector, { mode: 0o600 });
     return {
+        wrapperPath,
         env: {
             BASH_ENV: bashEnvPath,
             ZDOTDIR: dir,
@@ -195,6 +191,55 @@ function writeShellEnvInjector(wrapperBody) {
         },
     };
 }
+function ensureShellEnvWrap(toolCallId, policy) {
+    const existing = activeEnvWraps.get(toolCallId);
+    if (existing)
+        return existing;
+    const wrapperBody = wrapperBodyForPolicy(policy);
+    if (!wrapperBody)
+        return undefined;
+    const wrap = writeShellEnvInjector(wrapperBody);
+    remember(activeEnvWraps, toolCallId, wrap, (evicted) => evicted.cleanup());
+    return wrap;
+}
+/**
+ * Prepare OpenCode Bash args before execution when Cursor requested wrapping.
+ *
+ * bash/zsh source the shell.env injector, so the original command remains in
+ * OpenCode's permission/UI state. sh/dash ignore those startup variables; for
+ * them, use a short `exec wrapper.sh` command that contains no user payload.
+ *
+ * background_shell_spawn may already contain the inline non-plugin fallback.
+ * The classic hook replaces it with the original command (bash/zsh) or the
+ * shorter wrapper-file command (sh/dash), avoiding duplicate execution.
+ */
+export function prepareCursorShellArgs(toolCallId, args) {
+    const policy = policies.get(toolCallId);
+    if (!policy)
+        return;
+    if (!policy.backgroundSpawn && policy.timeoutBehavior !== CURSOR_TIMEOUT_BACKGROUND)
+        return;
+    pendingEnvWraps.add(toolCallId);
+    if (!policy.backgroundSpawn) {
+        // The wrapper returns just after Cursor's foreground window. OpenCode's own
+        // timeout is only an outer safety net and must not win the race.
+        args.timeout = Math.max(OPENCODE_TIMEOUT_GRACE_MS, policy.timeoutMs + OPENCODE_TIMEOUT_GRACE_MS);
+    }
+    const shellKind = resolveCursorShellKind();
+    if (process.platform === "win32" || shellKind === "bash" || shellKind === "zsh") {
+        // Native Windows PowerShell/cmd wrapping remains unsupported; do not emit
+        // a POSIX /bin/sh command there. Git Bash still uses the env path above.
+        args.command = policy.command;
+        return;
+    }
+    const wrap = ensureShellEnvWrap(toolCallId, policy);
+    if (wrap)
+        args.command = `exec /bin/sh ${shellQuote(wrap.wrapperPath)}`;
+}
+/** Restore the model-facing command in OpenCode's completed tool title. */
+export function cursorShellOriginalCommand(toolCallId) {
+    return policies.get(toolCallId)?.command || undefined;
+}
 /** Drop injector temp files for a finished/abandoned Cursor shell call. */
 export function releaseCursorShellEnv(toolCallId) {
     pendingEnvWraps.delete(toolCallId);
@@ -205,8 +250,8 @@ export function releaseCursorShellEnv(toolCallId) {
     active.cleanup();
 }
 /**
- * Env vars for OpenCode's `shell.env` hook so bash/zsh execute the Cursor
- * wrapper while `args.command` (and therefore the bash UI) stay original.
+ * Env vars for OpenCode's shell.env hook. bash/zsh execute the injector; the
+ * same materialized wrapper backs the direct-command sh/dash fallback.
  */
 export function cursorShellEnvForCall(toolCallId) {
     if (typeof toolCallId !== "string" || !toolCallId || !pendingEnvWraps.has(toolCallId))
@@ -214,18 +259,9 @@ export function cursorShellEnvForCall(toolCallId) {
     const policy = policies.get(toolCallId);
     if (!policy)
         return undefined;
-    const existing = activeEnvWraps.get(toolCallId);
-    if (existing)
-        return existing.env;
-    const wrapperBody = policy.backgroundSpawn
-        ? buildBackgroundShellCommand(policy.command)
-        : policy.timeoutBehavior === CURSOR_TIMEOUT_BACKGROUND
-            ? buildSoftBackgroundCommand(policy)
-            : undefined;
-    if (!wrapperBody)
+    const wrap = ensureShellEnvWrap(toolCallId, policy);
+    if (!wrap)
         return undefined;
-    const wrap = writeShellEnvInjector(wrapperBody);
-    remember(activeEnvWraps, toolCallId, wrap, (evicted) => evicted.cleanup());
     pendingEnvWraps.delete(toolCallId);
     return wrap.env;
 }
@@ -430,4 +466,5 @@ export function resetCursorShellCalls() {
     pendingEnvWraps.clear();
     policies.clear();
     outcomes.clear();
+    configuredShell = undefined;
 }

package/dist/transport/connect.d.ts

@@ -5,6 +5,7 @@ export declare function unaryAvailableModels(token: string, options?: {
     apiBaseURL?: string;
     baseURL?: string;
     headers?: Record<string, string>;
+    timeoutMs?: number;
 }): Promise<Record<string, unknown>>;
 /**
  * Cursor Run stream hosts from GetServerConfig / agentBaseURL.
@@ -30,6 +31,7 @@ export declare function fetchAgentUrl(token: string, options?: {
     apiBaseURL?: string;
     baseURL?: string;
     telemetryEnabled?: boolean;
+    timeoutMs?: number;
 }): Promise<string>;
 export type BidiStream = {
     write(msg: Uint8Array): boolean | void;

package/dist/transport/connect.js

@@ -5,8 +5,25 @@ import { getDeviceIds } from "../protocol/device-id.js";
 import { resolveClientVersion } from "../protocol/client-version.js";
 import { trace } from "../debug.js";
 import { CursorLocalCancellationError, CursorProtocolError, CursorTransportError, cursorGrpcError, cursorHttpError, errorCode, CursorProviderError, } from "../errors.js";
+import { withAbortDeadline } from "../deadline.js";
 import http2 from "node:http2";
 const API_BASE = `https://${CURSOR_API_HOST}`;
+const DEFAULT_UNARY_TIMEOUT_MS = 5_000;
+const MAX_TIMER_MS = 2_147_483_647;
+function unaryTimeoutMs(operation, value) {
+    const timeoutMs = value ?? DEFAULT_UNARY_TIMEOUT_MS;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMER_MS) {
+        throw new CursorProtocolError(`${operation} timeout must be a positive integer no greater than ${MAX_TIMER_MS}`, { code: "CURSOR_INVALID_TIMEOUT" });
+    }
+    return timeoutMs;
+}
+async function withUnaryDeadline(operation, timeoutMs, timeoutCode, run) {
+    return withAbortDeadline(timeoutMs, () => new CursorTransportError(`${operation} timed out after ${timeoutMs}ms`, {
+        transient: true,
+        replaySafe: true,
+        code: timeoutCode,
+    }), run);
+}
 function resolveApiBaseURL(options) {
     return new URL(options.apiBaseURL ?? options.baseURL ?? API_BASE).origin;
 }
@@ -33,42 +50,46 @@ export function buildBaseHeaders(token, clientVersion, extra) {
 export async function unaryAvailableModels(token, options = {}) {
     const base = resolveApiBaseURL(options);
     const url = `${base}/aiserver.v1.AiService/AvailableModels`;
-    const clientVersion = await resolveClientVersion();
-    const headers = buildBaseHeaders(token, clientVersion, options.headers);
-    let res;
-    try {
-        res = await fetch(url, {
-            method: "POST",
-            headers: {
-                ...headers,
-                "content-type": "application/json",
-                accept: "application/json",
-            },
-            // Request parameterized effort/context/fast variants like Cursor IDE.
-            body: JSON.stringify({
-                includeLongContextModels: true,
-                useModelParameters: true,
-                useCloudAgentEffortModes: true,
-            }),
-        });
-    }
-    catch (cause) {
-        throw new CursorTransportError("AvailableModels network request failed", {
-            transient: true,
-            replaySafe: true,
-            code: errorCode(cause),
-            cause,
-        });
-    }
-    if (!res.ok) {
-        throw await cursorHttpResponseError("AvailableModels failed:", res);
-    }
-    try {
-        return (await res.json());
-    }
-    catch (cause) {
-        throw new CursorProtocolError("AvailableModels returned malformed JSON", { cause });
-    }
+    const timeoutMs = unaryTimeoutMs("AvailableModels", options.timeoutMs);
+    return withUnaryDeadline("AvailableModels", timeoutMs, "CURSOR_AVAILABLE_MODELS_TIMEOUT", async (signal) => {
+        const clientVersion = await resolveClientVersion();
+        const headers = buildBaseHeaders(token, clientVersion, options.headers);
+        let res;
+        try {
+            res = await fetch(url, {
+                method: "POST",
+                headers: {
+                    ...headers,
+                    "content-type": "application/json",
+                    accept: "application/json",
+                },
+                // Request parameterized effort/context/fast variants like Cursor IDE.
+                body: JSON.stringify({
+                    includeLongContextModels: true,
+                    useModelParameters: true,
+                    useCloudAgentEffortModes: true,
+                }),
+                signal,
+            });
+        }
+        catch (cause) {
+            throw new CursorTransportError("AvailableModels network request failed", {
+                transient: true,
+                replaySafe: true,
+                code: errorCode(cause),
+                cause,
+            });
+        }
+        if (!res.ok) {
+            throw await cursorHttpResponseError("AvailableModels failed:", res);
+        }
+        try {
+            return (await res.json());
+        }
+        catch (cause) {
+            throw new CursorProtocolError("AvailableModels returned malformed JSON", { cause });
+        }
+    });
 }
 // ── Unary (GetServerConfig) ──
 /**
@@ -116,51 +137,55 @@ export function normalizeAgentRunOrigin(raw) {
 export async function fetchAgentUrl(token, options = {}) {
     const base = resolveApiBaseURL(options);
     const url = `${base}${SERVER_CONFIG_PATH}`;
-    const clientVersion = await resolveClientVersion();
-    // Match Cursor CLI: GetServerConfig uses base headers only — session headers belong on Run.
-    const headers = buildBaseHeaders(token, clientVersion);
-    trace(`GetServerConfig POST ${url}`);
-    let res;
-    try {
-        res = await fetch(url, {
-            method: "POST",
-            headers: {
-                ...headers,
-                "content-type": "application/json",
-                accept: "application/json",
-            },
-            body: JSON.stringify({ telem_enabled: options.telemetryEnabled ?? false }),
-        });
-    }
-    catch (cause) {
-        throw new CursorTransportError("GetServerConfig network request failed", {
-            transient: true,
-            replaySafe: true,
-            code: errorCode(cause),
-            cause,
-        });
-    }
-    if (!res.ok) {
-        throw await cursorHttpResponseError("GetServerConfig failed:", res);
-    }
-    let body;
-    try {
-        body = (await res.json());
-    }
-    catch (cause) {
-        throw new CursorProtocolError("GetServerConfig returned malformed JSON", { cause });
-    }
-    const cfg = body.agentUrlConfig;
-    const raw = cfg?.agentnUrl || cfg?.agentUrl;
-    const normalized = normalizeAgentRunOrigin(raw);
-    trace(`GetServerConfig reply: agentnUrl=${cfg?.agentnUrl ?? "<missing>"} ` +
-        `agentUrl=${cfg?.agentUrl ?? "<missing>"} → ${normalized ?? "<invalid>"}`);
-    if (!normalized) {
-        throw new CursorProtocolError(raw
-            ? "GetServerConfig returned an invalid Cursor agent URL"
-            : "GetServerConfig response missing agentUrlConfig.agentnUrl");
-    }
-    return normalized;
+    const timeoutMs = unaryTimeoutMs("GetServerConfig", options.timeoutMs);
+    return withUnaryDeadline("GetServerConfig", timeoutMs, "CURSOR_AGENT_URL_TIMEOUT", async (signal) => {
+        const clientVersion = await resolveClientVersion();
+        // Match Cursor CLI: GetServerConfig uses base headers only — session headers belong on Run.
+        const headers = buildBaseHeaders(token, clientVersion);
+        trace(`GetServerConfig POST ${url}`);
+        let res;
+        try {
+            res = await fetch(url, {
+                method: "POST",
+                headers: {
+                    ...headers,
+                    "content-type": "application/json",
+                    accept: "application/json",
+                },
+                body: JSON.stringify({ telem_enabled: options.telemetryEnabled ?? false }),
+                signal,
+            });
+        }
+        catch (cause) {
+            throw new CursorTransportError("GetServerConfig network request failed", {
+                transient: true,
+                replaySafe: true,
+                code: errorCode(cause),
+                cause,
+            });
+        }
+        if (!res.ok) {
+            throw await cursorHttpResponseError("GetServerConfig failed:", res);
+        }
+        let body;
+        try {
+            body = (await res.json());
+        }
+        catch (cause) {
+            throw new CursorProtocolError("GetServerConfig returned malformed JSON", { cause });
+        }
+        const cfg = body.agentUrlConfig;
+        const raw = cfg?.agentnUrl || cfg?.agentUrl;
+        const normalized = normalizeAgentRunOrigin(raw);
+        trace(`GetServerConfig reply: agentnUrl=${cfg?.agentnUrl ?? "<missing>"} ` +
+            `agentUrl=${cfg?.agentUrl ?? "<missing>"} → ${normalized ?? "<invalid>"}`);
+        if (!normalized) {
+            throw new CursorProtocolError(raw
+                ? "GetServerConfig returned an invalid Cursor agent URL"
+                : "GetServerConfig response missing agentUrlConfig.agentnUrl");
+        }
+        return normalized;
+    });
 }
 export class CursorRunInterruptedError extends CursorTransportError {
     constructor(message = "Cursor Run ended before turn_ended", options) {
@@ -217,7 +242,6 @@ const CONNECT_TIMEOUT_MS = 15_000;
 const DEFAULT_SESSION_PING_TIMEOUT_MS = 5_000;
 const DEFAULT_READ_IDLE_MS = 120_000;
 const WRITE_DRAIN_TIMEOUT_CODE = "CURSOR_WRITE_DRAIN_TIMEOUT";
-const MAX_TIMER_MS = 2_147_483_647;
 export const HTTP2_SESSION_MAX_AGE_MS = 15 * 60_000;
 export function shouldReuseHttp2Session(state, createdAt, now = Date.now()) {
     return !state.destroyed && !state.closed && now - createdAt < HTTP2_SESSION_MAX_AGE_MS;

package/dist/web-tools.d.ts

@@ -0,0 +1,34 @@
+import { type ToolContext, type ToolResult } from "@opencode-ai/plugin";
+export type OpenCodeWebSearchArgs = {
+    query: string;
+    numResults?: number;
+    livecrawl?: "fallback" | "preferred";
+    type?: "auto" | "fast" | "deep";
+    contextMaxCharacters?: number;
+};
+export declare function parseOpenCodeWebSearchResponse(raw: string): string | undefined;
+export declare function executeOpenCodeWebSearch(args: OpenCodeWebSearchArgs, context: ToolContext, fetchImpl?: typeof fetch): Promise<ToolResult>;
+export declare const openCodeWebSearchTool: {
+    description: string;
+    args: {
+        query: import("zod").ZodString;
+        numResults: import("zod").ZodOptional<import("zod").ZodNumber>;
+        livecrawl: import("zod").ZodOptional<import("zod").ZodEnum<{
+            fallback: "fallback";
+            preferred: "preferred";
+        }>>;
+        type: import("zod").ZodOptional<import("zod").ZodEnum<{
+            fast: "fast";
+            auto: "auto";
+            deep: "deep";
+        }>>;
+        contextMaxCharacters: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        query: string;
+        numResults?: number | undefined;
+        livecrawl?: "fallback" | "preferred" | undefined;
+        type?: "fast" | "auto" | "deep" | undefined;
+        contextMaxCharacters?: number | undefined;
+    }, context: ToolContext): Promise<ToolResult>;
+};

package/dist/web-tools.js

@@ -0,0 +1,127 @@
+import { tool } from "@opencode-ai/plugin";
+const EXA_MCP_URL = "https://mcp.exa.ai/mcp";
+const WEB_SEARCH_TIMEOUT_MS = 25_000;
+function exaMcpUrl() {
+    const apiKey = process.env.EXA_API_KEY;
+    if (!apiKey)
+        return EXA_MCP_URL;
+    const url = new URL(EXA_MCP_URL);
+    url.searchParams.set("exaApiKey", apiKey);
+    return url.href;
+}
+function mcpText(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const result = value.result;
+    if (!result || typeof result !== "object")
+        return undefined;
+    const content = result.content;
+    if (!Array.isArray(content))
+        return undefined;
+    for (const item of content) {
+        if (item &&
+            typeof item === "object" &&
+            item.type === "text" &&
+            typeof item.text === "string") {
+            return item.text;
+        }
+    }
+    return undefined;
+}
+export function parseOpenCodeWebSearchResponse(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        const text = mcpText(JSON.parse(trimmed));
+        if (text)
+            return text;
+    }
+    catch {
+        // MCP may respond as an SSE stream instead of one JSON object.
+    }
+    for (const line of raw.split("\n")) {
+        if (!line.startsWith("data: "))
+            continue;
+        try {
+            const text = mcpText(JSON.parse(line.slice(6)));
+            if (text)
+                return text;
+        }
+        catch {
+            // Ignore non-JSON SSE events.
+        }
+    }
+    return undefined;
+}
+export async function executeOpenCodeWebSearch(args, context, fetchImpl = fetch) {
+    await context.ask({
+        permission: "websearch",
+        patterns: [args.query],
+        always: ["*"],
+        metadata: {
+            query: args.query,
+            numResults: args.numResults,
+            livecrawl: args.livecrawl,
+            type: args.type,
+            contextMaxCharacters: args.contextMaxCharacters,
+            provider: "exa",
+        },
+    });
+    const controller = new AbortController();
+    const abort = () => controller.abort(context.abort.reason);
+    if (context.abort.aborted)
+        abort();
+    else
+        context.abort.addEventListener("abort", abort, { once: true });
+    const timeout = setTimeout(() => controller.abort(new Error("Web search timed out")), WEB_SEARCH_TIMEOUT_MS);
+    try {
+        const response = await fetchImpl(exaMcpUrl(), {
+            method: "POST",
+            headers: {
+                accept: "application/json, text/event-stream",
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "tools/call",
+                params: {
+                    name: "web_search_exa",
+                    arguments: {
+                        query: args.query,
+                        type: args.type ?? "auto",
+                        numResults: args.numResults ?? 8,
+                        livecrawl: args.livecrawl ?? "fallback",
+                        contextMaxCharacters: args.contextMaxCharacters,
+                    },
+                },
+            }),
+            signal: controller.signal,
+        });
+        const raw = await response.text();
+        if (!response.ok)
+            throw new Error(`Web search failed (${response.status}): ${raw.slice(0, 500)}`);
+        const output = parseOpenCodeWebSearchResponse(raw) ?? "No search results found. Please try a different query.";
+        return {
+            title: `Exa Web Search: ${args.query}`,
+            output,
+            metadata: { provider: "exa" },
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+        context.abort.removeEventListener("abort", abort);
+    }
+}
+export const openCodeWebSearchTool = tool({
+    description: "Search the web for current information using OpenCode's web search backend.",
+    args: {
+        query: tool.schema.string().describe("Web search query"),
+        numResults: tool.schema.number().int().min(1).max(20).optional(),
+        livecrawl: tool.schema.enum(["fallback", "preferred"]).optional(),
+        type: tool.schema.enum(["auto", "fast", "deep"]).optional(),
+        contextMaxCharacters: tool.schema.number().int().positive().optional(),
+    },
+    execute: executeOpenCodeWebSearch,
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",
@@ -61,7 +61,13 @@
     "protobufjs": "^7.4.0"
   },
   "peerDependencies": {
-    "@opencode-ai/plugin": "^1.17.13"
+    "@opencode-ai/plugin": "^1.17.13",
+    "@opencode-compat/profile": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@opencode-compat/profile": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.17.13",
@@ -69,4 +75,4 @@
     "@types/node": "^22.15.3",
     "typescript": "^5.8.3"
   }
-}
+}