@caeliq/llms 1.0.55 → 1.0.57

package/dist/cursor-sdk/events-to-sse.d.ts

@@ -0,0 +1,113 @@
+export type SseEmitter = {
+    enqueueChunk: (chunk: Record<string, unknown>) => void;
+    enqueueDone: () => void;
+};
+export declare function createSseHelpers(model: string, encoder: TextEncoder): {
+    setId(next: string): void;
+    content(text: string): {
+        choices: {
+            index: number;
+            delta: {
+                role: string;
+                content: string;
+            };
+            finish_reason: null;
+        }[];
+        id: string;
+        object: string;
+        created: number;
+        model: string;
+    };
+    thinking(text: string): {
+        choices: {
+            index: number;
+            delta: {
+                thinking: {
+                    content: string;
+                };
+            };
+            finish_reason: null;
+        }[];
+        id: string;
+        object: string;
+        created: number;
+        model: string;
+    };
+    /**
+     * Claude Code / Anthropic expecting extended-thinking streams require a
+     * signature_delta before the thinking block is closed. Cursor SDK has no
+     * provider signature, so emit a synthetic one (same pattern as reasoning /
+     * forcereasoning transformers). Without this, thinking_deltas are on the
+     * wire but the UI often never surfaces them.
+     */
+    thinkingSignature(signature?: string): {
+        choices: {
+            index: number;
+            delta: {
+                thinking: {
+                    signature: string;
+                };
+            };
+            finish_reason: null;
+        }[];
+        id: string;
+        object: string;
+        created: number;
+        model: string;
+    };
+    toolCall(tool: {
+        id: string;
+        name: string;
+        args: Record<string, unknown>;
+    }, index?: number): {
+        choices: {
+            index: number;
+            delta: {
+                role: string;
+                tool_calls: {
+                    index: number;
+                    id: string;
+                    type: string;
+                    function: {
+                        name: string;
+                        arguments: string;
+                    };
+                }[];
+            };
+            finish_reason: null;
+        }[];
+        id: string;
+        object: string;
+        created: number;
+        model: string;
+    };
+    finish(reason: "stop" | "tool_calls", usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+        prompt_tokens_details?: {
+            cached_tokens?: number;
+        };
+    }): {
+        choices: {
+            index: number;
+            delta: {};
+            finish_reason: "stop" | "tool_calls";
+        }[];
+        usage: {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+            prompt_tokens_details: {
+                cached_tokens: number;
+            };
+        };
+        id: string;
+        object: string;
+        created: number;
+        model: string;
+    };
+    encode(chunk: Record<string, unknown>): Uint8Array<ArrayBufferLike>;
+    encodeDone(): Uint8Array<ArrayBufferLike>;
+};
+export declare function accumulateChatCompletion(model: string, chunks: Array<Record<string, unknown>>): Record<string, unknown>;

package/dist/cursor-sdk/hooks-template.d.ts

@@ -0,0 +1 @@
+export declare function ensureDenyHooksWorkspace(workspaceDir: string): void;

package/dist/cursor-sdk/prompt.d.ts

@@ -0,0 +1,29 @@
+import type { UnifiedChatRequest } from "../types/llm";
+import type { SDKUserMessage } from "@cursor/sdk";
+export declare function buildBridgeSystemGuidance(request: UnifiedChatRequest, workspaceDir: string): string;
+/**
+ * Detect a short terminal message that only announces work which never occurred.
+ * Keep this deliberately narrow: it is a recovery signal, not a general quality score.
+ */
+export declare function isProgressOnlyAssistantText(text: string): boolean;
+export declare function shouldContinueProgressOnlyTurn(input: {
+    mode: "bridge" | "plan" | "agent";
+    assistantText: string;
+    emittedHostTools: number;
+    continuationAttempts: number;
+}): boolean;
+export declare function progressOnlyContinuationPrompt(): SDKUserMessage;
+/**
+ * Flatten Unified chat history into a single SDK prompt for a fresh/continued send.
+ * Live parked tool results are resolved via customTools.execute — not only this text.
+ */
+export declare function toSdkPrompt(request: UnifiedChatRequest, options: {
+    mode: "bridge" | "plan" | "agent";
+    workspaceDir: string;
+    /** When true, only the latest user turn (+ guidance) is sent — session already has history. */
+    followUpOnly?: boolean;
+}): SDKUserMessage;
+export declare function extractTrailingToolResults(request: UnifiedChatRequest): Array<{
+    toolCallId: string;
+    content: string;
+}>;

package/dist/cursor-sdk/runner.d.ts

@@ -0,0 +1,11 @@
+import type { UnifiedChatRequest } from "../types/llm";
+import { type CursorSdkMode } from "./shared";
+export interface CursorSdkRunnerOptions {
+    cursorMode?: CursorSdkMode;
+    cursorCwd?: string;
+    /** Opt-in only; ignored/forced off in Docker. Default false. */
+    sandboxEnabled?: boolean;
+    abortSignal?: AbortSignal;
+    logger?: any;
+}
+export declare function runCursor(request: UnifiedChatRequest, provider: any, context: any, options?: CursorSdkRunnerOptions): Promise<Response>;

