@caeliq/llms 1.0.72 → 1.0.73

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

@@ -0,0 +1,21 @@
+export type InternalCursorSession = {
+    /** Opaque id passed to the Cursor SDK session key. Never a client header. */
+    internalId: string;
+    /** Registry key: protocol identity, or the anonymous opening. */
+    inboundKey: string;
+};
+/**
+ * Protocol conversation → opaque Cursor session id.
+ *
+ * `isActive` reports whether the agent behind an internal id is running a
+ * turn or finished one within the replay window; it extends an opening's
+ * retry window past the time of its first request.
+ */
+export declare function resolveInternalCursorSession(input: {
+    protocol?: string;
+    request: unknown;
+    context: any;
+    model: string;
+    sourceSessionIdentity?: string;
+    isActive?: (internalId: string) => boolean;
+}): InternalCursorSession;

package/dist/cursor-sdk/model-selection.d.ts

@@ -0,0 +1,23 @@
+import type { ModelListItem, ModelSelection } from "@cursor/sdk";
+/**
+ * Reasoning the client asked for. `undefined`: none (absent, `none`, or
+ * disabled). `{}`: on at the model's default effort. `{ effort }`: on at
+ * that level.
+ */
+export type CursorReasoning = {
+    effort?: string;
+} | undefined;
+/**
+ * Map a CCR model id and the client's reasoning request onto an SDK
+ * ModelSelection from a Cursor.models.list catalog. Parameterized models
+ * (Grok 4.7 context/effort/fast) always get explicit params, as the Cursor
+ * SDK docs recommend; see `wantedParams` for the values.
+ *
+ * Grok 4.7 has no off switch, so no reasoning selects 256k+low+non-fast;
+ * Claude models select `thinking=false`, GPT 5.4+ `reasoning=none`.
+ */
+export declare function selectCursorModelSelection(models: ModelListItem[], modelId: string, reasoning?: CursorReasoning): ModelSelection;
+/** Stable id+params key for persist/compare. Order of params does not matter. */
+export declare function cursorModelFingerprint(selection: ModelSelection): string;
+export declare function cursorModelSelectionsEqual(left: ModelSelection | undefined, right: ModelSelection): boolean;
+export declare function isCursorInvalidRegistryModelError(err: unknown): boolean;

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

@@ -67,6 +67,11 @@ export type CursorSdkSession = {
     sendChain: Promise<void>;
     /** True after at least one successful `agent.send` on this session. */
     hasSentPrompt: boolean;
+    /**
+     * The agent was resumed (`Agent.resume`) rather than created for this
+     * session, so it carries server-side state from an earlier binding.
+     */
+    resumedAgent: boolean;
     /**
      * Exact host-visible transcript represented by this agent after the last
      * completed response. Unknown means tail-only reuse is forbidden.
@@ -164,14 +169,18 @@ export declare function shouldEnableCursorSandbox(requested?: boolean): boolean;
  */
 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.
+ * Cursor SDK session directory key. Prefer an explicit conversation id over
+ * hashing prompt text — never include system / harness version.
+ *
+ * The runner passes the opaque id from `inbound-session.ts` as
+ * `headerSession`. That id is already unique per protocol conversation,
+ * including parallel Tasks. Clients do not send it.
  *
- * 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.
+ * Direct callers that still pass a shared parent id plus first-user text get
+ * the mix below, so parallel workers do not collapse onto one Agent.
  */
 export declare function buildSessionKey(input: {
+    /** Opaque Cursor session id, or a caller-supplied conversation id. */
     headerSession?: string;
     /** Inbound-captured Claude/OpenCode session id (protocolContext / req). */
     clientSessionId?: string;
@@ -203,6 +212,8 @@ export declare class SessionManager {
     constructor(logger?: any | undefined);
     setLogger(logger: any): void;
     get(key: string): CursorSdkSession | undefined;
+    /** Live session for `key`, without touching, retiring, or creating one. */
+    peek(key: string): CursorSdkSession | undefined;
     retireSession(session: CursorSdkSession, reason: string, cleanup: () => Promise<boolean>): Promise<boolean>;
     getOrCreate(options: {
         key: string;

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

@@ -1,3 +1,4 @@
+import { type CursorReasoning } from "./model-selection";
 import type { UnifiedMessage } from "../types/llm";
 export declare const CURSOR_SDK_TRANSFORMER_NAME = "cursor-sdk";
 export type CursorSdkMode = "bridge" | "plan" | "agent";
@@ -25,7 +26,15 @@ export declare function ensureCcrHomePaths(): string[];
 export declare function contentToText(content: UnifiedMessage["content"]): string;
 export declare function hashSessionFingerprint(parts: string[]): string;
 export declare function coerceThinkingText(value: unknown): string;
-export declare function extractEffort(request: any): string | undefined;
+/**
+ * The reasoning a Unified request asks Cursor for. Every inbound protocol
+ * maps its own field (`thinking` / `output_config.effort`,
+ * `reasoning_effort`, `reasoning`) onto Unified `reasoning` and `thinking`.
+ * No signal, effort `none`, or disabled thinking means no reasoning.
+ */
+export declare function extractCursorReasoning(request: any): CursorReasoning;
+/** Stable label for a reasoning request, for compatibility stamps. */
+export declare function cursorReasoningKey(reasoning: CursorReasoning): string;
 /**
  * Transient Cursor provider failures (throttling / overload) must not destroy
  * the warm sticky agent: the retry reuses it instead of paying a cold start.

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

@@ -1,3 +1,5 @@
+/** How long an identical completed turn replays instead of re-running. */
+export declare const COMPLETED_TURN_TTL_MS = 60000;
 declare class SharedCursorTurn {
     readonly sessionKey: string;
     readonly fingerprint: string;