opencode-ext-connector 0.3.0

package/dist/providers/cursor/request-blob-ownership.js

@@ -0,0 +1,39 @@
+export class CursorRequestBlobOwnershipError extends Error {
+    constructor() {
+        super("Cursor request blob ownership could not acquire content");
+        this.name = "CursorRequestBlobOwnershipError";
+    }
+}
+export function createCursorRequestBlobCollector(store) {
+    const blobIds = [];
+    let state = "collecting";
+    const release = () => {
+        if (state === "released")
+            return;
+        state = "released";
+        for (const blobId of blobIds)
+            store.release(blobId);
+    };
+    return {
+        acquire: (blobId) => {
+            if (state !== "collecting")
+                throw new CursorRequestBlobOwnershipError();
+            if (blobIds.includes(blobId))
+                return;
+            if (!store.pin(blobId))
+                throw new CursorRequestBlobOwnershipError();
+            blobIds.push(blobId);
+        },
+        finish: () => {
+            if (state !== "collecting")
+                throw new CursorRequestBlobOwnershipError();
+            state = "owned";
+            return Object.freeze({
+                blobIds: Object.freeze([...blobIds]),
+                release,
+                [Symbol.dispose]: release,
+            });
+        },
+        rollback: release,
+    };
+}

package/dist/providers/cursor/request-build.d.ts

@@ -0,0 +1,18 @@
+import type { CursorBlobId, CursorBlobStore } from "./blob-store";
+import type { CursorCheckpointStore } from "./checkpoint-store";
+import { type CursorRequestBlobOwnership } from "./request-blob-ownership";
+export type CursorAgentRunBuildDependencies = {
+    readonly blobStore: CursorBlobStore;
+    readonly checkpointStore: CursorCheckpointStore;
+    readonly createId: () => string;
+    readonly input: unknown;
+};
+export type CursorAgentRunBuildResult = {
+    readonly kind: "fresh" | "checkpoint";
+    readonly bytes: Uint8Array;
+    readonly blobIds: readonly CursorBlobId[];
+    readonly conversationId: string;
+    readonly ownership: CursorRequestBlobOwnership;
+};
+export declare function normalizeCursorRootPrompt(prompt: string): Uint8Array;
+export declare function buildCursorAgentRunRequest(dependencies: CursorAgentRunBuildDependencies): CursorAgentRunBuildResult;

package/dist/providers/cursor/request-build.js

