@meetopenbot/cursor 0.0.3 → 0.0.5

package/dist/config.js

@@ -1,44 +1,63 @@
+import { lookupSecret, trimmedString, } from '@meetopenbot/plugin-sdk';
 const RUNTIMES = new Set(['local', 'cloud']);
 const MODES = new Set(['agent', 'plan']);
-const SETTING_SOURCES = new Set([
-    'project',
-    'user',
-    'team',
-    'mdm',
-    'plugins',
-    'all',
-]);
 export const CURSOR_API_KEY_ENV_VAR = 'CURSOR_API_KEY';
+export const pluginConfigSchema = {
+    type: 'object',
+    properties: {
+        runtime: {
+            type: 'string',
+            description: 'Agent runtime: local (default) or cloud.',
+            enum: ['local', 'cloud'],
+            default: 'local',
+        },
+        model: {
+            type: 'string',
+            description: 'Cursor model id (default: composer-2.5).',
+            default: 'composer-2.5',
+        },
+        mode: {
+            type: 'string',
+            description: 'Conversation mode: agent (default) or plan.',
+            enum: ['agent', 'plan'],
+        },
+        repoUrl: {
+            type: 'string',
+            description: 'Git repository URL for cloud agents.',
+            format: 'url',
+        },
+        startingRef: {
+            type: 'string',
+            description: 'Git ref to clone for cloud agents (e.g. main).',
+        },
+        autoCreatePR: {
+            type: 'boolean',
+            description: 'Open a pull request when a cloud run finishes.',
+            default: false,
+        },
+        workOnCurrentBranch: {
+            type: 'boolean',
+            description: 'Push cloud commits to the existing branch instead of a new one.',
+            default: false,
+        },
+    },
+};
 export const resolveConfig = (context, channelCwd) => {
     const config = context.config;
     const runtime = config.runtime && RUNTIMES.has(config.runtime) ? config.runtime : 'local';
     const mode = config.mode && MODES.has(config.mode) ? config.mode : undefined;
-    const settingSources = config.settingSources
-        ?.split(',')
-        .map((source) => source.trim())
-        .filter((source) => SETTING_SOURCES.has(source));
     return {
-        apiKey: (typeof config.apiKey === 'string' && config.apiKey.trim()) ||
-            process.env[CURSOR_API_KEY_ENV_VAR],
+        apiKey: lookupSecret({ envKeys: [CURSOR_API_KEY_ENV_VAR] }),
         runtime,
-        model: (typeof config.model === 'string' && config.model.trim()) || 'composer-2.5',
-        thinking: typeof config.thinking === 'string' && config.thinking.trim()
-            ? config.thinking.trim()
-            : undefined,
+        model: trimmedString(config.model) || 'composer-2.5',
         mode,
-        cwd: channelCwd || config.cwd,
-        repoUrl: config.repoUrl?.trim() || undefined,
-        startingRef: config.startingRef?.trim() || undefined,
+        cwd: channelCwd,
+        repoUrl: trimmedString(config.repoUrl),
+        startingRef: trimmedString(config.startingRef),
         autoCreatePR: config.autoCreatePR === true,
         workOnCurrentBranch: config.workOnCurrentBranch === true,
-        settingSources: settingSources?.length ? settingSources : undefined,
-        sandbox: config.sandbox === true,
-        autoReview: config.autoReview === true,
     };
 };
 export const buildModelSelection = (config) => ({
     id: config.model,
-    ...(config.thinking
-        ? { params: [{ id: 'thinking', value: config.thinking }] }
-        : {}),
 });

package/dist/index.js

