@caeliq/llms 1.0.67 → 1.0.68

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

@@ -95,12 +95,12 @@ export declare function createSseHelpers(model: string, encoder: TextEncoder): {
             finish_reason: "stop" | "tool_calls";
         }[];
         usage: {
+            prompt_tokens_details?: {
+                cached_tokens: number;
+            } | undefined;
             prompt_tokens: number;
             completion_tokens: number;
             total_tokens: number;
-            prompt_tokens_details: {
-                cached_tokens: number;
-            };
         };
         id: string;
         object: string;

package/dist/cursor-sdk/lifecycle-planner.d.ts

@@ -36,6 +36,11 @@ export type CursorLifecycleInput<TParked extends CursorParkedToolRef = CursorPar
         hasSentPrompt: boolean;
         poisoned: boolean;
         alignment: CursorContextAlignment;
+        /**
+         * False when agent/model/workspace/tool configuration changed since the
+         * transcript commit. Undefined preserves the legacy behavior (match).
+         */
+        compatibilityMatch?: boolean;
         run: CursorRunSnapshot<TParked>;
     };
     turn: {

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

@@ -4,6 +4,7 @@ import type { CursorTranscriptCommit } from "./turn-identity";
 import { type HostEnvironment } from "./host-env";
 import { type CursorSdkMode } from "./shared";
 export type ParkedTool = {
+    /** Original Cursor SDK tool-call id (never emitted to the client). */
     id: string;
     name: string;
     args: Record<string, unknown>;
@@ -30,8 +31,20 @@ export type CursorSdkSession = {
     streamNext?: Promise<IteratorResult<any>>;
     streamNextRunToken?: symbol;
     activeRunToken?: symbol;
+    /** Raw usage from the last completed SDK turn; never a parked CCR boundary. */
     lastSdkUsageRaw?: OpenAiUsage;
     parked: ParkedTool[];
+    /**
+     * Per-session bidirectional map between raw Cursor SDK tool-call ids
+     * (possibly newline-joined / overlong) and the host-safe aliases emitted
+     * to the client. Parked records keep originals; the wire carries aliases;
+     * incoming echoes are translated back before matching. Dies with the
+     * session; bounded below so long-lived agents cannot grow it forever.
+     */
+    toolIdAliases: {
+        byOriginal: Map<string, string>;
+        byAlias: Map<string, string>;
+    };
     /** Tool calls waiting to be emitted on the current SSE response. */
     pendingEmit: Array<{
         id: string;
@@ -103,6 +116,13 @@ export type CancelActiveRunResult = {
     failed: boolean;
     timedOut: boolean;
 };
+export declare function aliasHostToolId(session: CursorSdkSession, original: unknown): string | undefined;
+/**
+ * Translate a client-echoed tool-call id back to the parked SDK original.
+ * Unknown ids pass through unchanged so legacy / unmapped turns mismatch
+ * exactly as before instead of collapsing onto something unrelated.
+ */
+export declare function resolveHostToolId(session: CursorSdkSession, echoed: unknown): string;
 export declare function markSessionPoisoned(session: CursorSdkSession, reason: string): void;
 /**
  * Drop local run handles and await SDK `run.cancel()` when needed.
@@ -210,6 +230,7 @@ export declare class SessionManager {
     dispose(key: string): Promise<void>;
     invalidate(sessionOrKey: CursorSdkSession | string, reason: string): Promise<void>;
     private disposeAgent;
+    private rehydratePersistedAgent;
     private createSessionRecord;
     private evictIfNeeded;
     private evictIdle;

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

@@ -26,3 +26,10 @@ export declare function contentToText(content: UnifiedMessage["content"]): strin
 export declare function hashSessionFingerprint(parts: string[]): string;
 export declare function coerceThinkingText(value: unknown): string;
 export declare function extractEffort(request: any): string | undefined;
+/**
+ * Transient Cursor provider failures (throttling / overload) must not destroy
+ * the warm sticky agent: the retry reuses it instead of paying a cold start.
+ * Auth errors and client aborts are NOT transient — they keep the old
+ * retire-the-session behavior at the call site.
+ */
+export declare function isCursorTransientProviderError(err: unknown): boolean;

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

@@ -27,18 +27,25 @@ export declare function estimateRequestPromptTokens(request: UnifiedChatRequest)
 export declare function requestUsageFromEstimate(promptTokens: number, outputChars: number, cacheReadTokens?: number): OpenAiUsage;
 export declare function cursorUsageCountersFromSdk(raw: OpenAiUsage | undefined): CursorUsageCounters | undefined;
 /**
- * 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.
+ * Cursor SDK usage is per SDK turn, while Claude Code needs per-CCR-request
+ * usage. In bridge mode one SDK turn can span several parked host-tool request
+ * cycles. Use a terminal SDK witness only as a cache-read ratio for the CCR
+ * request that observes it; never attribute it to an earlier parked response.
  *
  * Kept for tests; prefer buildAccurateUsageFromSdk for turn-end reporting.
  */
 export declare function cacheReadFromSdkDelta(current: OpenAiUsage | undefined, previous: OpenAiUsage | undefined, promptTokens: number): number;
 /**
- * Build per-request OpenAI usage from SDK TurnEnded counters, normalized to
- * the per-request prompt estimate but preserving Cursor's cache proportions
- * (same math as cursor-opencode-provider buildLanguageModelV3UsageFromCounters).
- * Falls back to chars/4-based completion tokens when SDK output is absent.
+ * Build per-request OpenAI usage from the SDK turn-end usage message,
+ * normalized to the per-request prompt estimate but preserving Cursor's cache
+ * proportions (same math as cursor-opencode-provider
+ * buildLanguageModelV3UsageFromCounters). Falls back to chars/4-based
+ * completion tokens when SDK output is absent.
+ *
+ * When the runtime reports no usage for the turn (the SDK emits the usage
+ * message only "when the runtime reported usage"), prompt_tokens_details is
+ * omitted entirely so the cache-outcome tap reports "unknown" instead of a
+ * bogus "unexpected-miss" from a zero that was never measured.
  */
 export declare function buildAccurateUsageFromSdk(sdkRaw: OpenAiUsage | undefined, promptTokens: number, outputChars: number, priorRaw?: OpenAiUsage | undefined): OpenAiUsage;
 /** Map SDK TokenUsage / usage message into OpenAI shape (diagnostics only). */