@caeliq/llms 1.0.56 → 1.0.58

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

@@ -0,0 +1,77 @@
+declare class SharedCursorTurn {
+    readonly sessionKey: string;
+    readonly fingerprint: string;
+    readonly responseKind: "stream" | "json";
+    private readonly onTerminal;
+    readonly abortController: AbortController;
+    private phase;
+    private responseMetadata?;
+    private sourceReader?;
+    private chunks;
+    private bufferedBytes;
+    private replayable;
+    private readySettled;
+    private completedAt?;
+    private nextInterestId;
+    private nextSubscriberId;
+    private interests;
+    private subscribers;
+    private failure?;
+    private readyResolve;
+    private readyReject;
+    private settledResolve;
+    private readonly ready;
+    private readonly settled;
+    constructor(sessionKey: string, fingerprint: string, responseKind: "stream" | "json", onTerminal: (turn: SharedCursorTurn, outcome: "completed" | "failed") => void);
+    get canReplay(): boolean;
+    get replayAgeMs(): number;
+    get isJoinable(): boolean;
+    get isProducing(): boolean;
+    reserve(signal: AbortSignal | undefined, kind: "leader" | "join" | "replay"): CursorTurnLease;
+    releaseInterest(interestId: number): Promise<void> | undefined;
+    attach(response: Response, leaderInterestId: number, leaderSignal?: AbortSignal): Promise<Response | undefined>;
+    fail(error: unknown): void;
+    supersede(reason: string): Promise<void>;
+    responseFor(interestId: number, signal?: AbortSignal): Promise<Response>;
+    private responseForReadyInterest;
+    private openStream;
+    private pumpStarted;
+    private ensurePumpStarted;
+    private pump;
+    private abortIfUnobserved;
+    private removeSubscriber;
+    private closeSubscriber;
+    private errorSubscribers;
+    private releaseSourceReader;
+    private finishCompleted;
+    private finishFailed;
+}
+export declare class CursorTurnLease {
+    private readonly turn;
+    private readonly interestId;
+    private readonly signal?;
+    readonly kind: "leader" | "join" | "replay";
+    private attachedResponse?;
+    private removeReservationAbortListener?;
+    constructor(turn: SharedCursorTurn, interestId: number, signal?: AbortSignal | undefined, kind?: "leader" | "join" | "replay");
+    get producerSignal(): AbortSignal;
+    attach(response: Response): Promise<void>;
+    fail(error: unknown): void;
+    response(): Promise<Response>;
+}
+export declare class CursorTurnRegistry {
+    private sessions;
+    /** FIFO admission barrier; lifecycle supersession contains awaited cleanup. */
+    private admissionGates;
+    private forgetExpiredSuperseded;
+    private rememberSuperseded;
+    admit(input: {
+        sessionKey: string;
+        fingerprint: string;
+        responseKind: "stream" | "json";
+        signal?: AbortSignal;
+    }): Promise<CursorTurnLease>;
+    clear(): void;
+}
+export declare const globalCursorTurnRegistry: CursorTurnRegistry;
+export {};

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;