@@ -0,0 +1,123 @@
+// Derived from Rahularya01/pi-cursor v1.4.26 request-build.ts. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { InvalidArgumentError } from "../../core/errors";
+import { decodeConversationCheckpoint } from "./proto/checkpoint";
+import { encodeAgentClientMessage } from "./proto/request";
+import { createCursorRequestBlobCollector, } from "./request-blob-ownership";
+import { buildCursorSelectedContextBlob, buildCursorUserMessage, normalizeCursorRootPromptBytes, storeCursorHistory, storeCursorRequestBlob, } from "./request-history";
+import { parseCursorRunBuildInput } from "./request-input";
+function emptyCheckpoint(rootPromptBlobIds, turnBlobIds) {
+    return {
+        rootPromptMessageBlobIds: rootPromptBlobIds,
+        legacyTurnBlobIds: [],
+        todoBlobIds: [],
+        pendingToolCalls: [],
+        turnBlobIds,
+        previousWorkspaceUris: [],
+        mode: 1,
+        fileStates: [],
+        summaryArchiveBlobIds: [],
+        turnTimingMessages: [],
+        fileStatesV2: [],
+        subagentStates: [],
+        selfSummaryCount: 0,
+        readPaths: [],
+        trackedGitRepoBranches: [],
+        clientName: "opencode",
+    };
+}
+function buildAction(input, context) {
+    switch (input.action.kind) {
+        case "user":
+            return {
+                kind: "user-message",
+                userMessage: buildCursorUserMessage(input.action, context),
+            };
+        case "resume":
+            return { kind: "resume", payload: new Uint8Array() };
+        case "cancel":
+            return { kind: "cancel", payload: new Uint8Array() };
+    }
+}
+function checkpointState(input, checkpointStore, store, ownership) {
+    const checkpoint = checkpointStore.resume(input.sessionId);
+    if (checkpoint === null)
+        throw new InvalidArgumentError("checkpoint");
+    for (const blobId of checkpoint.blobIds)
+        ownership.acquire(blobId);
+    const state = decodeConversationCheckpoint(checkpoint.bytes);
+    const systemBytes = new TextEncoder().encode(JSON.stringify({
+        role: "system",
+        content: input.rootSystemPrompt.replace(/\r\n?/g, "\n").trim(),
+    }));
+    const systemBlobId = storeCursorRequestBlob(store, ownership, systemBytes);
+    const selectedContextBlob = storeCursorRequestBlob(store, ownership, buildCursorSelectedContextBlob(systemBlobId));
+    if (input.refreshRootPrompt !== true)
+        return { state, selectedContextBlob };
+    return {
+        state: {
+            ...state,
+            rootPromptMessageBlobIds: [
+                ...state.rootPromptMessageBlobIds,
+                storeCursorRequestBlob(store, ownership, normalizeCursorRootPromptBytes(input.rootSystemPrompt)),
+            ],
+        },
+        selectedContextBlob,
+    };
+}
+export function normalizeCursorRootPrompt(prompt) {
+    return normalizeCursorRootPromptBytes(prompt);
+}
+export function buildCursorAgentRunRequest(dependencies) {
+    const input = parseCursorRunBuildInput(dependencies.input);
+    const ownership = createCursorRequestBlobCollector(dependencies.blobStore);
+    const ids = { create: dependencies.createId };
+    try {
+        const prepared = input.mode === "fresh"
+            ? (() => {
+                const history = storeCursorHistory({
+                    turns: input.history,
+                    systemPrompt: input.rootSystemPrompt.replace(/\r\n?/g, "\n").trim(),
+                    store: dependencies.blobStore,
+                    ownership,
+                    ids,
+                });
+                return {
+                    state: emptyCheckpoint(history.rootPromptBlobIds, history.turnBlobIds),
+                    selectedContextBlob: history.selectedContextBlob,
+                };
+            })()
+            : checkpointState(input, dependencies.checkpointStore, dependencies.blobStore, ownership);
+        const bytes = encodeAgentClientMessage({
+            kind: "run-request",
+            request: {
+                conversationState: prepared.state,
+                action: buildAction(input, {
+                    selectedContextBlob: prepared.selectedContextBlob,
+                    store: dependencies.blobStore,
+                    ownership,
+                    ids,
+                }),
+                mcpTools: input.mcpTools,
+                conversationId: input.conversationId,
+                requestedModel: {
+                    modelId: input.modelId,
+                    maxMode: input.maxMode ?? false,
+                    parameters: input.modelParameters,
+                },
+            },
+        });
+        const owned = ownership.finish();
+        return Object.freeze({
+            kind: input.mode,
+            bytes: new Uint8Array(bytes),
+            blobIds: owned.blobIds,
+            conversationId: input.conversationId,
+            ownership: owned,
+        });
+    }
+    catch (error) {
+        ownership.rollback();
+        throw error;
+    }
+}

package/dist/providers/cursor/request-history.d.ts

@@ -0,0 +1,32 @@
+import type { CursorBlobStore } from "./blob-store";
+import type { UserMessage } from "./proto/context";
+import type { CursorRequestBlobCollector } from "./request-blob-ownership";
+import type { CursorRunMessage, CursorRunTurn } from "./request-input";
+export type CursorRequestIds = {
+    readonly create: () => string;
+};
+export type CursorStoredHistory = {
+    readonly rootPromptBlobIds: readonly Uint8Array[];
+    readonly turnBlobIds: readonly Uint8Array[];
+};
+export declare function storeCursorRequestBlob(store: CursorBlobStore, ownership: CursorRequestBlobCollector, bytes: Uint8Array): Uint8Array;
+export declare class CursorRequestBlobError extends Error {
+    constructor();
+}
+export declare function normalizeCursorRootPromptBytes(prompt: string): Uint8Array;
+export declare function buildCursorSelectedContextBlob(systemBlobId: Uint8Array): Uint8Array;
+export declare function buildCursorUserMessage(message: CursorRunMessage, context: {
+    readonly selectedContextBlob: Uint8Array;
+    readonly store: CursorBlobStore;
+    readonly ownership: CursorRequestBlobCollector;
+    readonly ids: CursorRequestIds;
+}): UserMessage;
+export declare function storeCursorHistory(input: {
+    readonly turns: readonly CursorRunTurn[];
+    readonly systemPrompt: string;
+    readonly store: CursorBlobStore;
+    readonly ownership: CursorRequestBlobCollector;
+    readonly ids: CursorRequestIds;
+}): CursorStoredHistory & {
+    readonly selectedContextBlob: Uint8Array;
+};

