@caeliq/llms 1.0.65 → 1.0.67

package/dist/cursor-sdk/auth-exchange-cache.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @cursor/sdk POSTs /auth/exchange_user_api_key on every Agent.create and
+ * models.list. Subagent turns mint new session keys, so Agent.create runs
+ * again and the SDK does not cache the access token across those calls.
+ *
+ * Wrap global fetch: coalesce in-flight exchanges per crsr_ key, reuse the
+ * access token until a Cursor request with that token returns 401.
+ *
+ * Critical: never forward a caller's AbortSignal onto the shared exchange.
+ * Agent.create often cancels while another waiter still needs the token; if
+ * the first caller's signal aborts the shared fetch, every waiter rejects
+ * with AbortError and Node surfaces unhandledRejection / late-handled
+ * PromiseRejectionHandledWarning.
+ */
+/**
+ * Drop a cached exchanged token for a dashboard API key (crsr_... or Bearer).
+ * Call when Cursor reports auth failure via run status / AuthenticationError —
+ * those paths often never surface as an HTTP 401 on the wrapped fetch.
+ */
+export declare function invalidateCursorAuthExchange(crsrApiKey: string): void;
+/** Re-wrap if tests or other code replaced globalThis.fetch. */
+export declare function installCursorAuthExchangeCache(): void;
+export declare function __resetCursorAuthExchangeCacheForTests(): void;

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

@@ -43,7 +43,9 @@ export type CursorLifecycleInput<TParked extends CursorParkedToolRef = CursorPar
         toolResults: readonly TResult[];
     };
 };
-export type CursorLifecycleRetirementReason = "poisoned-session" | "inconsistent-unused-session" | "unknown-context-alignment" | "divergent-context-alignment" | "active-different-turn" | "dead-parked-run" | "parked-turn-has-steering" | "parked-tool-results-mismatch" | "orphaned-tool-results";
+/** Hard remint only — soft alignment cases stay on the same agent. */
+export type CursorLifecycleRetirementReason = "poisoned-session";
+export type CursorLifecycleIncrementalReason = "strictly-aligned-idle-session" | "unknown-context-alignment" | "divergent-context-alignment" | "active-different-turn" | "dead-parked-run" | "parked-turn-has-steering" | "parked-tool-results-mismatch" | "orphaned-tool-results";
 export type CursorLifecycleRetirementPlan = {
     action: "retire-and-replay-full";
     reason: CursorLifecycleRetirementReason;
@@ -54,13 +56,23 @@ export type CursorLifecyclePlan<TParked extends CursorParkedToolRef = CursorPark
     matches: ExactParkedResultMatch<TParked, TResult>;
 } | {
     action: "send-full";
-    reason: "unused-session";
+    reason: "unused-session" | "inconsistent-unused-session";
 } | {
     action: "send-incremental";
-    reason: "strictly-aligned-idle-session";
+    reason: CursorLifecycleIncrementalReason;
 } | CursorLifecycleRetirementPlan;
 /**
- * Choose the only safe lifecycle action for a new, non-coalesced host turn.
+ * Soft incremental reasons where the runner must cancel/abandon any prior
+ * active or parked run before `agent.send` — without reminting the agent.
+ */
+export declare const CURSOR_SOFT_CANCEL_THEN_INCREMENTAL: Set<CursorLifecycleIncrementalReason>;
+/**
+ * Choose the lifecycle action for a new, non-coalesced host turn.
+ *
+ * Soft transcript-alignment mismatches stay on the same Cursor agent via
+ * `send-incremental` (caller cancels parked/active runs when needed). Hard
+ * remint (`retire-and-replay-full`) is reserved for poisoned sessions; send/
+ * stream failure recovery remints in the runner, not here.
  *
  * This function is intentionally pure. It neither resolves parked tools nor
  * changes session state; the caller executes the returned plan under its

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

@@ -3,6 +3,11 @@ import { type UnifiedTurnIntent } from "../types/turn-intent";
 import type { SDKUserMessage } from "@cursor/sdk";
 import { type HostEnvironment } from "./host-env";
 export declare function buildBridgeSystemGuidance(request: UnifiedChatRequest, workspaceDir: string, hostEnv?: HostEnvironment): string;
+/**
+ * Identity of the bridge preamble actually sent on an agent. Unchanged
+ * follow-ups skip re-sending it so Cursor history does not stack copies.
+ */
+export declare function bridgePromptGuidanceFingerprint(request: UnifiedChatRequest, workspaceDir: string, hostEnv: HostEnvironment): string;
 /**
  * Short restatement appended after the transcript. The guidance above is far
  * from the generation point once history is flattened in; this is the last
@@ -37,6 +42,11 @@ export declare function toSdkPrompt(request: UnifiedChatRequest, options: {
     hostEnv?: HostEnvironment;
     /** Protocol semantics recovered before Anthropic content was flattened. */
     turnIntent?: UnifiedTurnIntent;
