@beeuni/sdk 0.1.0 → 0.2.0

package/dist/core/session-sync/saved-copy-store.js

@@ -1,3 +1,4 @@
+import { registerSessionLogCopies, SESSION_LOG_COPY } from '../session-log/saved-log.js';
 export function isPaintableSavedCopy(envelope) {
     return (!!envelope &&
         envelope.available === true &&
@@ -58,7 +59,27 @@ function capturedAtMs(envelope) {
     const parsed = envelope.captured_at ? Date.parse(envelope.captured_at) : Number.NaN;
     return Number.isFinite(parsed) ? parsed : 0;
 }
+const ENVELOPE = {
+    paintable: isPaintableSavedCopy,
+    fit: fitSavedCopy,
+    capturedAt: capturedAtMs,
+};
 export function createSavedCopyStore(options) {
+    const v1 = createCopyStore(options, ENVELOPE);
+    const v2 = createCopyStore({ ...options, namespace: `${options.namespace ?? DEFAULT_NAMESPACE}.log` }, SESSION_LOG_COPY);
+    const store = {
+        ...v1,
+        remove: async (projectId, sessionId) => {
+            await Promise.all([v1.remove(projectId, sessionId), v2.remove(projectId, sessionId)]);
+        },
+        clear: async () => {
+            await Promise.all([v1.clear(), v2.clear()]);
+        },
+    };
+    registerSessionLogCopies(store, v2, v1.remove);
+    return store;
+}
+function createCopyStore(options, codec) {
     const { storage, userId, maxSessions = DEFAULT_MAX_SESSIONS, maxBytes = DEFAULT_MAX_BYTES, maxEnvelopeBytes = DEFAULT_MAX_ENVELOPE_BYTES, maxAgeMs = DEFAULT_MAX_AGE_MS, namespace = DEFAULT_NAMESPACE, now = () => Date.now(), } = options;
     const prefix = `${namespace}:${userId}:`;
     const indexKey = `${prefix}index`;
@@ -163,7 +184,7 @@ export function createSavedCopyStore(options) {
                     stored.v !== VERSION ||
                     stored.user !== userId ||
                     now() - stored.at > maxAgeMs ||
-                    !isPaintableSavedCopy(stored.e)) {
+                    !codec.paintable(stored.e)) {
                     removeNow(keyFor(projectId, sessionId));
                     void forgetScope(scope);
                     return null;
@@ -174,13 +195,13 @@ export function createSavedCopyStore(options) {
         },
         write(projectId, sessionId, envelope) {
             const scope = `${projectId}/${sessionId}`;
-            if (!isPaintableSavedCopy(envelope))
+            if (!codec.paintable(envelope))
                 return forgetScope(scope);
             const stored = { v: VERSION, user: userId, at: now(), e: envelope };
-            const text = fitSavedCopy(stored, maxEnvelopeBytes);
+            const text = codec.fit(stored, maxEnvelopeBytes);
             if (text === null)
                 return forgetScope(scope);
-            const captured = capturedAtMs(envelope);
+            const captured = codec.capturedAt(envelope);
             return enqueue(async () => {
                 const entries = await loadIndex();
                 const existing = entries.find((entry) => entry.s === scope);

package/dist/core/stream/event-stream.js

@@ -1,4 +1,4 @@
-import { getSupabaseAccessToken, invalidateTokenCache } from '../http/auth.js';
+import { getAuthToken, invalidateTokenCache } from '../http/auth.js';
 import { getClientForUrl } from '../runtime/client.js';
 import { isAuthFailure } from '../http/api/errors.js';
 import { logger } from '../http/logger.js';
@@ -241,7 +241,7 @@ function createLiveStream(client, opts, subscribers) {
                 if (isAuthError) {
                     try {
                         invalidateTokenCache();
-                        await getSupabaseAccessToken();
+                        await getAuthToken();
                         logger.info('SSE: refreshed auth token after auth error');
                     }
                     catch (refreshErr) {

package/dist/core/turns/classify.d.ts

@@ -1,6 +1,7 @@
 import type { MessageWithParts } from '../../transcript.js';
 import type { Part, ToolPart } from '../runtime/client.js';
 import { type GatewayAttemptFailure } from './errors.js';
+import type { ToolCallBlock } from '../session-log/types.js';
 import { type ToolKind } from './tool-kind.js';
 import type { TokenUsageLike } from './types.js';
 export type ToolStatus = 'pending' | 'running' | 'done' | 'error';
@@ -30,7 +31,7 @@ export interface ToolView {
     answers?: string[][];
     childSessionId?: string;
 }
-export declare function toToolView(part: Pick<ToolPart, 'tool' | 'state'>): ToolView;
+export declare function toToolView(call: Pick<ToolPart, 'tool' | 'state'> | ToolCallBlock): ToolView;
 export interface ClassifiedTextPart {
     kind: 'text';
     id: string;

package/dist/core/turns/classify.js

@@ -1,5 +1,6 @@
 import { extractGatewayErrorDetails, unwrapError } from './errors.js';
 import { getChildSessionId } from './parts.js';
+import { isToolCallBlock, toolPartOf } from '../session-log/tool-call.js';
 import { inputPath, toolKind } from './tool-kind.js';
 import { toolInfo } from './tool-registry.js';
 const MAX_PARSEABLE_OUTPUT_LENGTH = 256 * 1024;
@@ -153,7 +154,8 @@ function classifyToolState(tool, state) {
         childSessionId: getChildSessionId({ tool, state }),
     };
 }
-export function toToolView(part) {
+export function toToolView(call) {
+    const part = isToolCallBlock(call) ? toolPartOf(call) : call;
     return classifyToolState(part.tool, part.state);
 }
 function classifyText(part) {

package/dist/core/turns/parts.d.ts

@@ -1,3 +1,4 @@
+import type { ToolCallBlock } from '../session-log/types.js';
 import type { Diagnostic, MessageWithPartsLike, PartLike, RequestWithToolLike, ToolInfo, ToolPartLike } from './types.js';
 export declare function isTextPart<P extends PartLike>(part: P): part is P & {
     type: 'text';
@@ -42,8 +43,8 @@ export interface HiddenToolRef {
 }
 export declare function getHiddenToolParts(permission: RequestWithToolLike | undefined, question: RequestWithToolLike | undefined): HiddenToolRef[];
 export declare function isToolPartHidden(part: Pick<ToolPartLike, 'callID'>, messageId: string, hidden: HiddenToolRef[]): boolean;
-export declare function shouldShowToolPart(part: Pick<ToolPartLike, 'tool'>): boolean;
-export declare function getChildSessionId(part: Pick<ToolPartLike, 'tool' | 'state'>): string | undefined;
+export declare function shouldShowToolPart(part: Pick<ToolPartLike, 'tool'> | ToolCallBlock): boolean;
+export declare function getChildSessionId(call: Pick<ToolPartLike, 'tool' | 'state'> | ToolCallBlock): string | undefined;
 export declare function getChildSessionError(childMessages: readonly MessageWithPartsLike[] | undefined): string | undefined;
 export declare function getChildSessionToolParts<M extends MessageWithPartsLike>(childMessages: readonly M[]): Array<M['parts'][number] & {
     type: 'tool';

package/dist/core/turns/parts.js

@@ -1,4 +1,5 @@
 import { unwrapError } from './errors.js';
+import { isToolCallBlock, toolPartOf } from '../session-log/tool-call.js';
 import { inputPath, toolKind } from './tool-kind.js';
 import { normalizeName } from './tools/tool-meta.js';
 export function isTextPart(part) {
@@ -67,7 +68,7 @@ export function isToolPartHidden(part, messageId, hidden) {
 }
 const HIDDEN_TOOLS = new Set(['todoread', 'context_info']);
 export function shouldShowToolPart(part) {
-    return !HIDDEN_TOOLS.has(part.tool);
+    return !HIDDEN_TOOLS.has(isToolCallBlock(part) ? part.name : part.tool);
 }
 const CHILD_SESSION_TOOLS = new Set([
     'task',
@@ -82,7 +83,8 @@ const CHILD_SESSION_TOOLS = new Set([
     'task_update',
     'task_message',
 ]);
-export function getChildSessionId(part) {
+export function getChildSessionId(call) {
+    const part = isToolCallBlock(call) ? toolPartOf(call) : call;
     const tool = part.tool || '';
     if (tool.startsWith('oc-'))
         return undefined;

package/dist/core/turns/segments/index.d.ts

@@ -10,3 +10,4 @@ export * from './show-group.js';
 export * from './step-label.js';
 export * from './working-turn.js';
 export * from './turn-busy-visibility.js';
+export * from './work-split.js';

package/dist/core/turns/segments/index.js

@@ -10,3 +10,4 @@ export * from './show-group.js';
 export * from './step-label.js';
 export * from './working-turn.js';
 export * from './turn-busy-visibility.js';
+export * from './work-split.js';

package/dist/core/turns/segments/work-split.d.ts

@@ -0,0 +1,10 @@
+import type { ShowGroupedSegment } from './show-group.js';
+export interface TurnWorkSplit<S extends ShowGroupedSegment = ShowGroupedSegment> {
+    work: S[];
+    hoisted: S[];
+    final: S[];
+}
+export declare function splitTurnWork<S extends ShowGroupedSegment = ShowGroupedSegment>(segments: ReadonlyArray<S>, opts: {
+    working: boolean;
+}): TurnWorkSplit<S> | null;
+export declare function workedForLabel(durationMs: number | null): string;

package/dist/core/turns/segments/work-split.js

@@ -0,0 +1,40 @@
+import { formatDuration } from '../state.js';
+import { normalizeActivityToolName } from './session-activity-groups.js';
+function isDeliverableSegment(segment) {
+    if (segment.kind === 'show-group')
+        return true;
+    if (segment.kind !== 'standalone')
+        return false;
+    const name = normalizeActivityToolName(segment.part.tool);
+    return name === 'show' || name === 'show_user';
+}
+function isBlankText(segment) {
+    return segment.kind === 'text' && !segment.part.text?.trim();
+}
+export function splitTurnWork(segments, opts) {
+    if (opts.working)
+        return null;
+    let finalIndex = -1;
+    for (let i = segments.length - 1; i >= 0; i--) {
+        const segment = segments[i];
+        if (isDeliverableSegment(segment) || isBlankText(segment))
+            continue;
+        if (segment.kind === 'text')
+            finalIndex = i;
+        break;
+    }
+    const split = { work: [], hoisted: [], final: [] };
+    segments.forEach((segment, i) => {
+        if (i === finalIndex)
+            split.final.push(segment);
+        else if (isDeliverableSegment(segment))
+            split.hoisted.push(segment);
+        else
+            split.work.push(segment);
+    });
+    return split.work.length > 0 ? split : null;
+}
+export function workedForLabel(durationMs) {
+    const duration = durationMs == null ? '' : formatDuration(durationMs);
+    return duration ? `Worked for ${duration}` : 'Worked';
+}

package/dist/core/turns/state.d.ts

@@ -1,5 +1,5 @@
 import { extractGatewayErrorDetails } from './errors.js';
-import type { MessageInfoLike, MessageWithPartsLike, ModelPricingLookup, PartLike, PartWithMessage, RetryInfo, SessionStatusLike, TurnCostInfo, TurnLike } from './types.js';
+import type { MessageWithPartsLike, PartLike, PartWithMessage, RetryInfo, SessionStatusLike, TurnCostInfo, TurnLike } from './types.js';
 export declare function isLastUserMessage(messageId: string, allMessages: readonly MessageWithPartsLike[]): boolean;
 export declare function getWorkingState(sessionStatus: SessionStatusLike | undefined, isLast: boolean): boolean;
 export declare function shouldHideResponsePart(working: boolean, responsePartId: string | undefined): boolean;
@@ -11,12 +11,7 @@ export declare function getTurnStatus(parts: ReadonlyArray<{
     part: PartLike;
 }>, childMessages?: readonly MessageWithPartsLike[]): string;
 export declare function formatDuration(ms: number): string;
-export declare const COST_MARKUP = 1.2;
-export declare function getTurnCost(parts: ReadonlyArray<PartWithMessage>, lookup?: ModelPricingLookup): TurnCostInfo | undefined;
-export declare function getSessionCost(messages: ReadonlyArray<{
-    info?: MessageInfoLike;
-    parts: PartLike[];
-}>, lookup?: ModelPricingLookup): number;
+export declare function getTurnTokens(parts: ReadonlyArray<PartWithMessage>): TurnCostInfo['tokens'] | undefined;
 export declare function formatCost(cost: number): string;
 export declare function formatTokens(tokens: number): string;
 export declare function getRetryInfo(status: SessionStatusLike | undefined): RetryInfo | undefined;

package/dist/core/turns/state.js

@@ -185,145 +185,39 @@ export function formatDuration(ms) {
     const secs = seconds % 60;
     return secs > 0 ? `${minutes}m ${secs}s` : `${minutes}m`;
 }
-export const COST_MARKUP = 1.2;
-function estimateTokenCost(tokens, rates) {
-    if (!tokens)
-        return 0;
-    const input = tokens.input ?? 0;
-    const output = (tokens.output ?? 0) + (tokens.reasoning ?? 0);
-    const cacheRead = tokens.cache?.read ?? 0;
-    const cacheWrite = tokens.cache?.write ?? 0;
-    const regularInput = Math.max(0, input - cacheRead - cacheWrite);
-    const tierCandidates = [
-        ...(rates.tiers ?? []),
-        ...(rates.contextOver200k ? [rates.contextOver200k] : []),
-    ]
-        .filter((tier) => input > tier.contextThreshold)
-        .sort((a, b) => b.contextThreshold - a.contextThreshold);
-    const effective = tierCandidates[0] ?? rates;
-    let cost = (regularInput / 1_000_000) * effective.inputPer1M;
-    cost += (output / 1_000_000) * effective.outputPer1M;
-    if (cacheRead > 0) {
-        cost += (cacheRead / 1_000_000) * (effective.cacheReadPer1M ?? effective.inputPer1M);
-    }
-    if (cacheWrite > 0) {
-        cost += (cacheWrite / 1_000_000) * (effective.cacheWritePer1M ?? effective.inputPer1M);
-    }
-    return cost;
-}
-function isSubscriptionUsage(providerID, modelID) {
-    return (providerID === 'codex' ||
-        providerID === 'openai-codex' ||
-        (providerID === 'beeuni' && !!modelID?.startsWith('codex/')));
-}
-function stepFinishRawCost(sfp, providerID, modelID, lookup) {
-    if (isSubscriptionUsage(providerID, modelID))
-        return 0;
-    const reported = sfp.cost || 0;
-    if (reported > 0)
-        return reported;
-    if (!lookup || !providerID || !modelID)
-        return 0;
-    const rates = lookup(providerID, modelID);
-    if (!rates)
-        return 0;
-    return estimateTokenCost(sfp.tokens, rates);
-}
-function assistantMessageIds(message) {
-    if (message.role !== 'assistant')
-        return {};
-    const assistant = message;
-    return { providerID: assistant.providerID, modelID: assistant.modelID };
-}
-export function getTurnCost(parts, lookup) {
-    let totalCost = 0;
-    let input = 0;
-    let output = 0;
-    let reasoning = 0;
-    let cacheRead = 0;
-    let cacheWrite = 0;
+export function getTurnTokens(parts) {
+    const tokens = { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 };
     let found = false;
+    const add = (usage) => {
+        found = true;
+        tokens.input += usage.input ?? 0;
+        tokens.output += usage.output ?? 0;
+        tokens.reasoning += usage.reasoning ?? 0;
+        tokens.cacheRead += usage.cache?.read ?? 0;
+        tokens.cacheWrite += usage.cache?.write ?? 0;
+    };
+    const stepMessages = new Set();
     for (const { part, message } of parts) {
-        if (part.type === 'step-finish') {
-            found = true;
-            const sfp = part;
-            const { providerID, modelID } = assistantMessageIds(message.info);
-            totalCost += stepFinishRawCost(sfp, providerID, modelID, lookup);
-            input += sfp.tokens?.input || 0;
-            output += sfp.tokens?.output || 0;
-            reasoning += sfp.tokens?.reasoning || 0;
-            cacheRead += sfp.tokens?.cache?.read || 0;
-            cacheWrite += sfp.tokens?.cache?.write || 0;
-        }
-    }
-    if (!found) {
-        const seen = new Set();
-        for (const { message } of parts) {
-            if (message.info.role !== 'assistant')
-                continue;
-            const assistant = message.info;
-            if (seen.has(assistant.id))
-                continue;
-            seen.add(assistant.id);
-            const stepCost = assistantTokensCost(assistant, lookup);
-            const subscriptionTokens = assistant.tokens && isSubscriptionUsage(assistant.providerID, assistant.modelID);
-            if (stepCost <= 0 && !subscriptionTokens)
-                continue;
-            found = true;
-            totalCost += stepCost;
-            const t = assistant.tokens;
-            if (t) {
-                input += t.input ?? 0;
-                output += t.output ?? 0;
-                reasoning += t.reasoning ?? 0;
-                cacheRead += t.cache?.read ?? 0;
-                cacheWrite += t.cache?.write ?? 0;
-            }
-        }
+        if (part.type !== 'step-finish')
+            continue;
+        const usage = part.tokens;
+        if (!usage)
+            continue;
+        stepMessages.add(message.info.id);
+        add(usage);
     }
-    if (!found)
-        return undefined;
-    return {
-        cost: totalCost * COST_MARKUP,
-        tokens: { input, output, reasoning, cacheRead, cacheWrite },
-    };
-}
-function assistantTokensCost(assistant, lookup) {
-    if (isSubscriptionUsage(assistant.providerID, assistant.modelID))
-        return 0;
-    if (!lookup || !assistant.providerID || !assistant.modelID || !assistant.tokens)
-        return 0;
-    const rates = lookup(assistant.providerID, assistant.modelID);
-    if (!rates)
-        return 0;
-    return estimateTokenCost({
-        input: assistant.tokens.input,
-        output: assistant.tokens.output,
-        reasoning: assistant.tokens.reasoning,
-        cache: assistant.tokens.cache,
-    }, rates);
-}
-export function getSessionCost(messages, lookup) {
-    let totalCost = 0;
-    for (const msg of messages) {
-        if (msg.info?.role !== 'assistant')
+    const seen = new Set();
+    for (const { message } of parts) {
+        if (message.info.role !== 'assistant' ||
+            stepMessages.has(message.info.id) ||
+            seen.has(message.info.id))
             continue;
-        const assistant = msg.info;
-        const { providerID, modelID } = assistantMessageIds(assistant);
-        let msgCost = 0;
-        let sawStepFinish = false;
-        for (const part of msg.parts) {
-            if (part.type !== 'step-finish')
-                continue;
-            sawStepFinish = true;
-            msgCost += stepFinishRawCost(part, providerID, modelID, lookup);
-        }
-        if (!sawStepFinish) {
-            msgCost += assistantTokensCost(assistant, lookup);
-        }
-        totalCost += msgCost;
+        seen.add(message.info.id);
+        const usage = message.info.tokens;
+        if (usage)
+            add(usage);
     }
-    return totalCost * COST_MARKUP;
+    return found ? tokens : undefined;
 }
 export function formatCost(cost) {
     if (cost === 0)

package/dist/core/turns/tools/tool-meta.d.ts

@@ -1,4 +1,5 @@
 import type { ToolPart } from '../../runtime/client.js';
+import type { ToolCallBlock } from '../../session-log/types.js';
 export declare const CONTEXT_TOOLS: Set<string>;
 export declare function normalizeName(name: string): string;
 export declare function isContextTool(toolName: string): boolean;
@@ -24,7 +25,7 @@ export interface ContextToolTriggerLabels {
     workspace: string;
 }
 export declare const DEFAULT_CONTEXT_TOOL_TRIGGER_LABELS: Readonly<ContextToolTriggerLabels>;
-export declare function contextToolTrigger(part: ToolPart, labels?: Partial<ContextToolTriggerLabels>): {
+export declare function contextToolTrigger(call: ToolPart | ToolCallBlock, labels?: Partial<ContextToolTriggerLabels>): {
     title: string;
     subtitle: string;
 };

package/dist/core/turns/tools/tool-meta.js

@@ -1,4 +1,5 @@
 import { toolKind } from '../tool-kind.js';
+import { isToolCallBlock, toolPartOf } from '../../session-log/tool-call.js';
 import { humanizeSearchQuery } from './search-query.js';
 import { stripTrailingSlashes } from '../text-scan.js';
 export const CONTEXT_TOOLS = new Set(['read', 'glob', 'grep', 'list']);
@@ -100,7 +101,8 @@ export const DEFAULT_CONTEXT_TOOL_TRIGGER_LABELS = {
     worker: 'Worker',
     workspace: 'Workspace',
 };
-export function contextToolTrigger(part, labels = {}) {
+export function contextToolTrigger(call, labels = {}) {
+    const part = isToolCallBlock(call) ? toolPartOf(call) : call;
     const l = { ...DEFAULT_CONTEXT_TOOL_TRIGGER_LABELS, ...labels };
     const n = normalizeName(part.tool);
     const sub = getToolPrimaryArg(part);

package/dist/core/turns/tools/tool-outcome.d.ts

@@ -1,4 +1,5 @@
 import type { ToolPart } from '../../runtime/client.js';
+import type { ToolCallBlock } from '../../session-log/types.js';
 export interface ParsedJsonFailure {
     errorSummary: string;
     hint?: string;
@@ -9,7 +10,7 @@ export interface ParsedJsonFailure {
 export type ToolOutcome = 'ok' | 'partial' | 'failed';
 export declare function looksLikeError(text: string): boolean;
 export declare function isErrorOutput(output: string): boolean;
-export declare function partOutcome(part: Pick<ToolPart, 'state'>): ToolOutcome;
+export declare function partOutcome(call: Pick<ToolPart, 'state'> | ToolCallBlock): ToolOutcome;
 export declare function parseJsonFailure(output: string): ParsedJsonFailure | null;
 export declare function cleanErrorMessage(raw: string): string;
 export declare function formatJsonFailureOutput(output: string): string | null;

package/dist/core/turns/tools/tool-outcome.js

@@ -1,4 +1,5 @@
 import { jsonTail, stripErrorPrefixes } from '../text-scan.js';
+import { isToolCallBlock, toolPartOf } from '../../session-log/tool-call.js';
 function isJsonObject(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -19,7 +20,8 @@ export function looksLikeError(text) {
 export function isErrorOutput(output) {
     return !!output && (looksLikeError(output) || parseJsonFailure(output) !== null);
 }
-export function partOutcome(part) {
+export function partOutcome(call) {
+    const part = isToolCallBlock(call) ? toolPartOf(call) : call;
     const cached = OUTCOME_CACHE.get(part);
     if (cached && cached.state === part.state)
         return cached.outcome;

package/dist/core/turns/types.d.ts

@@ -79,7 +79,7 @@ export interface ToolInfo {
     subtitle?: string;
 }
 export interface TurnCostInfo {
-    cost: number;
+    cost: number | null;
     tokens: {
         input: number;
         output: number;

package/dist/core/warm-session-pool.d.ts

@@ -0,0 +1,29 @@
+export interface WarmPoolSession {
+    sessionId: string;
+}
+export interface WarmSessionPoolClient<Session extends WarmPoolSession, ClaimInput> {
+    ensure: (projectId: string, excludeSessionId?: string) => Promise<Session>;
+    claim: (projectId: string, input: ClaimInput) => Promise<unknown>;
+    read: (projectId: string, sessionId: string) => Promise<{
+        metadata?: unknown;
+    } | null>;
+}
+export interface WarmSessionPoolCoreOptions<Session extends WarmPoolSession, Send> {
+    fits: (session: Session, send: Send) => boolean;
+    sleep?: (ms: number) => Promise<void>;
+}
+export interface WarmSessionPoolCore<Session extends WarmPoolSession, Send, ClaimInput> {
+    ensure: (projectId: string, options?: {
+        excludeSessionId?: string;
+    }) => Promise<void>;
+    take: (projectId: string, send: Send, options: {
+        replenish: boolean;
+    }) => Session | null;
+    prime: (projectId: string, session: Session, input: ClaimInput) => Promise<boolean>;
+    dropBySessionId: (sessionId: string) => string | null;
+    revalidate: (projectId: string) => Promise<boolean>;
+    held: (projectId: string) => Session | null;
+    reset: () => void;
+    settled: () => Promise<void>;
+}
+export declare function createWarmSessionPool<Session extends WarmPoolSession, Send, ClaimInput>(client: WarmSessionPoolClient<Session, ClaimInput>, options: WarmSessionPoolCoreOptions<Session, Send>): WarmSessionPoolCore<Session, Send, ClaimInput>;

package/dist/core/warm-session-pool.js

@@ -0,0 +1,127 @@
+function isAmbiguousCreateFailure(code) {
+    return code === 'TIMEOUT' || code === 'request_deadline';
+}
+function errorCode(error) {
+    const code = isRecord(error) ? error.code : undefined;
+    return typeof code === 'string' ? code : undefined;
+}
+const isRecord = (value) => typeof value === 'object' && value !== null;
+function isWarmRow(row) {
+    const metadata = row?.metadata;
+    return !!isRecord(metadata) && metadata.warm === true;
+}
+const COMMIT_CONFIRM_ATTEMPTS = 5;
+const COMMIT_CONFIRM_DELAY_MS = 2_000;
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function confirmCommitted(probe, { attempts = COMMIT_CONFIRM_ATTEMPTS, delayMs = COMMIT_CONFIRM_DELAY_MS, sleep = wait, } = {}) {
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        if (attempt > 0)
+            await sleep(delayMs);
+        try {
+            if (await probe())
+                return true;
+        }
+        catch {
+        }
+    }
+    return false;
+}
+export function createWarmSessionPool(client, options) {
+    const ready = new Map();
+    const creating = new Set();
+    const taken = new Set();
+    const inFlight = new Set();
+    let generation = 0;
+    const runEnsure = (projectId, excludeSessionId, retriesLeft) => {
+        if (creating.has(projectId) || ready.has(projectId))
+            return Promise.resolve();
+        creating.add(projectId);
+        const startedIn = generation;
+        const run = (async () => {
+            let retryExclude = null;
+            try {
+                const session = await client.ensure(projectId, excludeSessionId);
+                if (startedIn !== generation)
+                    return;
+                if (taken.has(session.sessionId))
+                    retryExclude = session.sessionId;
+                else
+                    ready.set(projectId, session);
+            }
+            catch {
+            }
+            finally {
+                if (startedIn === generation)
+                    creating.delete(projectId);
+            }
+            if (retryExclude && retriesLeft > 0) {
+                await runEnsure(projectId, retryExclude, retriesLeft - 1);
+            }
+        })();
+        inFlight.add(run);
+        void run.finally(() => inFlight.delete(run));
+        return run;
+    };
+    return {
+        ensure: (projectId, opts) => runEnsure(projectId, opts?.excludeSessionId, 1),
+        take: (projectId, send, { replenish }) => {
+            const warm = ready.get(projectId);
+            if (!warm)
+                return null;
+            ready.delete(projectId);
+            taken.add(warm.sessionId);
+            if (replenish)
+                void runEnsure(projectId, warm.sessionId, 1);
+            return options.fits(warm, send) ? warm : null;
+        },
+        prime: async (projectId, warm, input) => {
+            try {
+                await client.claim(projectId, input);
+                return true;
+            }
+            catch (error) {
+                if (!isAmbiguousCreateFailure(errorCode(error)))
+                    return false;
+                return confirmCommitted(async () => !isWarmRow(await client.read(projectId, warm.sessionId)), options.sleep ? { sleep: options.sleep } : {});
+            }
+        },
+        dropBySessionId: (sessionId) => {
+            for (const [projectId, warm] of ready) {
+                if (warm.sessionId !== sessionId)
+                    continue;
+                ready.delete(projectId);
+                taken.add(sessionId);
+                return projectId;
+            }
+            return null;
+        },
+        revalidate: async (projectId) => {
+            const held = ready.get(projectId);
+            if (!held)
+                return false;
+            try {
+                if (isWarmRow(await client.read(projectId, held.sessionId)))
+                    return false;
+            }
+            catch {
+                return false;
+            }
+            if (ready.get(projectId)?.sessionId !== held.sessionId)
+                return false;
+            ready.delete(projectId);
+            taken.add(held.sessionId);
+            return true;
+        },
+        held: (projectId) => ready.get(projectId) ?? null,
+        reset: () => {
+            generation += 1;
+            ready.clear();
+            creating.clear();
+            taken.clear();
+        },
+        settled: async () => {
+            while (inFlight.size > 0)
+                await Promise.all([...inFlight]);
+        },
+    };
+}

package/dist/index.d.ts

@@ -30,8 +30,6 @@ export * from './core/http/authenticated-request.js';
 export * from './core/http/config.js';
 export * from './core/http/feature-flags.js';
 export * from './core/http/fresh-sessions.js';
-export * from './core/http/impersonation.js';
-export * from './core/http/instance-routes.js';
 export * from './core/http/runtime-errors.js';
 export * from './core/rest/platform-client/index.js';
 export * from './core/rest/projects-client/index.js';
@@ -41,6 +39,8 @@ export * from './core/attachments/prompt-attachments.js';
 export * from './core/runtime/client.js';
 export * from './core/runtime/attachment-part.js';
 export * from './core/session/index.js';
+export * from './core/session-log/index.js';
+export * from './core/warm-session-pool.js';
 export { createHttpSessionSyncController, loadHttpSessionHistory, type SessionSyncMessage, } from './core/session-sync/session-sync-controller.js';
 export * from './core/session-sync/saved-copy-store.js';
 export { type EmptyConversationInput, isEmptyConversation, savedCopyEmptyRoot, } from './core/session-sync/saved-transcript.js';