package/dist/providers/cursor/request-history.js

@@ -0,0 +1,163 @@
+// Derived from Rahularya01/pi-cursor v1.4.26 request-build.ts. Licensed under MIT.
+// See THIRD_PARTY_NOTICES.md.
+import { encodeMcpArgs, encodeMcpResult } from "./proto/mcp";
+import { concatBytes, encodeBytesField, encodeStringField } from "./proto-wire";
+function wireId(blobId) {
+    return new Uint8Array(Buffer.from(blobId, "hex"));
+}
+export function storeCursorRequestBlob(store, ownership, bytes) {
+    const blobId = store.put(bytes);
+    if (blobId === null)
+        throw new CursorRequestBlobError();
+    ownership.acquire(blobId);
+    return wireId(blobId);
+}
+export class CursorRequestBlobError extends Error {
+    constructor() {
+        super("Cursor request blob store rejected content");
+        this.name = "CursorRequestBlobError";
+    }
+}
+export function normalizeCursorRootPromptBytes(prompt) {
+    const normalized = prompt.replace(/\r\n?/g, "\n").trim();
+    const message = {
+        role: "user",
+        content: [{ type: "text", text: `<rules>\n${normalized}\n</rules>` }],
+    };
+    return new TextEncoder().encode(JSON.stringify(message));
+}
+export function buildCursorSelectedContextBlob(systemBlobId) {
+    return concatBytes([encodeBytesField(1, systemBlobId), encodeStringField(22, "opencode")]);
+}
+export function buildCursorUserMessage(message, context) {
+    const messageId = context.ids.create();
+    return {
+        text: message.text,
+        messageId,
+        selectedContext: {
+            selectedImages: message.images.map((image) => ({
+                uuid: context.ids.create(),
+                path: "",
+                mimeType: image.mimeType,
+                data: {
+                    kind: "blob-id",
+                    bytes: storeCursorRequestBlob(context.store, context.ownership, image.data),
+                },
+            })),
+            extraContext: [...(message.selectedContext ?? [])],
+        },
+        mode: 1,
+        selectedContextBlob: context.selectedContextBlob,
+        correlationId: messageId,
+    };
+}
+function encodeStep(step) {
+    switch (step.kind) {
+        case "assistant":
+            return encodeBytesField(1, encodeStringField(1, step.text));
+        case "thinking":
+            return encodeBytesField(3, encodeStringField(1, step.text));
+        case "tool": {
+            const args = encodeBytesField(1, encodeMcpArgs({
+                name: step.toolName,
+                args: step.arguments,
+                toolCallId: step.toolCallId,
+                providerIdentifier: "opencode",
+                toolName: step.toolName,
+            }));
+            const result = step.result === undefined
+                ? []
+                : [
+                    encodeBytesField(2, encodeMcpResult(step.result.kind === "success" ? { ...step.result, isError: false } : step.result)),
+                ];
+            return encodeBytesField(2, encodeBytesField(15, concatBytes([args, ...result])));
+        }
+    }
+}
+function rootMessages(turn) {
+    const messages = [{ role: "user", content: [{ type: "text", text: turn.user.text }] }];
+    for (const step of turn.steps) {
+        switch (step.kind) {
+            case "assistant":
+                messages.push({ role: "assistant", content: [{ type: "text", text: step.text }] });
+                break;
+            case "thinking":
+                break;
+            case "tool":
+                messages.push({
+                    role: "assistant",
+                    content: [
+                        {
+                            type: "tool-call",
+                            toolCallId: step.toolCallId,
+                            toolName: `mcp_opencode_${step.toolName}`,
+                            args: step.arguments,
+                        },
+                    ],
+                });
+                if (step.result !== undefined)
+                    messages.push({
+                        role: "tool",
+                        content: [
+                            {
+                                type: "tool-result",
+                                toolCallId: step.toolCallId,
+                                toolName: `mcp_opencode_${step.toolName}`,
+                                result: step.result,
+                            },
+                        ],
+                    });
+                break;
+        }
+    }
+    return messages;
+}
+export function storeCursorHistory(input) {
+    const systemBytes = new TextEncoder().encode(JSON.stringify({ role: "system", content: input.systemPrompt }));
+    const systemBlobId = storeCursorRequestBlob(input.store, input.ownership, systemBytes);
+    const selectedContextBlob = storeCursorRequestBlob(input.store, input.ownership, buildCursorSelectedContextBlob(systemBlobId));
+    const rootPromptBlobIds = [
+        systemBlobId,
+        storeCursorRequestBlob(input.store, input.ownership, normalizeCursorRootPromptBytes(input.systemPrompt)),
+    ];
+    const turnBlobIds = input.turns.map((turn) => {
+        const userMessage = buildCursorUserMessage(turn.user, {
+            selectedContextBlob,
+            store: input.store,
+            ownership: input.ownership,
+            ids: input.ids,
+        });
+        const userBlob = storeCursorRequestBlob(input.store, input.ownership, encodeCursorUserMessage(userMessage));
+        const steps = turn.steps.map((step) => storeCursorRequestBlob(input.store, input.ownership, encodeStep(step)));
+        for (const message of rootMessages(turn))
+            rootPromptBlobIds.push(storeCursorRequestBlob(input.store, input.ownership, new TextEncoder().encode(JSON.stringify(message))));
+        return storeCursorRequestBlob(input.store, input.ownership, encodeBytesField(1, concatBytes([
+            encodeBytesField(1, userBlob),
+            ...steps.map((value) => encodeBytesField(2, value)),
+            encodeStringField(3, input.ids.create()),
+        ])));
+    });
+    return { rootPromptBlobIds, turnBlobIds, selectedContextBlob };
+}
+function encodeCursorUserMessage(message) {
+    const selected = message.selectedContext;
+    return concatBytes([
+        encodeStringField(1, message.text),
+        encodeStringField(2, message.messageId),
+        ...(selected === undefined
+            ? []
+            : [
+                encodeBytesField(3, concatBytes([
+                    ...selected.selectedImages.map((image) => encodeBytesField(1, concatBytes([
+                        encodeBytesField(1, image.data.kind === "blob-id" ? image.data.bytes : new Uint8Array()),
+                        encodeStringField(2, image.uuid),
+                        encodeStringField(7, image.mimeType),
+                    ]))),
+                    ...selected.extraContext.map((value) => encodeStringField(3, value)),
+                ])),
+            ]),
+        new Uint8Array([0x20, 0x01]),
+        encodeBytesField(10, message.selectedContextBlob),
+        encodeStringField(17, message.correlationId),
+    ]);
+}