package/dist/cursor-sdk/send.d.ts

@@ -0,0 +1,9 @@
+import type { SDKUserMessage } from "@cursor/sdk";
+import { type CursorSdkSession } from "./session";
+export declare const CURSOR_SEND_TIMEOUT_MESSAGE = "Cursor SDK agent.send timed out";
+export declare function isCursorAgentBusyError(err: unknown): boolean;
+export declare function isCursorSendPoisonError(err: unknown): boolean;
+export declare function sendCursorPrompt(session: CursorSdkSession, prompt: SDKUserMessage, sendOptions: Record<string, any>, options?: {
+    abortSignal?: AbortSignal;
+    logger?: any;
+}): Promise<import("@cursor/sdk").Run>;

package/dist/cursor-sdk/session.d.ts

@@ -0,0 +1,146 @@
+import { type ModelSelection, type Run, type SDKAgent, type SDKMessage } from "@cursor/sdk";
+import type { OpenAiUsage } from "./usage";
+import { type CursorSdkMode } from "./shared";
+export type ParkedTool = {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+    runToken?: symbol;
+    resolve: (result: string) => void;
+    reject: (err: Error) => void;
+    promise: Promise<string>;
+};
+export type CursorSdkSession = {
+    key: string;
+    agent: SDKAgent;
+    agentId: string;
+    mode: CursorSdkMode;
+    workspaceDir: string;
+    run?: Run;
+    streamIterator?: AsyncIterator<any>;
+    activeRunToken?: symbol;
+    lastSdkUsageRaw?: OpenAiUsage;
+    parked: ParkedTool[];
+    /** Tool calls waiting to be emitted on the current SSE response. */
+    pendingEmit: Array<{
+        id: string;
+        name: string;
+        args: Record<string, unknown>;
+        runToken?: symbol;
+    }>;
+    emitWaiters: Array<() => void>;
+    /** SDK raw delta callbacks waiting to be merged into the current SSE response. */
+    pendingSdkMessages: Array<{
+        message: SDKMessage;
+        runToken?: symbol;
+        source: "delta";
+    }>;
+    sdkMessageWaiters: Array<() => void>;
+    /**
+     * Serializes cancel/send so a follow-up compact/retry cannot call
+     * `agent.send` while a prior run is still marked active in the SDK store.
+     */
+    sendChain: Promise<void>;
+    /** True after at least one successful `agent.send` on this session. */
+    hasSentPrompt: boolean;
+    /**
+     * Set when the local SDK handles are no longer trustworthy. The manager must
+     * not hand this agent out for a future request.
+     */
+    poisoned?: boolean;
+    poisonReason?: string;
+    lastActiveAt: number;
+    metrics: {
+        customToolCalls: number;
+        builtinToolCallsSeen: number;
+    };
+    parkHostTool: (tool: {
+        id: string;
+        name: string;
+        args: Record<string, unknown>;
+    }) => Promise<string>;
+    notifyEmit: () => void;
+    waitForEmit: () => Promise<void>;
+    enqueueSdkMessage: (message: SDKMessage, runToken?: symbol) => void;
+    notifySdkMessage: () => void;
+    waitForSdkMessage: () => Promise<void>;
+};
+export type CancelActiveRunResult = {
+    skipped: boolean;
+    hadRun: boolean;
+    hadIterator: boolean;
+    failed: boolean;
+    timedOut: boolean;
+};
+export declare function markSessionPoisoned(session: CursorSdkSession, reason: string): void;
+/**
+ * Drop local run handles and await SDK `run.cancel()` when needed.
+ *
+ * Cursor persists `activeRunId` in its local store and throws
+ * `Agent … already has active run` on the next `agent.send` until the prior
+ * run is terminal. Client disconnect / compact / retry often leave a live run.
+ */
+export declare function cancelActiveRun(session: CursorSdkSession, options?: {
+    rejectParked?: boolean;
+    reason?: string;
+    timeoutMs?: number;
+    onlyRunToken?: symbol;
+    poisonOnFailure?: boolean;
+}): Promise<CancelActiveRunResult>;
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T>;
+/** Run `fn` exclusively against this session's cancel/send critical section. */
+export declare function withSessionSendLock<T>(session: CursorSdkSession, fn: () => Promise<T>): Promise<T>;
+/**
+ * Cursor local sandbox requires a supported host (typically desktop with the
+ * sandbox helper). Docker/Alpine/CI do not support it and throw:
+ * "Local SDK sandboxing was requested, but sandboxing is not supported…".
+ *
+ * Model D relies on deny-hooks + customTools park, not sandbox. Default OFF;
+ * opt in with transformer `sandboxEnabled: true` or `CCR_CURSOR_SANDBOX=1`
+ * only on supported hosts.
+ */
+export declare function shouldEnableCursorSandbox(requested?: boolean): boolean;
+export declare function buildSessionKey(input: {
+    headerSession?: string;
+    metadataUserId?: string;
+    model?: string;
+    systemAndFirstUser?: string;
+}): string;
+/** True while a session has a live run, open stream, or unresolved host tools. */
+export declare function isSessionInFlight(session: CursorSdkSession): boolean;
+export declare function touchSession(session: CursorSdkSession): void;
+export declare class SessionManager {
+    private logger?;
+    private sessions;
+    private cleanupTimer?;
+    constructor(logger?: any | undefined);
+    setLogger(logger: any): void;
+    get(key: string): CursorSdkSession | undefined;
+    getOrCreate(options: {
+        key: string;
+        apiKey: string;
+        model: ModelSelection;
+        mode: CursorSdkMode;
+        cursorCwd?: string;
+        sandboxEnabled?: boolean;
+    }): Promise<CursorSdkSession>;
+    resume(options: {
+        key: string;
+        agentId: string;
+        apiKey: string;
+        model?: ModelSelection;
+        mode: CursorSdkMode;
+        workspaceDir: string;
+        sandboxEnabled?: boolean;
+    }): Promise<CursorSdkSession>;
+    resolveParkedTools(session: CursorSdkSession, results: Array<{
+        toolCallId: string;
+        content: string;
+    }>): number;
+    dispose(key: string): Promise<void>;
+    invalidate(sessionOrKey: CursorSdkSession | string, reason: string): void;
+    private createSessionRecord;
+    private evictIfNeeded;
+    private evictIdle;
+}
+export declare const globalSessionManager: SessionManager;

