@meetopenbot/cursor 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,7 +1,7 @@
 import { agentOutput, definePlugin, shouldHandleInvoke, } from '@meetopenbot/plugin-sdk';
 import { CURSOR_API_KEY_ENV_VAR, resolveConfig, } from './config.js';
 import { formatCursorError } from './format.js';
-import { getOrCreateCursorAgent } from './session.js';
+import { getOrCreateCursorAgent, StaleAgentSessionError } from './session.js';
 import { streamCursorPrompt } from './stream.js';
 export default definePlugin({
     id: 'cursor',
@@ -107,17 +107,40 @@ export default definePlugin({
                 return;
             }
             try {
-                const { agent } = await getOrCreateCursorAgent({
+                let agentHandle = await getOrCreateCursorAgent({
                     config,
                     state: handlerCtx.state,
                     storage: context.storage,
                 });
-                for await (const chunk of streamCursorPrompt(agent, prompt, config)) {
-                    yield agentOutput({
-                        agentId: context.agentId,
-                        content: chunk,
-                        threadId,
-                    });
+                try {
+                    for await (const chunk of streamCursorPrompt(agentHandle.agent, prompt, config, agentHandle.wasResumed)) {
+                        yield agentOutput({
+                            agentId: context.agentId,
+                            content: chunk,
+                            threadId,
+                        });
+                    }
+                }
+                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,
+                        });
+                        for await (const chunk of streamCursorPrompt(agentHandle.agent, prompt, config, agentHandle.wasResumed)) {
+                            yield agentOutput({
+                                agentId: context.agentId,
+                                content: chunk,
+                                threadId,
+                            });
+                        }
+                    }
+                    else {
+                        throw streamErr;
+                    }
                 }
             }
             catch (error) {

package/dist/session.js

@@ -2,6 +2,12 @@ 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) {
+        super(message);
+        this.name = 'StaleAgentSessionError';
+    }
+}
 const sessionCache = new Map();
 const buildSessionKey = (state) => state.threadId ? `${state.channelId}:${state.threadId}` : state.channelId;
 const buildAgentOptions = (config) => {
@@ -44,16 +50,33 @@ const resumeOptions = (config) => ({
 const createAgent = async (config) => Agent.create(buildAgentOptions(config));
 const resumeAgent = async (cursorAgentId, config) => Agent.resume(cursorAgentId, resumeOptions(config));
 export const getOrCreateCursorAgent = async (args) => {
-    const { config, state, storage } = args;
+    const { config, state, storage, forceNew } = args;
     const sessionKey = buildSessionKey(state);
-    const cached = sessionCache.get(sessionKey);
-    if (cached)
-        return cached;
-    const persisted = readPersistedState(state);
+    if (forceNew) {
+        const cached = sessionCache.get(sessionKey);
+        if (cached) {
+            try {
+                await cached.agent[Symbol.asyncDispose]();
+            }
+            catch (e) {
+                console.warn(`[cursor-plugin] Failed to dispose cached agent:`, e);
+            }
+            sessionCache.delete(sessionKey);
+        }
+        await persistCursorState(state, storage, { cursorAgentId: undefined });
+    }
+    else {
+        const cached = sessionCache.get(sessionKey);
+        if (cached)
+            return cached;
+    }
+    const persisted = forceNew ? {} : readPersistedState(state);
     let agent;
+    let wasResumed = false;
     if (persisted.cursorAgentId) {
         try {
             agent = await resumeAgent(persisted.cursorAgentId, config);
+            wasResumed = true;
         }
         catch (error) {
             console.warn(`[cursor-plugin] Failed to resume ${persisted.cursorAgentId}: ${formatCursorError(error)}`);
@@ -61,11 +84,12 @@ export const getOrCreateCursorAgent = async (args) => {
     }
     if (!agent) {
         agent = await createAgent(config);
+        wasResumed = false;
         if (agent.agentId !== persisted.cursorAgentId) {
             await persistCursorState(state, storage, { cursorAgentId: agent.agentId });
         }
     }
-    const handle = { agent, sessionKey };
+    const handle = { agent, sessionKey, wasResumed };
     sessionCache.set(sessionKey, handle);
     return handle;
 };

package/dist/state.js

@@ -2,7 +2,7 @@ const asRecord = (value) => value && typeof value === 'object' && !Array.isArray
     ? value
     : {};
 export const readPersistedState = (state) => {
-    const source = state.threadDetails?.state ?? state.channelDetails?.state;
+    const source = state.threadId ? state.threadDetails?.state : state.channelDetails?.state;
     const record = asRecord(source);
     return typeof record.cursorAgentId === 'string'
         ? { cursorAgentId: record.cursorAgentId }

package/dist/stream.js

@@ -1,7 +1,8 @@
 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 output chunks. */
-export async function* streamCursorPrompt(agent, prompt, config) {
+export async function* streamCursorPrompt(agent, prompt, config, wasResumed) {
     const state = createStreamState();
     const pending = [];
     let wake;
@@ -30,6 +31,9 @@ export async function* streamCursorPrompt(agent, prompt, config) {
                 pending.push(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(`**Cursor error:** Run finished with error status. Details: \`${details}\``);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/cursor",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "OpenBot agent plugin powered by the Cursor SDK.",
   "type": "module",
   "main": "dist/index.js",