package/dist/providers/cursor/request-input.d.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { type ModelId } from "../../core/ids";
+import type { McpToolDefinition } from "./proto/mcp";
+import type { RequestedModelParameter } from "./proto/model";
+import { type CursorSessionId } from "./session-state";
+type CursorJson = string | number | boolean | null | readonly CursorJson[] | {
+    readonly [key: string]: CursorJson;
+};
+export type CursorRunImage = {
+    readonly data: Uint8Array;
+    readonly mimeType: string;
+};
+export type CursorRunMessage = {
+    readonly text: string;
+    readonly images: readonly CursorRunImage[];
+    readonly selectedContext?: readonly string[] | undefined;
+};
+export type CursorRunResultContent = {
+    readonly kind: "text";
+    readonly text: string;
+} | (CursorRunImage & {
+    readonly kind: "image";
+});
+export type CursorRunToolResult = {
+    readonly kind: "success";
+    readonly content: readonly CursorRunResultContent[];
+} | {
+    readonly kind: "error";
+    readonly error: string;
+};
+export type CursorRunStep = {
+    readonly kind: "assistant";
+    readonly text: string;
+} | {
+    readonly kind: "thinking";
+    readonly text: string;
+} | {
+    readonly kind: "tool";
+    readonly arguments: Readonly<Record<string, CursorJson>>;
+    readonly result?: CursorRunToolResult | undefined;
+    readonly toolCallId: string;
+    readonly toolName: string;
+};
+export type CursorRunTurn = {
+    readonly user: CursorRunMessage;
+    readonly steps: readonly CursorRunStep[];
+};
+type CursorRunBase = {
+    readonly conversationId: CursorSessionId;
+    readonly history: readonly CursorRunTurn[];
+    readonly maxMode?: boolean | undefined;
+    readonly mcpTools: readonly McpToolDefinition[];
+    readonly modelId: ModelId;
+    readonly modelParameters: readonly RequestedModelParameter[];
+    readonly refreshRootPrompt?: boolean | undefined;
+    readonly rootSystemPrompt: string;
+};
+type CursorUserAction = CursorRunMessage & {
+    readonly kind: "user";
+};
+export type CursorRunBuildInput = (CursorRunBase & {
+    readonly mode: "fresh";
+    readonly action: CursorUserAction;
+}) | (CursorRunBase & {
+    readonly mode: "checkpoint";
+    readonly sessionId: CursorSessionId;
+    readonly action: CursorUserAction | {
+        readonly kind: "resume";
+    } | {
+        readonly kind: "cancel";
+    };
+});
+export declare const CursorRunBuildInputSchema: z.ZodType<CursorRunBuildInput>;
+export declare function parseCursorRunBuildInput(input: unknown): CursorRunBuildInput;
+export {};