@@ -1,238 +1,12 @@
-import { agentOutput, buildDiffWidget, definePlugin, diffFileFromMutationTool, resolveRunDiffFiles, shouldHandleInvoke, snapshotWorkspace, toolTraceWidget, uiWidget, } from '@meetopenbot/plugin-sdk';
-import { CURSOR_API_KEY_ENV_VAR, resolveConfig, } from './config.js';
-import { formatCursorError, formatToolResult } from './format.js';
-import { getOrCreateCursorAgent, StaleAgentSessionError } from './session.js';
-import { streamCursorPrompt } from './stream.js';
-export default definePlugin({
-    id: 'cursor',
+import { defineAgentPlugin } from '@meetopenbot/plugin-sdk';
+import { pluginConfigSchema } from './config.js';
+import { mapCursorError, runCursorTurn } from './runtime.js';
+export const plugin = await defineAgentPlugin({
     name: 'Cursor',
     description: 'Cursor coding agent — read, edit, and run code via the Cursor SDK.',
-    configSchema: {
-        type: 'object',
-        properties: {
-            apiKey: {
-                type: 'string',
-                description: 'Cursor API key. Falls back to CURSOR_API_KEY.',
-                format: 'password',
-            },
-            runtime: {
-                type: 'string',
-                description: 'Agent runtime: local (default) or cloud.',
-                enum: ['local', 'cloud'],
-                default: 'local',
-            },
-            model: {
-                type: 'string',
-                description: 'Cursor model id (default: composer-2.5).',
-                default: 'composer-2.5',
-            },
-            thinking: {
-                type: 'string',
-                description: 'Reasoning effort for models that support it (e.g. low, high).',
-            },
-            mode: {
-                type: 'string',
-                description: 'Conversation mode: agent (default) or plan.',
-                enum: ['agent', 'plan'],
-            },
-            cwd: {
-                type: 'string',
-                description: 'Working directory for local agents.',
-            },
-            repoUrl: {
-                type: 'string',
-                description: 'Git repository URL for cloud agents.',
-                format: 'url',
-            },
-            startingRef: {
-                type: 'string',
-                description: 'Git ref to clone for cloud agents (e.g. main).',
-            },
-            autoCreatePR: {
-                type: 'boolean',
-                description: 'Open a pull request when a cloud run finishes.',
-                default: false,
-            },
-            workOnCurrentBranch: {
-                type: 'boolean',
-                description: 'Push cloud commits to the existing branch instead of a new one.',
-                default: false,
-            },
-            settingSources: {
-                type: 'string',
-                description: 'Comma-separated local settings layers: project,user,team,mdm,plugins,all.',
-            },
-            sandbox: {
-                type: 'boolean',
-                description: 'Enable the local agent sandbox.',
-                default: false,
-            },
-            autoReview: {
-                type: 'boolean',
-                description: 'Route local tool calls through Auto-review.',
-                default: false,
-            },
-        },
-    },
-    factory: (context) => (builder) => {
-        builder.on('agent:invoke', async function* (event, handlerCtx) {
-            if (!shouldHandleInvoke(event, context.agentId))
-                return;
-            const threadId = event.meta?.threadId ?? handlerCtx.state.threadId;
-            const prompt = (event.data.content ?? '').trim();
-            if (!prompt) {
-                yield agentOutput({
-                    agentId: context.agentId,
-                    content: 'Send a message to run Cursor in this workspace — for example, "Summarize this repo" or "Fix the failing test in src/foo.test.ts".',
-                    threadId,
-                });
-                return;
-            }
-            const channelCwd = handlerCtx.state.channelDetails?.cwd;
-            const config = resolveConfig(context, channelCwd);
-            if (!config.apiKey) {
-                yield agentOutput({
-                    agentId: context.agentId,
-                    content: `Set a Cursor API key in plugin config (\`apiKey\`) or the \`${CURSOR_API_KEY_ENV_VAR}\` environment variable. Get a key from https://cursor.com/dashboard/api`,
-                    threadId,
-                });
-                return;
-            }
-            if (config.runtime === 'local' && !config.cwd && !channelCwd) {
-                yield agentOutput({
-                    agentId: context.agentId,
-                    content: 'Local Cursor agents need a working directory. Set `cwd` in plugin config or configure a channel `cwd`.',
-                    threadId,
-                });
-                return;
-            }
-            try {
-                let agentHandle = await getOrCreateCursorAgent({
-                    config,
-                    state: handlerCtx.state,
-                    storage: context.storage,
-                });
-                const snapshot = snapshotWorkspace(config.cwd);
-                const runTurn = async function* (wasResumed) {
-                    const toolInfoMap = new Map();
-                    const changedFiles = new Map();
-                    let fullTextContent = '';
-                    for await (const chunk of streamCursorPrompt(agentHandle.agent, prompt, config, wasResumed)) {
-                        switch (chunk.type) {
-                            case 'tool_start':
-                                toolInfoMap.set(chunk.toolCallId, {
-                                    statusLine: chunk.statusLine,
-                                    args: chunk.args,
-                                });
-                                yield uiWidget({
-                                    agentId: context.agentId,
-                                    threadId,
-                                    widget: toolTraceWidget({
-                                        widgetId: chunk.toolCallId,
-                                        groupId: 'cursor:tools',
-                                        title: chunk.statusLine,
-                                        body: `**Input**\n\`\`\`json\n${JSON.stringify(chunk.args ?? {}, null, 2)}\n\`\`\``,
-                                    }),
-                                });
-                                break;
-                            case 'tool_end': {
-                                const info = toolInfoMap.get(chunk.toolCallId);
-                                const args = chunk.args ?? info?.args;
-                                const inputMd = args
-                                    ? `**Input**\n\`\`\`json\n${JSON.stringify(args, null, 2)}\n\`\`\`\n\n`
-                                    : '';
-                                const outputMd = chunk.result != null
-                                    ? `**Output**\n${formatToolResult(chunk.result)}`
-                                    : '';
-                                yield uiWidget({
-                                    agentId: context.agentId,
-                                    threadId,
-                                    widget: toolTraceWidget({
-                                        widgetId: chunk.toolCallId,
-                                        groupId: 'cursor:tools',
-                                        title: chunk.statusLine || info?.statusLine || `Tool ${chunk.toolName} finished`,
-                                        body: inputMd + outputMd,
-                                        state: chunk.isError ? 'error' : 'submitted',
-                                    }),
-                                });
-                                if (!chunk.isError) {
-                                    const file = diffFileFromMutationTool({
-                                        toolName: chunk.toolName,
-                                        input: args,
-                                        result: chunk.result,
-                                    });
-                                    if (file)
-                                        changedFiles.set(file.path, file);
-                                }
-                                break;
-                            }
-                            case 'status':
-                                yield uiWidget({
-                                    agentId: context.agentId,
-                                    threadId,
-                                    widget: toolTraceWidget({
-                                        widgetId: `status-${Date.now()}`,
-                                        groupId: 'cursor:tools',
-                                        title: 'Status',
-                                        body: chunk.statusLine,
-                                    }),
-                                });
-                                break;
-                            case 'text':
-                                if (fullTextContent)
-                                    fullTextContent += '\n\n';
-                                fullTextContent += chunk.content;
-                                break;
-                        }
-                    }
-                    if (fullTextContent.trim()) {
-                        yield agentOutput({
-                            agentId: context.agentId,
-                            content: fullTextContent.trim(),
-                            threadId,
-                        });
-                    }
-                    const diff = buildDiffWidget({
-                        widgetId: `cursor-diff:${threadId ?? 'run'}:${Date.now()}`,
-                        files: resolveRunDiffFiles({
-                            snapshot,
-                            fallback: changedFiles.values(),
-                        }),
-                    });
-                    if (diff) {
-                        yield uiWidget({
-                            agentId: context.agentId,
-                            threadId,
-                            widget: diff,
-                        });
-                    }
-                };
-                try {
-                    yield* runTurn(agentHandle.wasResumed);
-                }
-                catch (streamErr) {
-                    if (streamErr instanceof StaleAgentSessionError) {
-                        console.warn(`[cursor-plugin] Detected stale resumed agent. Re-creating a fresh agent session...`);
-                        agentHandle = await getOrCreateCursorAgent({
-                            config,
-                            state: handlerCtx.state,
-                            storage: context.storage,
-                            forceNew: true,
-                        });
-                        yield* runTurn(agentHandle.wasResumed);
-                    }
-                    else {
-                        throw streamErr;
-                    }
-                }
-            }
-            catch (error) {
-                yield agentOutput({
-                    agentId: context.agentId,
-                    content: `**Cursor error:** ${formatCursorError(error)}`,
-                    threadId,
-                });
-            }
-        });
-    },
+    configSchema: pluginConfigSchema,
+    emptyPrompt: 'Send a message to run Cursor in this workspace — for example, "Summarize this repo" or "Fix the failing test in src/foo.test.ts".',
+    run: runCursorTurn,
+    mapError: mapCursorError,
 });
+export default plugin;

package/dist/runtime.js

@@ -0,0 +1,39 @@
+import { missingSecretMessage, textReply, } from '@meetopenbot/plugin-sdk';
+import { CURSOR_API_KEY_ENV_VAR, resolveConfig } from './config.js';
+import { getOrCreateCursorAgent, StaleAgentSessionError } from './session.js';
+import { runCursorPrompt } from './stream.js';
+export async function* runCursorTurn({ prompt, handlerCtx, context, }) {
+    const channelCwd = handlerCtx.state.channelDetails?.cwd;
+    const config = resolveConfig(context, channelCwd);
+    if (!config.apiKey) {
+        yield textReply(missingSecretMessage(CURSOR_API_KEY_ENV_VAR));
+        return;
+    }
+    if (config.runtime === 'local' && !config.cwd) {
+        yield textReply('Local Cursor agents need a working directory. Configure a channel `cwd`.');
+        return;
+    }
+    let agentHandle = await getOrCreateCursorAgent({
+        config,
+        state: handlerCtx.state,
+        storage: context.storage,
+    });
+    try {
+        yield* runCursorPrompt(agentHandle.agent, prompt, config, agentHandle.wasResumed);
+    }
+    catch (error) {
+        if (!(error instanceof StaleAgentSessionError))
+            throw error;
+        agentHandle = await getOrCreateCursorAgent({
+            config,
+            state: handlerCtx.state,
+            storage: context.storage,
+            forceNew: true,
+        });
+        yield* runCursorPrompt(agentHandle.agent, prompt, config, agentHandle.wasResumed);
+    }
+}
+export function mapCursorError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return textReply(`Cursor error: ${message}`);
+}

package/dist/session.js

@@ -1,6 +1,5 @@
 import { Agent, } from '@cursor/sdk';
 import { buildModelSelection, } from './config.js';
-import { formatCursorError } from './format.js';
 import { persistCursorState, readPersistedState } from './state.js';
 export class StaleAgentSessionError extends Error {
     constructor(message) {
@@ -35,9 +34,6 @@ const buildAgentOptions = (config) => {
     else {
         options.local = {
             cwd: config.cwd || process.cwd(),
-            ...(config.settingSources ? { settingSources: config.settingSources } : {}),
-            ...(config.sandbox ? { sandboxOptions: { enabled: true } } : {}),
-            ...(config.autoReview ? { autoReview: true } : {}),
         };
     }
     return options;
@@ -79,7 +75,7 @@ export const getOrCreateCursorAgent = async (args) => {
             wasResumed = true;
         }
         catch (error) {
-            console.warn(`[cursor-plugin] Failed to resume ${persisted.cursorAgentId}: ${formatCursorError(error)}`);
+            console.warn(`[cursor-plugin] Failed to resume ${persisted.cursorAgentId}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     if (!agent) {

package/dist/stream.js

@@ -1,83 +1,39 @@
+import { emitTextReplies, textReply, } from '@meetopenbot/plugin-sdk';
 import { buildModelSelection } from './config.js';
-import { createStreamState, formatCursorEvent, } from './format.js';
 import { StaleAgentSessionError } from './session.js';
-/** Bridge Cursor SDK run events into an async generator of structured chunks. */
-export async function* streamCursorPrompt(agent, prompt, config, wasResumed) {
-    const state = createStreamState();
-    const pending = [];
-    let wake;
-    let finished = false;
-    let error;
-    const wakeUp = () => {
-        wake?.();
-        wake = undefined;
-    };
+const assistantText = (event) => {
+    if (event.type !== 'assistant')
+        return '';
+    return event.message.content
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('');
+};
+export const classifyCursorEvent = (event) => {
+    if (event.type === 'assistant') {
+        const text = assistantText(event);
+        return text ? { type: 'delta', text } : { type: 'skip' };
+    }
+    // Tool payloads are skipped for now; still flush so prior text lands before the next turn.
+    if (event.type === 'tool_call' || event.type === 'usage')
+        return { type: 'flush' };
+    return { type: 'skip' };
+};
+/** Run a Cursor prompt and yield each completed assistant turn. */
+export async function* runCursorPrompt(agent, prompt, config, wasResumed) {
     const run = await agent.send(prompt, {
         ...(config.mode ? { mode: config.mode } : {}),
         model: buildModelSelection(config),
     });
-    const streamTask = (async () => {
-        try {
-            for await (const event of run.stream()) {
-                const chunk = formatCursorEvent(event, state, config);
-                if (chunk) {
-                    pending.push(chunk);
-                    wakeUp();
-                }
-            }
-            const result = await run.wait();
-            const finalText = (result.result ?? state.assistantText).trim();
-            if (finalText) {
-                pending.push({ type: 'text', content: finalText });
-            }
-            if (result.status === 'error') {
-                if (wasResumed && (result.durationMs ?? 0) < 2000) {
-                    throw new StaleAgentSessionError('Resumed Cursor agent session is stale or expired.');
-                }
-                const details = JSON.stringify(result);
-                pending.push({
-                    type: 'text',
-                    content: `**Cursor error:** Run finished with error status. Details: \`${details}\``,
-                });
-            }
-            else if (result.status === 'cancelled') {
-                pending.push({ type: 'text', content: '**Cursor:** Run cancelled.' });
-            }
-            if (result.git?.branches?.length) {
-                const branches = result.git.branches
-                    .map((branch) => {
-                    const parts = [branch.branch, branch.prUrl].filter(Boolean);
-                    return parts.join(' — ');
-                })
-                    .filter(Boolean);
-                if (branches.length) {
-                    pending.push({ type: 'text', content: `Git: ${branches.join('; ')}` });
-                }
-            }
-        }
-        catch (err) {
-            error = err instanceof Error ? err : new Error(String(err));
-        }
-        finally {
-            finished = true;
-            wakeUp();
-        }
-    })();
-    try {
-        while (!finished || pending.length > 0) {
-            if (pending.length === 0) {
-                await new Promise((resolve) => {
-                    wake = resolve;
-                });
-                continue;
-            }
-            yield pending.shift();
+    yield* emitTextReplies(run.stream(), classifyCursorEvent);
+    const result = await run.wait();
+    if (result.status === 'error') {
+        if (wasResumed && (result.durationMs ?? 0) < 2000) {
+            throw new StaleAgentSessionError('Resumed Cursor agent session is stale or expired.');
         }
-        await streamTask;
-        if (error)
-            throw error;
+        yield textReply(`Cursor error: run finished with status ${result.status}.`);
     }
-    finally {
-        // no-op: keep the Cursor agent alive for follow-ups
+    else if (result.status === 'cancelled') {
+        yield textReply('Cursor run cancelled.');
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/cursor",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "OpenBot agent plugin powered by the Cursor SDK.",
   "type": "module",
   "main": "./dist/index.js",
@@ -20,7 +20,7 @@
   "license": "MIT",
   "dependencies": {
     "@cursor/sdk": "^1.0.18",
-    "@meetopenbot/plugin-sdk": "^0.2.0"
+    "@meetopenbot/plugin-sdk": "^0.4.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.2",

package/dist/format.js

@@ -1,190 +0,0 @@
-import { CursorSdkError } from '@cursor/sdk';
-export const createStreamState = () => ({
-    assistantText: '',
-});
-const truncate = (text, max = 80) => text.length > max ? `${text.slice(0, max - 3)}…` : text;
-const quoteDetail = (detail) => detail.includes('`') ? `"${detail}"` : `\`${detail}\``;
-const strArg = (args, ...keys) => {
-    if (!args || typeof args !== 'object')
-        return undefined;
-    const record = args;
-    for (const key of keys) {
-        const value = record[key];
-        if (typeof value === 'string' && value.trim())
-            return value.trim();
-        if (typeof value === 'number' && Number.isFinite(value))
-            return String(value);
-    }
-    return undefined;
-};
-const formatToolDetail = (toolName, args) => {
-    switch (toolName) {
-        case 'Shell':
-        case 'shell': {
-            const command = strArg(args, 'command');
-            return command ? truncate(command.replace(/\s+/g, ' ')) : undefined;
-        }
-        case 'Read':
-        case 'read': {
-            const path = strArg(args, 'path', 'target_file', 'file_path');
-            return path ? truncate(path, 120) : undefined;
-        }
-        case 'Write':
-        case 'write':
-        case 'Edit':
-        case 'edit':
-        case 'StrReplace':
-        case 'strReplace': {
-            const path = strArg(args, 'path', 'target_file', 'file_path');
-            return path ? truncate(path, 120) : undefined;
-        }
-        case 'Grep':
-        case 'grep': {
-            const pattern = strArg(args, 'pattern');
-            const path = strArg(args, 'path') ?? '.';
-            if (!pattern)
-                return undefined;
-            return `${truncate(pattern)} in ${truncate(path, 60)}`;
-        }
-        case 'Glob':
-        case 'glob':
-        case 'GlobFileSearch':
-        case 'globFileSearch': {
-            const pattern = strArg(args, 'glob_pattern', 'pattern');
-            return pattern ? truncate(pattern) : undefined;
-        }
-        case 'LS':
-        case 'ls':
-        case 'ListDir':
-        case 'listDir': {
-            const path = strArg(args, 'path', 'target_directory') ?? '.';
-            return truncate(path, 120);
-        }
-        default:
-            return undefined;
-    }
-};
-const formatToolStart = (toolName, args) => {
-    const detail = formatToolDetail(toolName, args);
-    if (detail)
-        return `Running **${toolName}** (${quoteDetail(detail)})…`;
-    return `Running **${toolName}**…`;
-};
-const formatCloudStatus = (status, message, config) => {
-    const isCloud = config?.runtime === 'cloud';
-    switch (status) {
-        case 'CREATING':
-            return isCloud ? 'Starting cloud agent…' : 'Starting local agent…';
-        case 'RUNNING':
-            return message ? truncate(message) : undefined;
-        case 'ERROR':
-            return message
-                ? `**Cursor error:** ${message}`
-                : isCloud
-                    ? '**Cursor error:** Cloud run failed.'
-                    : '**Cursor error:** Local run failed.';
-        case 'CANCELLED':
-            return isCloud ? 'Cloud run cancelled.' : 'Local run cancelled.';
-        case 'EXPIRED':
-            return isCloud ? 'Cloud run expired.' : 'Local run expired.';
-        case 'FINISHED':
-            return undefined;
-        default:
-            return message ? truncate(message) : undefined;
-    }
-};
-export const formatToolResult = (result) => {
-    if (result == null)
-        return '';
-    if (typeof result === 'string')
-        return result;
-    try {
-        return JSON.stringify(result, null, 2);
-    }
-    catch {
-        return String(result);
-    }
-};
-/** Map Cursor SDK stream events to structured output chunks. */
-export const formatCursorEvent = (event, state, config) => {
-    switch (event.type) {
-        case 'assistant': {
-            const text = event.message.content
-                .filter((block) => block.type === 'text')
-                .map((block) => block.text)
-                .join('');
-            if (text)
-                state.assistantText += text;
-            return undefined;
-        }
-        case 'tool_call': {
-            if (event.status === 'running') {
-                return {
-                    type: 'tool_start',
-                    toolCallId: event.call_id,
-                    toolName: event.name,
-                    args: event.args,
-                    statusLine: formatToolStart(event.name, event.args),
-                };
-            }
-            const isError = event.status === 'error';
-            return {
-                type: 'tool_end',
-                toolCallId: event.call_id,
-                toolName: event.name,
-                args: event.args,
-                result: event.result,
-                isError,
-                statusLine: isError
-                    ? `Tool **${event.name}** failed.`
-                    : formatToolStart(event.name, event.args).replace(/…$/, ''),
-            };
-        }
-        case 'status': {
-            if (event.status === 'ERROR') {
-                const details = JSON.stringify(event);
-                const isCloud = config?.runtime === 'cloud';
-                const prefix = isCloud ? 'Cloud run failed' : 'Local run failed';
-                return {
-                    type: 'text',
-                    content: `**Cursor error:** ${prefix}. Event details: \`${details}\``,
-                };
-            }
-            const statusLine = formatCloudStatus(event.status, event.message, config);
-            return statusLine ? { type: 'status', statusLine } : undefined;
-        }
-        case 'task': {
-            if (!event.text?.trim())
-                return undefined;
-            return { type: 'status', statusLine: truncate(event.text) };
-        }
-        default:
-            return undefined;
-    }
-};
-export const formatCursorError = (error) => {
-    if (error instanceof CursorSdkError) {
-        const parts = [error.message];
-        if (error.requestId)
-            parts.push(`(requestId: ${error.requestId})`);
-        const helpUrl = error.helpUrl;
-        if (helpUrl)
-            parts.push(`See ${helpUrl}`);
-        return parts.join(' ');
-    }
-    if (error instanceof Error) {
-        const extra = { ...error };
-        if (Object.keys(extra).length > 0) {
-            return `${error.message} (details: ${JSON.stringify(extra)})`;
-        }
-        return error.message;
-    }
-    try {
-        return typeof error === 'object' && error !== null
-            ? JSON.stringify(error)
-            : String(error);
-    }
-    catch {
-        return String(error);
-    }
-};