package/dist/cursor-sdk/shared.d.ts

@@ -0,0 +1,14 @@
+export declare const CURSOR_SDK_TRANSFORMER_NAME = "cursor-sdk";
+export type CursorSdkMode = "bridge" | "plan" | "agent";
+export declare const DEFAULT_CURSOR_MODE: CursorSdkMode;
+export declare const CCR_HOME: string;
+export declare const CURSOR_SDK_WORKSPACES_ROOT: string;
+export declare const SESSION_IDLE_TTL_MS: number;
+export declare const SESSION_LRU_MAX = 32;
+/** Cursor built-ins we try to deny so Claude Code remains the tool host. */
+export declare const CURSOR_BUILTIN_DENY_LIST: readonly ["Shell", "Read", "Write", "Delete", "Grep", "Glob", "Edit", "ApplyPatch", "Task", "SemanticSearch", "SemSearch", "ReadLints", "LS", "CreatePlan", "UpdateTodos", "Await", "WebFetch", "WebSearch", "GenerateImage"];
+export declare const CUSTOM_USER_TOOLS_SERVER = "custom-user-tools";
+export declare function ensureCcrHomePaths(): string[];
+export declare function hashSessionFingerprint(parts: string[]): string;
+export declare function coerceThinkingText(value: unknown): string;
+export declare function extractEffort(request: any): string | undefined;

package/dist/cursor-sdk/tools.d.ts

@@ -0,0 +1,4 @@
+import type { SDKCustomTool } from "@cursor/sdk";
+import type { UnifiedChatRequest } from "../types/llm";
+import type { CursorSdkSession } from "./session";
+export declare function toCustomTools(request: UnifiedChatRequest, session: CursorSdkSession): Record<string, SDKCustomTool>;

package/dist/cursor-sdk/usage.d.ts

@@ -0,0 +1,28 @@
+import type { UnifiedChatRequest } from "../types/llm";
+export type OpenAiUsage = {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    prompt_tokens_details?: {
+        cached_tokens?: number;
+    };
+};
+/**
+ * Rough char→token estimate for mid-turn usage before Cursor emits a usage
+ * event (and as the host-facing request usage even when it does).
+ * Mirrors cursor-opencode-provider: never report Cursor cumulative counters as
+ * the current Claude Code / OpenCode request usage.
+ */
+export declare function estimateTokens(chars: number): number;
+/** Estimate current-request prompt tokens from the Claude Code → CCR payload. */
+export declare function estimateRequestPromptTokens(request: UnifiedChatRequest): number;
+/** Build OpenAI-style usage for a single CCR request (not Cursor session totals). */
+export declare function requestUsageFromEstimate(promptTokens: number, outputChars: number, cacheReadTokens?: number): OpenAiUsage;
+/**
+ * Cursor SDK usage is session-cumulative, while Claude Code needs per-request
+ * usage. Use SDK usage only as a cache-read ratio and apply it to CCR's
+ * current-request prompt estimate.
+ */
+export declare function cacheReadFromSdkDelta(current: OpenAiUsage | undefined, previous: OpenAiUsage | undefined, promptTokens: number): number;
+/** Map SDK TokenUsage / usage message into OpenAI shape (diagnostics only). */
+export declare function usageFromSdk(message: any): OpenAiUsage | undefined;