package/dist/providers/cursor/request-input.js

@@ -0,0 +1,123 @@
+import { z } from "zod";
+import { ModelIdSchema } from "../../core/ids";
+import { CursorSessionIdSchema } from "./session-state";
+const BytesSchema = z.instanceof(Uint8Array);
+const ImageSchema = z
+    .object({ data: BytesSchema, mimeType: z.string().min(1).max(256) })
+    .strict()
+    .readonly();
+const SelectedContextSchema = z
+    .array(z.string().min(1))
+    .max(128)
+    .readonly();
+const MessageSchema = z
+    .object({
+    text: z.string(),
+    images: z.array(ImageSchema).max(32).readonly(),
+    selectedContext: SelectedContextSchema.optional(),
+})
+    .strict()
+    .readonly();
+const ResultContentSchema = z.discriminatedUnion("kind", [
+    z
+        .object({ kind: z.literal("text"), text: z.string() })
+        .strict()
+        .readonly(),
+    z
+        .object({ kind: z.literal("image"), data: BytesSchema, mimeType: z.string().min(1) })
+        .strict()
+        .readonly(),
+]);
+const ToolResultSchema = z.discriminatedUnion("kind", [
+    z
+        .object({ kind: z.literal("success"), content: z.array(ResultContentSchema).readonly() })
+        .strict()
+        .readonly(),
+    z
+        .object({ kind: z.literal("error"), error: z.string() })
+        .strict()
+        .readonly(),
+]);
+const StepSchema = z.discriminatedUnion("kind", [
+    z
+        .object({ kind: z.literal("assistant"), text: z.string() })
+        .strict()
+        .readonly(),
+    z
+        .object({ kind: z.literal("thinking"), text: z.string() })
+        .strict()
+        .readonly(),
+    z
+        .object({
+        kind: z.literal("tool"),
+        arguments: z.record(z.string(), z.json()),
+        result: ToolResultSchema.optional(),
+        toolCallId: z.string().min(1),
+        toolName: z.string().min(1),
+    })
+        .strict()
+        .readonly(),
+]);
+const TurnSchema = z
+    .object({ user: MessageSchema, steps: z.array(StepSchema).readonly() })
+    .strict()
+    .readonly();
+const McpToolSchema = z
+    .object({
+    name: z.string().min(1),
+    description: z.string(),
+    inputSchema: z.json(),
+    providerIdentifier: z.string().min(1),
+    toolName: z.string().min(1),
+})
+    .strict()
+    .readonly();
+const UserActionSchema = z
+    .object({
+    kind: z.literal("user"),
+    text: z.string(),
+    images: z.array(ImageSchema).max(32).readonly(),
+    selectedContext: SelectedContextSchema.optional(),
+})
+    .strict()
+    .readonly();
+const BaseShape = {
+    conversationId: CursorSessionIdSchema,
+    history: z.array(TurnSchema).readonly(),
+    maxMode: z.boolean().optional(),
+    mcpTools: z.array(McpToolSchema).readonly(),
+    modelId: ModelIdSchema,
+    modelParameters: z
+        .array(z.object({ id: z.string(), value: z.string() }).strict().readonly())
+        .readonly(),
+    refreshRootPrompt: z.boolean().optional(),
+    rootSystemPrompt: z.string(),
+};
+export const CursorRunBuildInputSchema = z.discriminatedUnion("mode", [
+    z
+        .object({ ...BaseShape, mode: z.literal("fresh"), action: UserActionSchema })
+        .strict()
+        .readonly(),
+    z
+        .object({
+        ...BaseShape,
+        mode: z.literal("checkpoint"),
+        sessionId: CursorSessionIdSchema,
+        action: z.union([
+            UserActionSchema,
+            z
+                .object({ kind: z.literal("resume") })
+                .strict()
+                .readonly(),
+            z
+                .object({ kind: z.literal("cancel") })
+                .strict()
+                .readonly(),
+        ]),
+    })
+        .strict()
+        .readonly(),
+]);
+export function parseCursorRunBuildInput(input) {
+    return CursorRunBuildInputSchema.parse(input);
+}