+    /**
+     * Bridge preamble + tail reminder. Default true. Set false on follow-ups
+     * whose tool catalog and host env already went out on this agent.
+     */
+    includeBridgeGuidance?: boolean;
 }): SDKUserMessage;
 export type TrailingCursorToolTurn = {
     toolResults: Array<{

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

@@ -63,6 +63,11 @@ export type CursorSdkSession = {
     compatibilityStamp?: string;
     /** Fingerprint of the host env baked into the workspace rules/deny hooks. */
     guidanceFingerprint?: string;
+    /**
+     * Bridge preamble last actually sent on this agent (host env + tool catalog).
+     * Unchanged follow-ups omit the preamble so history does not stack copies.
+     */
+    lastBridgePromptGuidanceFingerprint?: string;
     /**
      * Set when the local SDK handles are no longer trustworthy. The manager must
      * not hand this agent out for a future request.
@@ -138,11 +143,29 @@ export declare function shouldEnableCursorSandbox(requested?: boolean): boolean;
  * path correction) is updated here regardless.
  */
 export declare function refreshWorkspaceGuidance(session: CursorSdkSession, hostEnv: HostEnvironment): boolean;
+/**
+ * Cursor SDK session directory key. Prefer explicit client conversation ids
+ * over hashing prompt text — never include system / harness version.
+ *
+ * Claude Code subagents share the parent session id. Mix first-user text so
+ * parallel Task agents each get their own Cursor Agent instead of collapsing
+ * onto one turn registry slot.
+ */
 export declare function buildSessionKey(input: {
     headerSession?: string;
+    /** Inbound-captured Claude/OpenCode session id (protocolContext / req). */
+    clientSessionId?: string;
     metadataUserId?: string;
     model?: string;
+    /** Anonymous clients only: first user text (not system). */
+    firstUserText?: string;
+    /** @deprecated Use firstUserText. Kept for call-site compatibility. */
     systemAndFirstUser?: string;
+    /**
+     * Claude Code Task / subagent turn. Parent session id alone is not unique
+     * across parallel subagents.
+     */
+    isSubagent?: boolean;
 }): string;
 /** True while a session has a live run, open stream, or unresolved host tools. */
 export declare function isSessionInFlight(session: CursorSdkSession): boolean;

package/dist/cursor-sdk/turn-output.d.ts

@@ -71,6 +71,9 @@ export declare class CursorTurnRegistry {
         responseKind: "stream" | "json";
         signal?: AbortSignal;
     }): Promise<CursorTurnLease>;
+    peekActive(sessionKey: string): {
+        fingerprint: string;
+    } | undefined;
     clear(): void;
 }
 export declare const globalCursorTurnRegistry: CursorTurnRegistry;

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

@@ -7,6 +7,13 @@ export type OpenAiUsage = {
         cached_tokens?: number;
     };
 };
+export type CursorUsageCounters = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheRead: number;
+    cacheWrite: number;
+    reasoningTokens: 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).
@@ -18,11 +25,21 @@ export declare function estimateTokens(chars: number): number;
 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;
+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.
+ *
+ * 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.
+ */
+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). */
 export declare function usageFromSdk(message: any): OpenAiUsage | undefined;