package/dist/providers/cursor/run-events.d.ts

@@ -0,0 +1,15 @@
+export type CursorRunEvent = {
+    readonly kind: "text";
+    readonly text: string;
+} | {
+    readonly kind: "thinking";
+    readonly text: string;
+} | {
+    readonly kind: "turn-ended";
+} | {
+    readonly kind: "tool";
+    readonly callId: string;
+    readonly name: string;
+    readonly args: unknown;
+};
+export declare function extractCursorRunEvents(bytes: Uint8Array): readonly CursorRunEvent[];

package/dist/providers/cursor/run-events.js

@@ -0,0 +1,43 @@
+// Derived from Rahularya01/pi-cursor AgentServerMessage interaction updates.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { decodeAgentServerMessage } from "./proto/server";
+function eventFromUpdate(update) {
+    switch (update.kind) {
+        case "text-delta":
+            return update.text === "" ? null : { kind: "text", text: update.text };
+        case "thinking-delta":
+            return update.text === "" ? null : { kind: "thinking", text: update.text };
+        case "turn-ended":
+            return { kind: "turn-ended" };
+        case "tool-call-started": {
+            const name = update.args.toolName || update.args.name;
+            return update.callId === "" || name === ""
+                ? null
+                : { kind: "tool", callId: update.callId, name, args: update.args.args };
+        }
+        case "tool-call-completed":
+        case "thinking-completed":
+        case "user-message-appended":
+        case "partial-tool-call":
+        case "token-delta":
+        case "summary":
+        case "summary-started":
+        case "summary-completed":
+        case "shell-output-delta":
+        case "heartbeat":
+        case "tool-call-delta":
+        case "step-started":
+        case "step-completed":
+        case "field-25":
+            return null;
+        default:
+            return update;
+    }
+}
+export function extractCursorRunEvents(bytes) {
+    const message = decodeAgentServerMessage(bytes);
+    if (message.kind !== "interaction-update")
+        return [];
+    const event = eventFromUpdate(message.update);
+    return event === null ? [] : [event];
+}

package/dist/providers/cursor/run-session-expiry.d.ts

@@ -0,0 +1,15 @@
+import type { CursorRunSessionIdentity } from "./run-session";
+export type CursorRunSessionBackgroundCleanupErrorHandler = (error: CursorRunSessionTtlCleanupError) => void | Promise<void>;
+export declare class CursorRunSessionTtlCleanupError extends Error {
+    readonly identity: CursorRunSessionIdentity;
+    readonly cause: AggregateError;
+    readonly name = "CursorRunSessionTtlCleanupError";
+    readonly code = "CURSOR_RUN_SESSION_TTL_CLEANUP_ERROR";
+    readonly operation = "ttl-expiration";
+    constructor(identity: CursorRunSessionIdentity, cause: AggregateError);
+}
+export declare function settleCursorRunSessionExpiry(options: {
+    readonly identity: CursorRunSessionIdentity;
+    readonly terminate: (identity: CursorRunSessionIdentity) => Promise<void>;
+    readonly onBackgroundCleanupError: CursorRunSessionBackgroundCleanupErrorHandler;
+}): void;

package/dist/providers/cursor/run-session-expiry.js

@@ -0,0 +1,21 @@
+export class CursorRunSessionTtlCleanupError extends Error {
+    identity;
+    cause;
+    name = "CursorRunSessionTtlCleanupError";
+    code = "CURSOR_RUN_SESSION_TTL_CLEANUP_ERROR";
+    operation = "ttl-expiration";
+    constructor(identity, cause) {
+        super("Cursor Run session TTL cleanup failed", { cause });
+        this.identity = identity;
+        this.cause = cause;
+    }
+}
+export function settleCursorRunSessionExpiry(options) {
+    const reported = options.terminate(options.identity).catch((cause) => {
+        const aggregateCause = cause instanceof AggregateError
+            ? cause
+            : new AggregateError([cause], "Cursor Run session TTL cleanup failed");
+        return options.onBackgroundCleanupError(new CursorRunSessionTtlCleanupError(options.identity, aggregateCause));
+    });
+    void Promise.allSettled([reported]);
+}