@usewhisper/sdk 3.10.0 → 3.10.1

package/adapters/ai-sdk.d.mts

@@ -0,0 +1,2434 @@
+import { z } from 'zod';
+
+type WhisperErrorCode = "INVALID_API_KEY" | "PROJECT_NOT_FOUND" | "PROJECT_AMBIGUOUS" | "RATE_LIMITED" | "TEMPORARY_UNAVAILABLE" | "NETWORK_ERROR" | "TIMEOUT" | "REQUEST_FAILED" | "MISSING_PROJECT" | "AUTH_IDENTITY_REQUIRED" | "AUTH_IDENTITY_INVALID" | "MISCONFIGURED_IDENTITY_MODE" | "VALIDATION_ERROR";
+declare class WhisperError extends Error {
+    code: WhisperErrorCode;
+    status?: number;
+    retryable: boolean;
+    hint?: string;
+    requestId?: string;
+    details?: unknown;
+    constructor(args: {
+        code: WhisperErrorCode;
+        message: string;
+        status?: number;
+        retryable?: boolean;
+        hint?: string;
+        requestId?: string;
+        details?: unknown;
+        cause?: unknown;
+    });
+}
+
+type MemoryKind$1 = "factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction" | "episodic" | "semantic" | "procedural";
+interface MemoryLatencyBreakdown$1 {
+    cache_ms: number;
+    embed_ms: number;
+    vector_ms: number;
+    lexical_ms: number;
+    merge_ms: number;
+    total_ms: number;
+}
+interface MemorySearchResult {
+    memory: {
+        id: string;
+        content: string;
+        type: string;
+        entities?: string[];
+        confidence?: number;
+        version?: number;
+        temporal?: {
+            document_date?: string | null;
+            event_date?: string | null;
+            valid_from?: string | null;
+            valid_until?: string | null;
+        };
+    };
+    similarity: number;
+    relations?: Array<Record<string, unknown>>;
+    chunk?: {
+        id: string;
+        content: string;
+        metadata?: Record<string, unknown>;
+    };
+}
+interface MemorySearchResponse$1 {
+    results: MemorySearchResult[];
+    count: number;
+    query: string;
+    trace_id?: string;
+    latency_ms?: number;
+    latency_breakdown?: MemoryLatencyBreakdown$1;
+    fallback?: "vector" | "lexical";
+    mode?: "fast" | "balanced" | "quality";
+    profile?: "fast" | "balanced" | "quality";
+    include_pending?: boolean;
+    pending_overlay_count?: number;
+    cache_hit?: boolean;
+}
+interface MemoryWriteAck$1 {
+    success: boolean;
+    mode?: "async" | "sync";
+    trace_id?: string;
+    memory_id?: string;
+    job_id?: string;
+    status_url?: string;
+    accepted_at?: string;
+    visibility_sla_ms?: number;
+    pending_visibility?: boolean;
+    semantic_status?: "pending" | "ready";
+    queued?: boolean;
+    event_id?: string;
+    created?: number;
+    errors?: string[];
+}
+type LearnIngestionProfile = "auto" | "repo" | "web_docs" | "pdf_layout" | "video_transcript" | "plain_text";
+type LearnStrategyOverride = "fixed" | "recursive" | "semantic" | "hierarchical" | "adaptive";
+type LearnSourceType = "github" | "web" | "playwright" | "pdf" | "local" | "slack" | "video";
+interface LearnConversationInput {
+    mode: "conversation";
+    project?: string;
+    user_id?: string;
+    session_id: string;
+    messages: Array<{
+        role: string;
+        content: string;
+        timestamp?: string;
+    }>;
+}
+interface LearnTextInput {
+    mode: "text";
+    project?: string;
+    title: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    namespace?: string;
+    options?: {
+        async?: boolean;
+        ingestion_profile?: LearnIngestionProfile;
+        strategy_override?: LearnStrategyOverride;
+        profile_config?: Record<string, unknown>;
+    };
+}
+interface LearnSourceInput {
+    mode: "source";
+    project?: string;
+    type: LearnSourceType;
+    name?: string;
+    metadata?: Record<string, string>;
+    owner?: string;
+    repo?: string;
+    branch?: string;
+    paths?: string[];
+    url?: string;
+    file_path?: string;
+    path?: string;
+    channel_ids?: string[];
+    since?: string;
+    token?: string;
+    auth_ref?: string;
+    platform?: "youtube" | "loom" | "generic";
+    language?: string;
+    options?: {
+        async?: boolean;
+        auto_index?: boolean;
+        ingestion_profile?: LearnIngestionProfile;
+        strategy_override?: LearnStrategyOverride;
+        profile_config?: Record<string, unknown>;
+        crawl_depth?: number;
+        include_paths?: string[];
+        exclude_paths?: string[];
+        glob?: string;
+        max_files?: number;
+        max_pages?: number;
+        extract_mode?: "text" | "structured" | "markdown";
+        workspace_id?: string;
+        allow_stt_fallback?: boolean;
+        max_duration_minutes?: number;
+        max_chunks?: number;
+    };
+}
+type LearnInput = LearnConversationInput | LearnTextInput | LearnSourceInput;
+interface LearnConversationResult {
+    success: true;
+    mode: "conversation";
+    project: string;
+    scope_mode: "user_session" | "session_only";
+    memories_created: number;
+    relations_created: number;
+    memories_invalidated: number;
+    errors?: string[];
+}
+interface LearnTextResult {
+    success: true;
+    mode: "text";
+    project: string;
+    status: "processing" | "completed";
+    job_id?: string | null;
+    chunks_indexed?: number;
+    source_id?: string | null;
+}
+interface LearnSourceResult {
+    success: true;
+    mode: "source";
+    project: string;
+    source_id: string;
+    status: string;
+    job_id?: string | null;
+    index_started: boolean;
+}
+type LearnResult = LearnConversationResult | LearnTextResult | LearnSourceResult;
+
+/**
+ * Whisper - Simple Memory Layer for AI Agents
+ *
+ * Two methods:
+ * - getContext(): Retrieve relevant context before LLM call
+ * - capture(): Extract and store memories after LLM response
+ *
+ * Zero magic - you control when to get context and when to capture
+ */
+
+interface WhisperOptions extends WhisperConfig {
+    /**
+     * Maximum context results to retrieve.
+     * Default: 10
+     */
+    contextLimit?: number;
+    /**
+     * Which memory types to use.
+     * Default: all 7 types
+     */
+    memoryTypes?: Array<"factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction">;
+    /**
+     * Prefix for context injection.
+     * Default: "Relevant context:"
+     */
+    contextPrefix?: string;
+    /**
+     * Extract structured memories before writing.
+     * Default: true
+     */
+    autoExtract?: boolean;
+    /**
+     * Minimum extraction confidence for auto-write.
+     * Default: 0.65
+     */
+    autoExtractMinConfidence?: number;
+    /**
+     * Maximum extracted memories to write per remember/capture call.
+     * Default: 5
+     */
+    maxMemoriesPerCapture?: number;
+}
+interface ContextResult {
+    context: string;
+    results: QueryResult["results"];
+    count: number;
+}
+interface RememberResult {
+    success: boolean;
+    memoryId?: string;
+    memoryIds?: string[];
+    extracted?: number;
+}
+/**
+ * Simple, transparent memory layer
+ *
+ * @example
+ * ```typescript
+ * import { Whisper } from '@usewhisper/sdk';
+ *
+ * const whisper = new Whisper({
+ *   apiKey: process.env.WHISPER_KEY,
+ *   project: 'my-app'
+ * });
+ *
+ * // BEFORE: Get relevant context
+ * const { context, results } = await whisper.getContext("What does user prefer?");
+ *
+ * // Inject context into your LLM prompt
+ * const prompt = `${context}\n\nUser: What does user prefer?`;
+ * const response = await llm.complete(prompt);
+ *
+ * // AFTER: Capture what happened
+ * await whisper.capture(response);
+ * // → Memories extracted & stored (async)
+ * ```
+ */
+declare class Whisper {
+    private client;
+    private runtimeClient;
+    private options;
+    private sessionId?;
+    private userId?;
+    constructor(options: WhisperOptions);
+    /**
+     * Set session ID for conversation tracking
+     */
+    session(sessionId: string): this;
+    /**
+     * Set user ID for user-specific memories
+     */
+    user(userId: string): this;
+    /**
+     * Get relevant context BEFORE your LLM call
+     *
+     * @param query - What you want to know / user question
+     * @returns Context string and raw results
+     *
+     * @example
+     * ```typescript
+     * const { context, results, count } = await whisper.getContext(
+     *   "What are user's preferences?",
+     *   { userId: "user-123" }
+     * );
+     *
+     * // Results: [
+     * //   { content: "User prefers dark mode", type: "preference", score: 0.95 },
+     * //   { content: "Allergic to nuts", type: "factual", score: 0.89 }
+     * // ]
+     * ```
+     */
+    getContext(query: string, options?: {
+        userId?: string;
+        sessionId?: string;
+        project?: string;
+        limit?: number;
+    }): Promise<ContextResult>;
+    /**
+     * Remember what happened AFTER your LLM response
+     *
+     * Fire-and-forget - doesn't block your response
+     *
+     * @param content - What your LLM responded with
+     * @returns Promise that resolves when stored (or fails silently)
+     *
+     * @example
+     * ```typescript
+     * const llmResponse = "I've set your theme to dark mode and removed nuts from recommendations.";
+     *
+     * await whisper.remember(llmResponse, { userId: "user-123" });
+     * // → Auto-extracts: "theme set to dark mode", "nut allergy"
+     * // → Stored as preferences
+     * ```
+     */
+    remember(content: string, options?: {
+        userId?: string;
+        sessionId?: string;
+        project?: string;
+    }): Promise<RememberResult>;
+    /**
+     * Alias for remember() - same thing
+     */
+    capture(content: string, options?: {
+        userId?: string;
+        sessionId?: string;
+        project?: string;
+    }): Promise<RememberResult>;
+    /**
+     * Capture from multiple messages (e.g., full conversation)
+     */
+    captureSession(messages: Array<{
+        role: string;
+        content: string;
+    }>, options?: {
+        userId?: string;
+        sessionId?: string;
+        project?: string;
+        auto_learn?: boolean;
+    }): Promise<{
+        success: boolean;
+        extracted: number;
+    }>;
+    /**
+     * Run a full agent turn with automatic memory read (before) + write (after).
+     */
+    runTurn(params: {
+        userMessage: string;
+        generate: (prompt: string) => Promise<string>;
+        userId?: string;
+        sessionId?: string;
+        project?: string;
+        limit?: number;
+        auto_learn?: boolean;
+    }): Promise<{
+        response: string;
+        context: string;
+        count: number;
+        extracted: number;
+    }>;
+    learn(input: LearnInput): Promise<LearnResult>;
+    /**
+     * Direct access to WhisperContext for advanced usage
+     */
+    raw(): WhisperContext;
+    private extractMemoryIdsFromBulkResponse;
+    private fallbackCaptureViaAddMemory;
+}
+
+type CompatMode = "fallback" | "strict";
+type OperationType = "search" | "writeAck" | "bulk" | "profile" | "session" | "query" | "get";
+interface TimeoutBudgets {
+    searchMs: number;
+    writeAckMs: number;
+    bulkMs: number;
+    profileMs: number;
+    sessionMs: number;
+}
+interface RetryPolicy {
+    maxAttemptsByOperation?: Partial<Record<OperationType, number>>;
+    retryableStatusCodes?: number[];
+    retryOnNetworkError?: boolean;
+    maxBackoffMs?: number;
+    baseBackoffMs?: number;
+}
+interface RuntimeRequestOptions {
+    endpoint: string;
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    body?: Record<string, unknown> | undefined;
+    headers?: Record<string, string> | undefined;
+    operation: OperationType;
+    idempotent?: boolean;
+    traceId?: string;
+    dedupeKeyExtra?: string;
+}
+interface RuntimeClientOptions {
+    apiKey: string;
+    baseUrl?: string;
+    sdkVersion?: string;
+    compatMode?: CompatMode;
+    timeouts?: Partial<TimeoutBudgets>;
+    retryPolicy?: RetryPolicy;
+    fetchImpl?: typeof fetch;
+}
+interface RuntimeResponse<T> {
+    data: T;
+    status: number;
+    traceId: string;
+}
+interface DiagnosticsRecord {
+    id: string;
+    startedAt: string;
+    endedAt: string;
+    traceId: string;
+    spanId: string;
+    operation: OperationType;
+    method: string;
+    endpoint: string;
+    status?: number;
+    durationMs: number;
+    success: boolean;
+    deduped?: boolean;
+    errorCode?: string;
+    errorMessage?: string;
+}
+
+type DiagnosticsSubscriber = (record: DiagnosticsRecord) => void;
+declare class DiagnosticsStore {
+    private readonly maxEntries;
+    private readonly records;
+    private readonly subscribers;
+    constructor(maxEntries?: number);
+    add(record: DiagnosticsRecord): void;
+    getLast(limit?: number): DiagnosticsRecord[];
+    snapshot(): {
+        total: number;
+        success: number;
+        failure: number;
+        avgDurationMs: number;
+        lastTraceId?: string;
+    };
+    subscribe(fn: DiagnosticsSubscriber): () => void;
+}
+
+interface QueuedWrite {
+    eventId: string;
+    project: string;
+    userId?: string;
+    sessionId?: string;
+    payload: {
+        content: string;
+        memory_type?: string;
+        user_id?: string;
+        session_id?: string;
+        agent_id?: string;
+        importance?: number;
+        confidence?: number;
+        metadata?: Record<string, unknown>;
+        document_date?: string;
+        event_date?: string;
+    };
+    createdAt: string;
+}
+interface QueueStore {
+    load(): Promise<QueuedWrite[]>;
+    save(items: QueuedWrite[]): Promise<void>;
+}
+interface WriteQueueStatus {
+    queued: number;
+    flushing: boolean;
+    lastFlushAt?: string;
+    lastFlushCount: number;
+}
+type FlushHandler = (items: QueuedWrite[]) => Promise<void>;
+declare class WriteQueue {
+    private readonly flushHandler;
+    private readonly store;
+    private readonly maxBatchSize;
+    private readonly flushIntervalMs;
+    private readonly maxAttempts;
+    private readonly queue;
+    private flushTimer;
+    private flushing;
+    private lastFlushAt?;
+    private lastFlushCount;
+    constructor(args: {
+        flushHandler: FlushHandler;
+        store?: QueueStore;
+        maxBatchSize?: number;
+        flushIntervalMs?: number;
+        maxAttempts?: number;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    status(): WriteQueueStatus;
+    enqueue(input: Omit<QueuedWrite, "eventId" | "createdAt"> & {
+        eventId?: string;
+    }): Promise<QueuedWrite>;
+    flush(): Promise<void>;
+    private makeEventId;
+    private bindProcessHooks;
+}
+
+declare class RuntimeClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly sdkVersion;
+    private readonly compatMode;
+    private readonly retryPolicy;
+    private readonly timeouts;
+    private readonly diagnostics;
+    private readonly inFlight;
+    private readonly sendApiKeyHeader;
+    private readonly fetchImpl;
+    constructor(options: RuntimeClientOptions, diagnostics?: DiagnosticsStore);
+    getDiagnosticsStore(): DiagnosticsStore;
+    getCompatMode(): CompatMode;
+    private timeoutFor;
+    private maxAttemptsFor;
+    private shouldRetryStatus;
+    private backoff;
+    private runtimeName;
+    private apiKeyOnlyPrefixes;
+    private shouldAttachApiKeyHeader;
+    private createRequestFingerprint;
+    request<T>(options: RuntimeRequestOptions): Promise<RuntimeResponse<T>>;
+    private performRequest;
+}
+
+interface SearchCacheKeyInput {
+    project: string;
+    userId?: string;
+    sessionId?: string;
+    query: string;
+    topK: number;
+    profile: string;
+    includePending: boolean;
+}
+declare class SearchResponseCache<T = unknown> {
+    private readonly ttlMs;
+    private readonly capacity;
+    private readonly byKey;
+    private readonly scopeIndex;
+    constructor(ttlMs?: number, capacity?: number);
+    makeScopeKey(project: string, userId?: string, sessionId?: string): string;
+    makeKey(input: SearchCacheKeyInput): string;
+    get(key: string): T | null;
+    set(key: string, scopeKey: string, value: T): void;
+    invalidateScope(scopeKey: string): number;
+    private evictIfNeeded;
+    private deleteByKey;
+}
+
+interface MemoryModuleOptions {
+    defaultProject?: string;
+    cacheEnabled?: boolean;
+    queueEnabled?: boolean;
+}
+declare class MemoryModule {
+    private readonly client;
+    private readonly cache;
+    private readonly queue;
+    private readonly options;
+    constructor(client: RuntimeClient, cache: SearchResponseCache<MemorySearchResponse$1>, queue: WriteQueue, options?: MemoryModuleOptions);
+    private resolveProject;
+    private invalidate;
+    add(params: {
+        project?: string;
+        content: string;
+        memory_type?: MemoryKind$1;
+        user_id?: string;
+        session_id?: string;
+        agent_id?: string;
+        importance?: number;
+        confidence?: number;
+        metadata?: Record<string, unknown>;
+        document_date?: string;
+        event_date?: string;
+        write_mode?: "async" | "sync";
+        async?: boolean;
+    }): Promise<MemoryWriteAck$1>;
+    addBulk(params: {
+        project?: string;
+        memories: Array<{
+            content: string;
+            memory_type?: MemoryKind$1;
+            user_id?: string;
+            session_id?: string;
+            agent_id?: string;
+            importance?: number;
+            confidence?: number;
+            metadata?: Record<string, unknown>;
+            document_date?: string;
+            event_date?: string;
+        }>;
+        write_mode?: "async" | "sync";
+        async?: boolean;
+    }): Promise<MemoryWriteAck$1>;
+    search(params: {
+        project?: string;
+        query: string;
+        user_id?: string;
+        session_id?: string;
+        top_k?: number;
+        memory_type?: MemoryKind$1;
+        profile?: "fast" | "balanced" | "quality";
+        include_pending?: boolean;
+    }): Promise<MemorySearchResponse$1>;
+    getUserProfile(params: {
+        project?: string;
+        user_id: string;
+        include_pending?: boolean;
+        memory_types?: string;
+    }): Promise<{
+        user_id: string;
+        memories: Array<Record<string, unknown>>;
+        count: number;
+    }>;
+    getSessionMemories(params: {
+        project?: string;
+        session_id: string;
+        include_pending?: boolean;
+        limit?: number;
+    }): Promise<{
+        memories: Array<Record<string, unknown>>;
+        count: number;
+    }>;
+    get(memoryId: string): Promise<{
+        memory: Record<string, unknown>;
+    }>;
+    update(memoryId: string, params: {
+        content: string;
+        reasoning?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    delete(memoryId: string): Promise<{
+        success: boolean;
+        deleted: string;
+    }>;
+    flag(params: {
+        memoryId: string;
+        reason: string;
+        severity?: "low" | "medium" | "high";
+    }): Promise<{
+        success: boolean;
+    }>;
+}
+
+type SessionState = "created" | "active" | "suspended" | "resumed" | "ended" | "archived";
+declare class SessionModule {
+    private readonly memory;
+    private readonly defaultProject?;
+    private readonly sessions;
+    constructor(memory: MemoryModule, defaultProject?: string | undefined);
+    private resolveProject;
+    private ensure;
+    start(params: {
+        userId: string;
+        project?: string;
+        sessionId?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        sessionId: string;
+        state: SessionState;
+        createdAt: string;
+    }>;
+    event(params: {
+        sessionId: string;
+        type: string;
+        content: string;
+        parentEventId?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        success: boolean;
+        eventId: string;
+        sequence: number;
+    }>;
+    suspend(params: {
+        sessionId: string;
+    }): Promise<{
+        sessionId: string;
+        state: SessionState;
+    }>;
+    resume(params: {
+        sessionId: string;
+    }): Promise<{
+        sessionId: string;
+        state: SessionState;
+    }>;
+    end(params: {
+        sessionId: string;
+    }): Promise<{
+        sessionId: string;
+        state: SessionState;
+    }>;
+    archive(params: {
+        sessionId: string;
+    }): Promise<{
+        sessionId: string;
+        state: SessionState;
+    }>;
+}
+
+declare class ProfileModule {
+    private readonly memory;
+    constructor(memory: MemoryModule);
+    getUserProfile(params: {
+        project?: string;
+        user_id: string;
+        include_pending?: boolean;
+        memory_types?: string;
+    }): Promise<{
+        user_id: string;
+        memories: Array<Record<string, unknown>>;
+        count: number;
+    }>;
+    getSessionMemories(params: {
+        project?: string;
+        session_id: string;
+        include_pending?: boolean;
+        limit?: number;
+    }): Promise<{
+        memories: Array<Record<string, unknown>>;
+        count: number;
+    }>;
+}
+
+declare class AnalyticsModule {
+    private readonly diagnostics;
+    private readonly queue;
+    constructor(diagnostics: DiagnosticsStore, queue: WriteQueue);
+    diagnosticsSnapshot(): {
+        total: number;
+        success: number;
+        failure: number;
+        avgDurationMs: number;
+        lastTraceId?: string;
+    };
+    queueStatus(): WriteQueueStatus;
+}
+
+interface AgentRunContext {
+    workspacePath?: string;
+    project?: string;
+    userId?: string;
+    sessionId?: string;
+    traceId?: string;
+    clientName?: string;
+}
+interface TurnInput {
+    userMessage: string;
+    taskSummary?: string;
+    touchedFiles?: string[];
+    toolContext?: string;
+}
+type WorkEventKind = "decision" | "constraint" | "outcome" | "failure" | "task_update" | "file_edit" | "tool_result";
+type WorkEventSalience = "low" | "medium" | "high";
+interface WorkEvent {
+    kind: WorkEventKind;
+    summary: string;
+    details?: string;
+    salience?: WorkEventSalience;
+    timestamp?: string;
+    filePaths?: string[];
+    toolName?: string;
+    success?: boolean;
+}
+interface PreparedTurn {
+    scope: AgentRunContext & {
+        project: string;
+        userId: string;
+        sessionId: string;
+    };
+    retrieval: {
+        primaryQuery: string;
+        taskFrameQuery: string | null;
+        warnings: string[];
+        degraded: boolean;
+        degradedReason?: string;
+        durationMs: number;
+        targetBudgetMs: number;
+        hardTimeoutMs: number;
+        branchStatus: Record<string, "ok" | "error" | "timeout" | "skipped">;
+        focusedScopeApplied: boolean;
+        focusedSourceIds: string[];
+        focusedFileHints: string[];
+        clientScoped: boolean;
+        fallbackUsed: boolean;
+        droppedBelowFloor: number;
+        dedupedCount: number;
+    };
+    context: string;
+    items: Array<{
+        id: string;
+        content: string;
+        type: "project" | "memory";
+        score: number;
+        sourceQuery: "primary" | "task_frame" | "bootstrap";
+        metadata?: Record<string, unknown>;
+    }>;
+}
+interface TurnCaptureResult {
+    success: boolean;
+    sessionIngested: boolean;
+    memoriesCreated: number;
+    relationsCreated: number;
+    invalidatedCount: number;
+    mergedCount: number;
+    droppedCount: number;
+    warnings: string[];
+}
+interface AgentRuntimeStatus {
+    clientName: string;
+    scope: {
+        project?: string;
+        userId?: string;
+        sessionId?: string;
+        source?: "explicit" | "workspace" | "config" | "generated";
+        warning?: string;
+    };
+    queue: {
+        queued: number;
+        flushing: boolean;
+        lastFlushAt?: string;
+        lastFlushCount: number;
+    };
+    retrieval: PreparedTurn["retrieval"] | null;
+    counters: {
+        mergedCount: number;
+        droppedCount: number;
+        bufferedLowSalience: number;
+        focusedPassHits: number;
+        fallbackTriggers: number;
+        floorDroppedCount: number;
+        injectedItemCount: number;
+        sourceScopedTurns: number;
+        broadScopedTurns: number;
+        totalTurns: number;
+    };
+}
+interface AgentRuntimeRankWeights {
+    focusedPassBonus?: number;
+    sourceMatchBonus?: number;
+    touchedFileBonus?: number;
+    clientMatchBonus?: number;
+    highSalienceBonus?: number;
+    mediumSalienceBonus?: number;
+    staleBroadPenalty?: number;
+    unrelatedClientPenalty?: number;
+    lowSaliencePenalty?: number;
+}
+interface AgentRuntimeSourceActivityOptions {
+    maxTurns?: number;
+    maxIdleMs?: number;
+    decayAfterTurns?: number;
+    decayAfterIdleMs?: number;
+    evictOnTaskSwitch?: boolean;
+}
+interface AgentRuntimeRetrievalOptions {
+    focusedTopK?: number;
+    broadTopK?: number;
+    minFocusedResults?: number;
+    minFocusedTopScore?: number;
+    minProjectScore?: number;
+    minMemoryScore?: number;
+    rankWeights?: AgentRuntimeRankWeights;
+    sourceActivity?: AgentRuntimeSourceActivityOptions;
+}
+interface AgentRuntimeOptions extends AgentRunContext {
+    topK?: number;
+    maxTokens?: number;
+    targetRetrievalMs?: number;
+    hardRetrievalTimeoutMs?: number;
+    bindingStorePath?: string;
+    recentWorkLimit?: number;
+    retrieval?: AgentRuntimeRetrievalOptions;
+}
+interface QueueStatus {
+    queued: number;
+    flushing: boolean;
+    lastFlushAt?: string;
+    lastFlushCount: number;
+}
+interface RuntimeAdapter {
+    resolveProject(project?: string): Promise<Project>;
+    query(params: QueryParams): Promise<QueryResult>;
+    ingestSession(params: {
+        project?: string;
+        session_id: string;
+        user_id?: string;
+        messages: Array<{
+            role: string;
+            content: string;
+            timestamp: string;
+        }>;
+        async?: boolean;
+        write_mode?: "async" | "sync";
+    }): Promise<{
+        success: boolean;
+        memories_created: number;
+        relations_created: number;
+        memories_invalidated: number;
+        errors?: string[];
+    } & MemoryWriteAck$1>;
+    getSessionMemories(params: {
+        project?: string;
+        session_id: string;
+        include_pending?: boolean;
+        limit?: number;
+    }): Promise<{
+        memories: Array<Record<string, unknown>>;
+        count: number;
+    }>;
+    getUserProfile(params: {
+        project?: string;
+        user_id: string;
+        include_pending?: boolean;
+        memory_types?: string;
+    }): Promise<{
+        user_id: string;
+        memories: Array<Record<string, unknown>>;
+        count: number;
+    }>;
+    searchMemories(params: {
+        project?: string;
+        query: string;
+        user_id?: string;
+        session_id?: string;
+        top_k?: number;
+        memory_type?: MemoryKind$1;
+        profile?: "fast" | "balanced" | "quality";
+        include_pending?: boolean;
+    }): Promise<MemorySearchResponse$1>;
+    addMemory(params: {
+        project?: string;
+        content: string;
+        memory_type?: MemoryKind$1;
+        user_id?: string;
+        session_id?: string;
+        importance?: number;
+        confidence?: number;
+        metadata?: Record<string, unknown>;
+        event_date?: string;
+        write_mode?: "async" | "sync";
+        async?: boolean;
+    }): Promise<MemoryWriteAck$1>;
+    queueStatus(): QueueStatus;
+    flushQueue(): Promise<void>;
+}
+declare class WhisperAgentRuntime {
+    private readonly args;
+    private readonly bindingStore;
+    private readonly focusedTopK;
+    private readonly broadTopK;
+    private readonly maxTokens;
+    private readonly targetRetrievalMs;
+    private readonly hardRetrievalTimeoutMs;
+    private readonly recentWorkLimit;
+    private readonly baseContext;
+    private readonly clientName;
+    private readonly minFocusedResults;
+    private readonly minFocusedTopScore;
+    private readonly minProjectScore;
+    private readonly minMemoryScore;
+    private readonly rankWeights;
+    private readonly sourceActivityOptions;
+    private bindings;
+    private touchedFiles;
+    private recentWork;
+    private recentSourceActivity;
+    private bufferedLowSalience;
+    private lastPreparedTurn;
+    private mergedCount;
+    private droppedCount;
+    private focusedPassHits;
+    private fallbackTriggers;
+    private floorDroppedCount;
+    private injectedItemCount;
+    private sourceScopedTurns;
+    private broadScopedTurns;
+    private totalTurns;
+    private currentTurn;
+    private lastTaskSummary;
+    private lastScope;
+    constructor(args: {
+        baseContext: AgentRunContext;
+        options: AgentRuntimeOptions;
+        adapter: RuntimeAdapter;
+    });
+    private getBindings;
+    private pushTouchedFiles;
+    private pushWorkEvent;
+    noteSourceActivity(sourceIds?: string[]): void;
+    private refreshTaskSummary;
+    private activeSourceIds;
+    private focusedScope;
+    private exactFileMetadataFilter;
+    private makeTaskFrameQuery;
+    private resolveScope;
+    private runBranch;
+    private contextItems;
+    private memoryItems;
+    private stableItemKey;
+    private metadataStrings;
+    private hasSourceMatch;
+    private hasFileMatch;
+    private hasClientMatch;
+    private salienceAdjustment;
+    private narrowFocusedMemories;
+    private applyRelevanceFloor;
+    private rerank;
+    private buildContext;
+    bootstrap(context?: Partial<AgentRunContext>): Promise<PreparedTurn>;
+    beforeTurn(input: TurnInput, context?: Partial<AgentRunContext>): Promise<PreparedTurn>;
+    recordWork(event: WorkEvent, context?: Partial<AgentRunContext>): Promise<MemoryWriteAck$1 | {
+        success: true;
+        buffered: true;
+    }>;
+    private resolveLearningScope;
+    afterTurn(input: TurnInput & {
+        assistantMessage: string;
+        auto_learn?: boolean;
+    }, context?: Partial<AgentRunContext>): Promise<TurnCaptureResult>;
+    flush(reason?: string, context?: Partial<AgentRunContext>): Promise<AgentRuntimeStatus>;
+    status(): AgentRuntimeStatus;
+}
+
+type WhisperIdentityMode = "demo-local" | "app-identity";
+type WhisperEnvironment = "local" | "staging" | "production";
+interface WhisperResolvedIdentity {
+    userId: string;
+    sessionId?: string;
+}
+interface WhisperPreflightCheck {
+    check: string;
+    ok: boolean;
+    message: string;
+    hint?: string;
+}
+interface WhisperPreflightResult {
+    ok: boolean;
+    checks: WhisperPreflightCheck[];
+    requestId: string;
+    identityMode: WhisperIdentityMode;
+    environment: WhisperEnvironment;
+}
+interface WhisperClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+    project?: string;
+    identityMode?: WhisperIdentityMode;
+    getIdentity?: () => WhisperResolvedIdentity | Promise<WhisperResolvedIdentity>;
+    environment?: WhisperEnvironment;
+    strictIdentityMode?: boolean;
+    compatMode?: CompatMode;
+    fetch?: typeof fetch;
+    timeouts?: Partial<TimeoutBudgets>;
+    retryPolicy?: RetryPolicy;
+    cache?: {
+        enabled?: boolean;
+        ttlMs?: number;
+        capacity?: number;
+    };
+    queue?: {
+        enabled?: boolean;
+        maxBatchSize?: number;
+        flushIntervalMs?: number;
+        maxAttempts?: number;
+        persistence?: "memory" | "storage" | "file";
+        filePath?: string;
+    };
+    telemetry?: {
+        enabled?: boolean;
+        maxEntries?: number;
+    };
+}
+interface RunContext {
+    project?: string;
+    userId?: string;
+    sessionId?: string;
+    traceId?: string;
+}
+declare class WhisperClient {
+    private readonly config;
+    readonly diagnostics: {
+        getLast: (limit?: number) => ReturnType<DiagnosticsStore["getLast"]>;
+        subscribe: (fn: Parameters<DiagnosticsStore["subscribe"]>[0]) => ReturnType<DiagnosticsStore["subscribe"]>;
+        snapshot: () => ReturnType<DiagnosticsStore["snapshot"]>;
+    };
+    readonly queue: {
+        flush: () => Promise<void>;
+        status: () => ReturnType<WriteQueue["status"]>;
+    };
+    readonly memory: {
+        add: (params: Parameters<MemoryModule["add"]>[0]) => Promise<MemoryWriteAck$1>;
+        addBulk: (params: Parameters<MemoryModule["addBulk"]>[0]) => Promise<MemoryWriteAck$1>;
+        search: (params: Parameters<MemoryModule["search"]>[0]) => Promise<MemorySearchResponse$1>;
+        get: (memoryId: string) => Promise<{
+            memory: Record<string, unknown>;
+        }>;
+        getUserProfile: (params: Parameters<MemoryModule["getUserProfile"]>[0]) => ReturnType<MemoryModule["getUserProfile"]>;
+        getSessionMemories: (params: Parameters<MemoryModule["getSessionMemories"]>[0]) => ReturnType<MemoryModule["getSessionMemories"]>;
+        update: (memoryId: string, params: {
+            content: string;
+            reasoning?: string;
+        }) => Promise<{
+            success: boolean;
+        }>;
+        delete: (memoryId: string) => Promise<{
+            success: boolean;
+            deleted: string;
+        }>;
+        flag: (params: {
+            memoryId: string;
+            reason: string;
+            severity?: "low" | "medium" | "high";
+        }) => Promise<{
+            success: boolean;
+        }>;
+    };
+    readonly session: {
+        start: (params: Parameters<SessionModule["start"]>[0]) => ReturnType<SessionModule["start"]>;
+        event: (params: Parameters<SessionModule["event"]>[0]) => ReturnType<SessionModule["event"]>;
+        suspend: (params: Parameters<SessionModule["suspend"]>[0]) => ReturnType<SessionModule["suspend"]>;
+        resume: (params: Parameters<SessionModule["resume"]>[0]) => ReturnType<SessionModule["resume"]>;
+        end: (params: Parameters<SessionModule["end"]>[0]) => ReturnType<SessionModule["end"]>;
+    };
+    readonly profile: {
+        getUserProfile: (params: Parameters<ProfileModule["getUserProfile"]>[0]) => ReturnType<ProfileModule["getUserProfile"]>;
+        getSessionMemories: (params: Parameters<ProfileModule["getSessionMemories"]>[0]) => ReturnType<ProfileModule["getSessionMemories"]>;
+    };
+    readonly analytics: {
+        diagnosticsSnapshot: () => ReturnType<AnalyticsModule["diagnosticsSnapshot"]>;
+        queueStatus: () => ReturnType<AnalyticsModule["queueStatus"]>;
+    };
+    private readonly runtimeClient;
+    private readonly diagnosticsStore;
+    private readonly searchCache;
+    private readonly writeQueue;
+    private readonly memoryModule;
+    private readonly sessionModule;
+    private readonly profileModule;
+    private readonly analyticsModule;
+    private readonly projectRefToId;
+    private readonly identityMode;
+    private readonly environment;
+    private readonly strictIdentityMode;
+    private readonly getIdentity?;
+    private projectCache;
+    private projectCacheExpiresAt;
+    constructor(config: WhisperClientConfig);
+    private enforceIdentityModeGuardrail;
+    private toWhisperError;
+    private runOrThrow;
+    private resolveIdentityOverride;
+    private withIdentity;
+    private withSessionIdentity;
+    static fromEnv(overrides?: Partial<WhisperClientConfig>): WhisperClient;
+    private createQueueStore;
+    private defaultQueuePersistence;
+    private defaultQueueFilePath;
+    private getRequiredProject;
+    private refreshProjectCache;
+    private fetchResolvedProject;
+    resolveProject(projectRef?: string): Promise<Project>;
+    preflight(options?: {
+        project?: string;
+        requireIdentity?: boolean;
+    }): Promise<WhisperPreflightResult>;
+    query(params: QueryParams): Promise<QueryResult>;
+    ingestSession(params: {
+        project?: string;
+        session_id: string;
+        user_id?: string;
+        messages: Array<{
+            role: string;
+            content: string;
+            timestamp: string;
+        }>;
+        async?: boolean;
+        write_mode?: "async" | "sync";
+    }): Promise<{
+        success: boolean;
+        memories_created: number;
+        relations_created: number;
+        memories_invalidated: number;
+        errors?: string[];
+    } & MemoryWriteAck$1>;
+    learn(params: LearnInput): Promise<LearnResult>;
+    createAgentRuntime(options?: AgentRuntimeOptions): WhisperAgentRuntime;
+    withRunContext(context: RunContext): {
+        memory: {
+            add: (params: Omit<Parameters<MemoryModule["add"]>[0], "project" | "user_id" | "session_id"> & {
+                project?: string;
+                user_id?: string;
+                session_id?: string;
+                memory_type?: MemoryKind$1;
+            }) => Promise<MemoryWriteAck$1>;
+            search: (params: Omit<Parameters<MemoryModule["search"]>[0], "project" | "user_id" | "session_id"> & {
+                project?: string;
+                user_id?: string;
+                session_id?: string;
+            }) => Promise<MemorySearchResponse$1>;
+        };
+        session: {
+            event: (params: Omit<Parameters<SessionModule["event"]>[0], "sessionId"> & {
+                sessionId?: string;
+            }) => Promise<{
+                success: boolean;
+                eventId: string;
+                sequence: number;
+            }>;
+        };
+        learn: (params: LearnInput) => Promise<LearnResult>;
+        queue: {
+            flush: () => Promise<void>;
+            status: () => ReturnType<WriteQueue["status"]>;
+        };
+        diagnostics: {
+            getLast: (limit?: number) => ReturnType<DiagnosticsStore["getLast"]>;
+            subscribe: (fn: Parameters<DiagnosticsStore["subscribe"]>[0]) => ReturnType<DiagnosticsStore["subscribe"]>;
+            snapshot: () => ReturnType<DiagnosticsStore["snapshot"]>;
+        };
+    };
+    deleteSource(sourceId: string): Promise<{
+        deleted: boolean;
+        id: string;
+        restore_until: string;
+    }>;
+    extractMemories(params: {
+        project: string;
+        message: string;
+    }): Promise<{
+        explicit: unknown[];
+        implicit: unknown[];
+        all: unknown[];
+    }>;
+    shutdown(): Promise<void>;
+}
+
+interface AgentMiddlewareConfig extends WhisperOptions {
+    /**
+     * Build the prompt passed to the model.
+     */
+    promptBuilder?: (params: {
+        context: string;
+        userMessage: string;
+    }) => string;
+}
+interface AgentTurnParams {
+    userMessage: string;
+    userId?: string;
+    sessionId?: string;
+    project?: string;
+    contextLimit?: number;
+    auto_learn?: boolean;
+}
+interface AgentTurnResult {
+    prompt: string;
+    context: string;
+    contextCount: number;
+}
+interface WrappedGenerateResult {
+    response: string;
+    prompt: string;
+    context: string;
+    contextCount: number;
+    extracted: number;
+}
+/**
+ * Drop-in middleware for existing AI agents.
+ *
+ * Typical flow:
+ * 1) beforeTurn -> retrieve context
+ * 2) call your model
+ * 3) afterTurn -> store memories
+ */
+declare class WhisperAgentMiddleware {
+    private readonly whisper;
+    private readonly promptBuilder;
+    constructor(config: AgentMiddlewareConfig);
+    beforeTurn(params: AgentTurnParams): Promise<AgentTurnResult>;
+    afterTurn(params: {
+        userMessage: string;
+        assistantMessage: string;
+        userId?: string;
+        sessionId?: string;
+        project?: string;
+        auto_learn?: boolean;
+    }): Promise<{
+        success: boolean;
+        extracted: number;
+    }>;
+    wrapGenerate(params: AgentTurnParams & {
+        generate: (prompt: string) => Promise<string>;
+    }): Promise<WrappedGenerateResult>;
+    raw(): Whisper;
+}
+declare function createAgentMiddleware(config: AgentMiddlewareConfig): WhisperAgentMiddleware;
+
+interface LangChainMemoryAdapterOptions {
+    project?: string;
+    userId: string;
+    sessionId?: string;
+    memoryKey?: string;
+    topK?: number;
+    profile?: "fast" | "balanced" | "quality";
+}
+/**
+ * Lightweight adapter matching LangChain memory contract shape.
+ * Compatible with BaseMemory-style integrations:
+ * - loadMemoryVariables
+ * - saveContext
+ * - clear
+ */
+declare class LangChainMemoryAdapter {
+    private readonly client;
+    private readonly options;
+    readonly memoryKeys: string[];
+    private readonly memoryKey;
+    constructor(client: WhisperClient, options: LangChainMemoryAdapterOptions);
+    loadMemoryVariables(_inputValues: Record<string, unknown>): Promise<Record<string, string>>;
+    saveContext(inputValues: Record<string, unknown>, outputValues: Record<string, unknown>): Promise<void>;
+    clear(): Promise<void>;
+}
+declare function createLangChainMemoryAdapter(client: WhisperClient, options: LangChainMemoryAdapterOptions): LangChainMemoryAdapter;
+
+interface LangGraphCheckpointConfig {
+    configurable: {
+        thread_id: string;
+        checkpoint_ns?: string;
+        checkpoint_id?: string;
+    };
+}
+interface LangGraphCheckpointTuple {
+    config: LangGraphCheckpointConfig;
+    checkpoint: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    parent_config?: LangGraphCheckpointConfig | null;
+}
+interface LangGraphCheckpointListOptions {
+    limit?: number;
+    before?: {
+        checkpointId?: string;
+        updatedAt?: string;
+    };
+    sort?: "asc" | "desc";
+    filter?: {
+        checkpointNs?: string;
+        metadata?: Record<string, unknown>;
+    };
+}
+interface LangGraphCheckpointSearchOptions {
+    threadId: string;
+    query: string;
+    checkpointNs?: string;
+    topK?: number;
+    includePending?: boolean;
+    profile?: "fast" | "balanced" | "quality";
+}
+interface LangGraphCheckpointAdapterOptions {
+    project?: string;
+    userIdPrefix?: string;
+    defaultCheckpointNs?: string;
+}
+/**
+ * LangGraph checkpoint adapter over Whisper memory APIs.
+ * Phase 5a: get/put/list.
+ * Phase 5b: checkpoint_ns fidelity, richer list/search filtering, schema-hard parsing.
+ */
+declare class LangGraphCheckpointAdapter {
+    private readonly client;
+    private readonly localByKey;
+    private readonly localByThread;
+    private readonly options;
+    constructor(client: WhisperClient, options?: LangGraphCheckpointAdapterOptions);
+    private getUserId;
+    private resolveCheckpointNs;
+    private makeLocalKey;
+    private normalizeTuple;
+    private parseCheckpointTupleFromRow;
+    private upsertLocal;
+    private mergeWithLocal;
+    private applyListFilters;
+    private fetchThreadRecords;
+    get(config: LangGraphCheckpointConfig): Promise<LangGraphCheckpointTuple | undefined>;
+    put(config: LangGraphCheckpointConfig, checkpoint: Record<string, unknown>, metadata?: Record<string, unknown>, parentConfig?: LangGraphCheckpointConfig | null): Promise<LangGraphCheckpointConfig>;
+    list(config: LangGraphCheckpointConfig, options?: LangGraphCheckpointListOptions): Promise<LangGraphCheckpointTuple[]>;
+    search(params: LangGraphCheckpointSearchOptions): Promise<LangGraphCheckpointTuple[]>;
+}
+declare function createLangGraphCheckpointAdapter(client: WhisperClient, options?: LangGraphCheckpointAdapterOptions): LangGraphCheckpointAdapter;
+
+interface WithWhisperOptions extends Partial<Omit<WhisperClientConfig, "apiKey">> {
+    apiKey?: string;
+    client?: WhisperClient;
+    project?: string;
+    topK?: number;
+    contextPrefix?: string;
+    bestEffort?: boolean;
+    warn?: (message: string) => void;
+}
+/**
+ * Framework adapter that augments model inputs with Whisper context.
+ * Works with model objects exposing `generate` / `stream` / `doGenerate` / `doStream`.
+ */
+declare function withWhisper<T extends Record<string, unknown> | ((...args: any[]) => any)>(model: T, options?: WithWhisperOptions): T;
+
+interface WhisperToolsOptions extends Partial<Omit<WhisperClientConfig, "apiKey">> {
+    apiKey?: string;
+    client?: WhisperClient;
+    project?: string;
+    searchTopK?: number;
+}
+interface WhisperToolDefinition<TInput, TResult> {
+    description: string;
+    inputSchema: z.ZodType<TInput>;
+    execute: (input: TInput) => Promise<TResult>;
+}
+type SearchInput = {
+    q: string;
+    project?: string;
+    topK?: number;
+    userId?: string;
+    sessionId?: string;
+};
+type RememberInput = {
+    content: string;
+    project?: string;
+    memoryType?: "factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction";
+    userId?: string;
+    sessionId?: string;
+    metadata?: Record<string, unknown>;
+};
+declare function whisperTools(config?: WhisperToolsOptions): {
+    whisper_search: WhisperToolDefinition<SearchInput, {
+        context: string;
+        total: number;
+        results: Array<{
+            id: string;
+            score: number;
+            source: string;
+            snippet: string;
+        }>;
+    }>;
+    whisper_remember: WhisperToolDefinition<RememberInput, {
+        success: boolean;
+    }>;
+    whisper_preflight: WhisperToolDefinition<{
+        project?: string;
+        requireIdentity?: boolean;
+    }, WhisperPreflightResult>;
+};
+
+type ChatMessage = {
+    role: string;
+    content: unknown;
+};
+type ChatCompletionPayload = {
+    model?: string;
+    messages?: ChatMessage[];
+    user?: string;
+    [key: string]: unknown;
+};
+type MemoryRouterFallbackReason = "none" | "no_user_prompt" | "memory_query_failed";
+interface MemoryRouterTrace {
+    providerUrl: string;
+    requestId: string;
+    usedMemory: boolean;
+    fallbackReason: MemoryRouterFallbackReason;
+    providerStatus?: number;
+    model?: string;
+}
+interface MemoryRouterResult<T = unknown> {
+    status: number;
+    data: T;
+    trace: MemoryRouterTrace;
+}
+interface MemoryRouterConfig extends Partial<Omit<WhisperClientConfig, "apiKey">> {
+    apiKey?: string;
+    client?: WhisperClient;
+    project?: string;
+    providerBaseUrl: string;
+    providerApiKey?: string;
+    providerHeaders?: Record<string, string>;
+    routePath?: string;
+    beta?: boolean;
+    bestEffort?: boolean;
+    contextPrefix?: string;
+    logger?: (trace: MemoryRouterTrace) => void;
+}
+declare class WhisperMemoryRouter {
+    private readonly config;
+    private readonly providerUrl;
+    private readonly fetchImpl;
+    private client;
+    private lastTrace;
+    constructor(config: MemoryRouterConfig);
+    private getClient;
+    getLastTrace(): MemoryRouterTrace | null;
+    chatCompletions<T = unknown>(payload: ChatCompletionPayload): Promise<MemoryRouterResult<T>>;
+}
+declare function createMemoryRouter(config: MemoryRouterConfig): WhisperMemoryRouter;
+
+interface MemoryGraphNode {
+    id: string;
+    label?: string;
+    memory_type?: string;
+}
+interface MemoryGraphEdge {
+    source: string;
+    target: string;
+    type?: string;
+}
+interface MemoryGraphPayload {
+    nodes: MemoryGraphNode[];
+    edges: MemoryGraphEdge[];
+}
+/**
+ * Convert memory graph payload to Mermaid flowchart syntax.
+ * Useful for quick visualization in docs/dashboards.
+ */
+declare function memoryGraphToMermaid(graph: MemoryGraphPayload): string;
+
+interface WhisperConfig {
+    apiKey: string;
+    baseUrl?: string;
+    project?: string;
+    timeoutMs?: number;
+    retry?: {
+        maxAttempts?: number;
+        baseDelayMs?: number;
+        maxDelayMs?: number;
+    };
+}
+interface QueryParams {
+    project?: string;
+    query: string;
+    top_k?: number;
+    threshold?: number;
+    chunk_types?: string[];
+    source_ids?: string[];
+    metadata_filter?: Record<string, any>;
+    hybrid?: boolean;
+    vector_weight?: number;
+    bm25_weight?: number;
+    rerank?: boolean;
+    include_memories?: boolean;
+    user_id?: string;
+    session_id?: string;
+    agent_id?: string;
+    include_graph?: boolean;
+    graph_depth?: number;
+    max_tokens?: number;
+    compress?: boolean;
+    compression_strategy?: "summarize" | "extract" | "delta" | "adaptive";
+    use_cache?: boolean;
+    include_parent_content?: boolean;
+    retrieval_profile?: "legacy" | "precision_v1";
+}
+interface QueryResult {
+    results: Array<{
+        id: string;
+        content: string;
+        score: number;
+        metadata: Record<string, any>;
+        source: string;
+        document: string;
+        type: string;
+        retrieval_source: string;
+    }>;
+    context: string;
+    meta: {
+        query: string;
+        total: number;
+        latency_ms: number;
+        cache_hit: boolean;
+        tokens_used: number;
+        context_hash: string;
+        source_scope?: {
+            mode: "none" | "explicit" | "auto";
+            source_ids: string[];
+            host?: string;
+            matched_sources?: number;
+        };
+        profile?: string;
+        retrieval_profile?: "legacy" | "precision_v1";
+        compression?: any;
+        timing?: {
+            cache_check_ms?: number;
+            embed_ms?: number;
+            vector_ms?: number;
+            fts_ms?: number;
+            rerank_ms?: number;
+            enrich_ms?: number;
+            pack_ms?: number;
+            cache_set_ms?: number;
+            total_ms?: number;
+            [key: string]: number | undefined;
+        };
+    };
+}
+interface Project {
+    id: string;
+    orgId: string;
+    name: string;
+    slug: string;
+    description?: string;
+    settings?: Record<string, any>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface Source {
+    id: string;
+    projectId: string;
+    name: string;
+    connectorType: string;
+    config: Record<string, any>;
+    status: string;
+    syncSchedule?: string;
+    lastSyncAt?: string;
+    syncError?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface VideoSourceMetadata {
+    source_kind: "video";
+    video_url: string;
+    platform: "youtube" | "loom" | "generic";
+    duration_seconds?: number;
+    published_at?: string;
+    channel_or_author?: string;
+}
+interface VideoIngestionStatus {
+    source_id: string;
+    status: string;
+    stage: "extracting" | "transcribing" | "segmenting" | "enriching" | "indexing" | "completed" | "failed";
+    sync_job_id?: string | null;
+    progress?: {
+        current: number;
+        total: number;
+        message: string;
+    } | null;
+    duration_seconds?: number | null;
+    chunks_indexed?: number | null;
+    decisions_detected?: number | null;
+    entities_extracted?: string[];
+    last_error?: string | null;
+    updated_at?: string;
+}
+type CanonicalSourceType = "github" | "web" | "playwright" | "pdf" | "local" | "slack" | "video";
+interface CanonicalSourceCreateParams {
+    type: CanonicalSourceType;
+    name?: string;
+    auto_index?: boolean;
+    metadata?: Record<string, string>;
+    ingestion_profile?: "auto" | "repo" | "web_docs" | "pdf_layout" | "video_transcript" | "plain_text";
+    strategy_override?: "fixed" | "recursive" | "semantic" | "hierarchical" | "adaptive";
+    profile_config?: Record<string, any>;
+    owner?: string;
+    repo?: string;
+    branch?: string;
+    paths?: string[];
+    url?: string;
+    crawl_depth?: number;
+    include_paths?: string[];
+    exclude_paths?: string[];
+    file_path?: string;
+    path?: string;
+    glob?: string;
+    max_files?: number;
+    max_pages?: number;
+    extract_mode?: "text" | "structured" | "markdown";
+    workspace_id?: string;
+    channel_ids?: string[];
+    since?: string;
+    token?: string;
+    auth_ref?: string;
+    platform?: "youtube" | "loom" | "generic";
+    language?: string;
+    allow_stt_fallback?: boolean;
+    max_duration_minutes?: number;
+    max_chunks?: number;
+}
+interface CanonicalSourceCreateResult {
+    source_id: string;
+    status: "queued" | "indexing" | "ready" | "failed";
+    job_id: string | null;
+    index_started: boolean;
+    warnings: string[];
+}
+interface Memory {
+    id: string;
+    projectId: string;
+    content: string;
+    memoryType: "factual" | "episodic" | "semantic" | "procedural";
+    userId?: string;
+    sessionId?: string;
+    agentId?: string;
+    importance: number;
+    metadata: Record<string, any>;
+    accessCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+type MemoryKind = "factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction";
+interface ExtractedMemory {
+    content: string;
+    memoryType: MemoryKind;
+    entityMentions: string[];
+    eventDate: string | null;
+    confidence: number;
+    reasoning?: string;
+    inferred?: boolean;
+}
+interface MemoryExtractionResult {
+    explicit: ExtractedMemory[];
+    implicit: ExtractedMemory[];
+    all: ExtractedMemory[];
+    extractionMethod: "pattern" | "inference" | "hybrid" | "skipped";
+    latencyMs: number;
+}
+interface MemoryLatencyBreakdown {
+    cache_ms: number;
+    embed_ms: number;
+    vector_ms: number;
+    lexical_ms: number;
+    merge_ms: number;
+    total_ms: number;
+}
+interface MemorySearchResponse {
+    results: Array<{
+        memory: {
+            id: string;
+            content: string;
+            type: string;
+            entities?: string[];
+            confidence?: number;
+            version?: number;
+            temporal?: {
+                document_date?: string | null;
+                event_date?: string | null;
+                valid_from?: string | null;
+                valid_until?: string | null;
+            };
+        };
+        chunk?: {
+            id: string;
+            content: string;
+            metadata?: Record<string, any>;
+        };
+        similarity: number;
+        relations?: any[];
+    }>;
+    count: number;
+    query: string;
+    trace_id?: string;
+    question_date?: string;
+    latency_ms?: number;
+    latency_breakdown?: MemoryLatencyBreakdown;
+    fallback?: "vector" | "lexical";
+    mode?: "fast" | "balanced" | "quality";
+    profile?: "fast" | "balanced" | "quality";
+    include_pending?: boolean;
+    pending_overlay_count?: number;
+}
+interface MemoryWriteAck {
+    success: boolean;
+    mode?: "async" | "sync";
+    trace_id?: string;
+    job_id?: string;
+    status_url?: string;
+    accepted_at?: string;
+    visibility_sla_ms?: number;
+    pending_visibility?: boolean;
+    [key: string]: any;
+}
+interface MemoryWriteResult {
+    id: string;
+    success: boolean;
+    path: "sota" | "legacy";
+    fallback_used: boolean;
+    mode?: "async" | "sync";
+    memory_id?: string;
+    job_id?: string;
+    status_url?: string;
+    accepted_at?: string;
+    visibility_sla_ms?: number;
+    pending_visibility?: boolean;
+    semantic_status?: "pending" | "ready";
+}
+declare class WhisperContext {
+    private apiKey;
+    private baseUrl;
+    private defaultProject?;
+    private timeoutMs;
+    private retryConfig;
+    private runtimeClient;
+    private projectRefToId;
+    private projectCache;
+    private projectCacheExpiresAt;
+    constructor(config: WhisperConfig);
+    withProject(project: string): WhisperContext;
+    private getRequiredProject;
+    private refreshProjectCache;
+    private fetchResolvedProject;
+    resolveProject(projectRef?: string): Promise<Project>;
+    private resolveProjectId;
+    private getProjectRefCandidates;
+    private withProjectRefFallback;
+    private shouldRetryWithResolvedProjectId;
+    private withProjectPathFallback;
+    private classifyError;
+    private isEndpointNotFoundError;
+    private inferOperation;
+    private request;
+    query(params: QueryParams): Promise<QueryResult>;
+    createProject(params: {
+        name: string;
+        description?: string;
+        settings?: Record<string, any>;
+    }): Promise<Project>;
+    listProjects(): Promise<{
+        projects: Project[];
+    }>;
+    getProject(id: string): Promise<Project & {
+        sources: Source[];
+    }>;
+    listSources(project?: string): Promise<{
+        project: {
+            id: string;
+            name: string;
+            slug: string;
+        };
+        sources: Source[];
+    }>;
+    deleteProject(id: string): Promise<{
+        deleted: boolean;
+    }>;
+    addSource(projectId: string, params: {
+        name: string;
+        connector_type: string;
+        config: Record<string, any>;
+        sync_schedule?: string;
+    }): Promise<Source>;
+    syncSource(sourceId: string): Promise<any>;
+    addSourceByType(projectId: string, params: {
+        type: "video";
+        url: string;
+        auto_sync?: boolean;
+        tags?: string[];
+        platform?: "youtube" | "loom" | "generic";
+        language?: string;
+        allow_stt_fallback?: boolean;
+        max_duration_minutes?: number;
+        name?: string;
+        ingestion_profile?: "auto" | "repo" | "web_docs" | "pdf_layout" | "video_transcript" | "plain_text";
+        strategy_override?: "fixed" | "recursive" | "semantic" | "hierarchical" | "adaptive";
+        profile_config?: Record<string, any>;
+    }): Promise<{
+        source_id: string;
+        sync_job_id?: string | null;
+        status: "processing" | "queued" | "created";
+    }>;
+    getSourceStatus(sourceId: string): Promise<VideoIngestionStatus>;
+    createCanonicalSource(project: string, params: CanonicalSourceCreateParams): Promise<CanonicalSourceCreateResult>;
+    ingest(projectId: string, documents: Array<{
+        id?: string;
+        title: string;
+        content: string;
+        metadata?: Record<string, any>;
+        file_path?: string;
+        ingestion_profile?: "auto" | "repo" | "web_docs" | "pdf_layout" | "video_transcript" | "plain_text";
+        strategy_override?: "fixed" | "recursive" | "semantic" | "hierarchical" | "adaptive";
+        profile_config?: Record<string, any>;
+    }>): Promise<{
+        ingested: number;
+    }>;
+    addContext(params: {
+        project?: string;
+        content: string;
+        title?: string;
+        metadata?: Record<string, any>;
+    }): Promise<{
+        ingested: number;
+    }>;
+    learn(params: LearnInput): Promise<LearnResult>;
+    listMemories(params: {
+        project?: string;
+        user_id?: string;
+        session_id?: string;
+        agent_id?: string;
+        limit?: number;
+    }): Promise<{
+        memories: any[];
+    }>;
+    addMemory(params: {
+        project?: string;
+        content: string;
+        memory_type?: "factual" | "episodic" | "semantic" | "procedural" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction";
+        user_id?: string;
+        session_id?: string;
+        agent_id?: string;
+        importance?: number;
+        metadata?: Record<string, any>;
+        expires_in_seconds?: number;
+        async?: boolean;
+        write_mode?: "async" | "sync";
+        allow_legacy_fallback?: boolean;
+    }): Promise<MemoryWriteResult>;
+    addMemoriesBulk(params: {
+        project?: string;
+        memories: Array<{
+            content: string;
+            memory_type?: MemoryKind | "episodic" | "semantic" | "procedural";
+            user_id?: string;
+            session_id?: string;
+            agent_id?: string;
+            importance?: number;
+            confidence?: number;
+            metadata?: Record<string, any>;
+            entity_mentions?: string[];
+            document_date?: string;
+            event_date?: string;
+        }>;
+        namespace?: string;
+        tags?: string[];
+        async?: boolean;
+        write_mode?: "async" | "sync";
+        webhook_url?: string;
+    }): Promise<any>;
+    extractMemories(params: {
+        project?: string;
+        message: string;
+        context?: string;
+        session_id?: string;
+        user_id?: string;
+        enable_pattern?: boolean;
+        enable_inference?: boolean;
+        min_confidence?: number;
+    }): Promise<MemoryExtractionResult>;
+    extractSessionMemories(params: {
+        project?: string;
+        user_id?: string;
+        messages: Array<{
+            role: "user" | "assistant" | "system";
+            content: string;
+            timestamp?: string;
+        }>;
+        enable_pattern?: boolean;
+        enable_inference?: boolean;
+    }): Promise<{
+        memories: ExtractedMemory[];
+        count: number;
+        latencyMs: number;
+    }>;
+    searchMemories(params: {
+        project?: string;
+        query: string;
+        user_id?: string;
+        session_id?: string;
+        agent_id?: string;
+        memory_type?: "factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction";
+        top_k?: number;
+        profile?: "fast" | "balanced" | "quality";
+        include_pending?: boolean;
+    }): Promise<MemorySearchResponse>;
+    createApiKey(params: {
+        name: string;
+        scopes?: string[];
+        rate_limit?: number;
+        expires_in_days?: number;
+    }): Promise<{
+        key: string;
+        prefix: string;
+        name: string;
+    }>;
+    listApiKeys(): Promise<{
+        keys: any[];
+    }>;
+    getUsage(days?: number): Promise<any>;
+    searchMemoriesSOTA(params: {
+        query: string;
+        project?: string;
+        user_id?: string;
+        session_id?: string;
+        question_date?: string;
+        top_k?: number;
+        memory_types?: Array<"factual" | "preference" | "event" | "relationship" | "opinion" | "goal" | "instruction">;
+        include_inactive?: boolean;
+        include_chunks?: boolean;
+        include_relations?: boolean;
+        fast_mode?: boolean;
+        profile?: "fast" | "balanced" | "quality";
+        include_pending?: boolean;
+    }): Promise<MemorySearchResponse>;
+    ingestSession(params: {
+        project?: string;
+        session_id: string;
+        user_id?: string;
+        messages: Array<{
+            role: string;
+            content: string;
+            timestamp: string;
+        }>;
+        async?: boolean;
+        write_mode?: "async" | "sync";
+    }): Promise<{
+        success: boolean;
+        memories_created: number;
+        relations_created: number;
+        memories_invalidated: number;
+        errors?: string[];
+    } & MemoryWriteAck>;
+    getSessionMemories(params: {
+        session_id: string;
+        project?: string;
+        limit?: number;
+        since_date?: string;
+        include_pending?: boolean;
+    }): Promise<{
+        memories: any[];
+        count: number;
+    }>;
+    getUserProfile(params: {
+        user_id: string;
+        project?: string;
+        memory_types?: string;
+        include_pending?: boolean;
+    }): Promise<{
+        user_id: string;
+        memories: any[];
+        count: number;
+    }>;
+    getMemory(memoryId: string): Promise<{
+        memory: any;
+    }>;
+    getMemoryVersions(memoryId: string): Promise<{
+        memory_id: string;
+        versions: any[];
+        count: number;
+    }>;
+    updateMemory(memoryId: string, params: {
+        content: string;
+        reasoning?: string;
+    }): Promise<{
+        success: boolean;
+        new_memory_id: string;
+        old_memory_id: string;
+    }>;
+    deleteMemory(memoryId: string): Promise<{
+        success: boolean;
+        deleted: string;
+    }>;
+    getMemoryRelations(memoryId: string): Promise<{
+        memory_id: string;
+        relations: any[];
+        count: number;
+    }>;
+    getMemoryGraph(params: {
+        project?: string;
+        user_id?: string;
+        session_id?: string;
+        include_inactive?: boolean;
+        limit?: number;
+    }): Promise<any>;
+    getConversationGraph(params: {
+        project?: string;
+        session_id: string;
+        include_inactive?: boolean;
+        limit?: number;
+    }): Promise<any>;
+    oracleSearch(params: {
+        query: string;
+        project?: string;
+        max_results?: number;
+        mode?: "search" | "research";
+        max_steps?: number;
+    }): Promise<any>;
+    autosubscribe(params: {
+        project?: string;
+        source: {
+            type: "github" | "local";
+            owner?: string;
+            repo?: string;
+            path?: string;
+        };
+        dependency_file?: "package.json" | "requirements.txt" | "Cargo.toml" | "go.mod" | "Gemfile";
+        index_limit?: number;
+        auto_sync?: boolean;
+    }): Promise<{
+        success: boolean;
+        discovered: number;
+        indexed: number;
+        errors: string[];
+        dependencies?: any[];
+        auto_sync_enabled: boolean;
+    }>;
+    createSharedContext(params: {
+        session_id: string;
+        project?: string;
+        title?: string;
+        include_memories?: boolean;
+        include_chunks?: boolean;
+        expiry_days?: number;
+    }): Promise<{
+        success: boolean;
+        share_id: string;
+        share_url: string;
+        title: string;
+        memories_count: number;
+        messages_count: number;
+        expires_at: string;
+    }>;
+    loadSharedContext(shareId: string): Promise<{
+        share_id: string;
+        title: string;
+        created_at: string;
+        expires_at: string;
+        memories: any[];
+        messages: any[];
+        chunks?: any[];
+        metadata: any;
+    }>;
+    resumeFromSharedContext(params: {
+        share_id: string;
+        project?: string;
+        new_session_id?: string;
+    }): Promise<{
+        success: boolean;
+        session_id: string;
+        memories_restored: number;
+        messages_restored: number;
+        chunks_restored: number;
+    }>;
+    consolidateMemories(params: {
+        project?: string;
+        similarity_threshold?: number;
+        auto_merge?: boolean;
+        dry_run?: boolean;
+    }): Promise<any>;
+    updateImportanceDecay(params: {
+        project?: string;
+        decay_function?: "exponential" | "linear" | "logarithmic";
+        half_life_days?: number;
+        access_boost?: number;
+        auto_archive?: boolean;
+        archive_threshold?: number;
+    }): Promise<{
+        success: boolean;
+        memories_updated: number;
+        average_importance: number;
+        memories_archived: number;
+        config: any;
+    }>;
+    getImportanceStats(project?: string): Promise<{
+        project_id: string;
+        statistics: any;
+    }>;
+    getCacheStats(): Promise<{
+        cache_type: string;
+        hit_rate: number;
+        total_requests: number;
+        hits: number;
+        misses: number;
+        size_bytes: number;
+        keys_count: number;
+        average_latency_ms: number;
+        uptime_seconds: number;
+    }>;
+    warmCache(params: {
+        project?: string;
+        queries: string[];
+        ttl_seconds?: number;
+    }): Promise<{
+        success: boolean;
+        queries_warmed: number;
+        errors: string[];
+        cache_size_increase_bytes: number;
+    }>;
+    clearCache(params: {
+        pattern?: string;
+        clear_all?: boolean;
+    }): Promise<{
+        success: boolean;
+        keys_cleared: number;
+        bytes_freed: number;
+    }>;
+    getCostSummary(params?: {
+        project?: string;
+        start_date?: string;
+        end_date?: string;
+    }): Promise<any>;
+    getCostBreakdown(params?: {
+        project?: string;
+        group_by?: "model" | "task" | "day" | "hour";
+        start_date?: string;
+        end_date?: string;
+    }): Promise<any>;
+    /**
+     * Semantic search over raw documents without pre-indexing.
+     * Send file contents/summaries directly — the API embeds them in-memory and ranks by similarity.
+     * Perfect for AI agents to semantically explore a codebase on-the-fly.
+     */
+    semanticSearch(params: {
+        query: string;
+        documents: Array<{
+            id: string;
+            content: string;
+        }>;
+        top_k?: number;
+        threshold?: number;
+    }): Promise<{
+        results: Array<{
+            id: string;
+            score: number;
+            content: string;
+            snippet: string;
+        }>;
+        total_searched: number;
+        total_returned: number;
+        query: string;
+        latency_ms: number;
+    }>;
+    searchFiles(params: {
+        query: string;
+        path?: string;
+        mode?: "content" | "filename" | "both";
+        file_types?: string[];
+        max_results?: number;
+        context_lines?: number;
+        case_sensitive?: boolean;
+    }): Promise<{
+        results: Array<{
+            file: string;
+            matches: Array<{
+                line: number;
+                content: string;
+                context_before: string[];
+                context_after: string[];
+            }>;
+        }>;
+        total_files: number;
+        total_matches: number;
+        search_path: string;
+        mode: string;
+        latency_ms: number;
+        engine: "ripgrep" | "node";
+    }>;
+    getCostSavings(params?: {
+        project?: string;
+        start_date?: string;
+        end_date?: string;
+    }): Promise<any>;
+    readonly projects: {
+        create: (params: {
+            name: string;
+            description?: string;
+            settings?: Record<string, any>;
+        }) => Promise<Project>;
+        list: () => Promise<{
+            projects: Project[];
+        }>;
+        get: (id: string) => Promise<Project & {
+            sources: Source[];
+        }>;
+        delete: (id: string) => Promise<{
+            deleted: boolean;
+        }>;
+    };
+    readonly sources: {
+        add: (projectId: string, params: {
+            name: string;
+            connector_type: string;
+            config: Record<string, any>;
+            sync_schedule?: string;
+        }) => Promise<Source>;
+        addSource: (projectId: string, params: {
+            type: "video";
+            url: string;
+            auto_sync?: boolean;
+            tags?: string[];
+            platform?: "youtube" | "loom" | "generic";
+            language?: string;
+            allow_stt_fallback?: boolean;
+            max_duration_minutes?: number;
+            name?: string;
+        }) => Promise<{
+            source_id: string;
+            sync_job_id?: string | null;
+            status: "processing" | "queued" | "created";
+        }>;
+        sync: (sourceId: string) => Promise<any>;
+        syncSource: (sourceId: string) => Promise<any>;
+        status: (sourceId: string) => Promise<VideoIngestionStatus>;
+        getStatus: (sourceId: string) => Promise<VideoIngestionStatus>;
+    };
+    readonly memory: {
+        add: (params: Parameters<WhisperContext["addMemory"]>[0]) => Promise<MemoryWriteResult>;
+        addBulk: (params: Parameters<WhisperContext["addMemoriesBulk"]>[0]) => Promise<any>;
+        extract: (params: Parameters<WhisperContext["extractMemories"]>[0]) => Promise<MemoryExtractionResult>;
+        extractSession: (params: Parameters<WhisperContext["extractSessionMemories"]>[0]) => Promise<{
+            memories: ExtractedMemory[];
+            count: number;
+            latencyMs: number;
+        }>;
+        search: (params: Parameters<WhisperContext["searchMemories"]>[0]) => Promise<MemorySearchResponse>;
+        searchSOTA: (params: Parameters<WhisperContext["searchMemoriesSOTA"]>[0]) => Promise<MemorySearchResponse>;
+        ingestSession: (params: Parameters<WhisperContext["ingestSession"]>[0]) => Promise<{
+            success: boolean;
+            memories_created: number;
+            relations_created: number;
+            memories_invalidated: number;
+            errors?: string[];
+        } & MemoryWriteAck>;
+        getSessionMemories: (params: Parameters<WhisperContext["getSessionMemories"]>[0]) => Promise<{
+            memories: any[];
+            count: number;
+        }>;
+        getUserProfile: (params: Parameters<WhisperContext["getUserProfile"]>[0]) => Promise<{
+            user_id: string;
+            memories: any[];
+            count: number;
+        }>;
+        get: (memoryId: string) => Promise<{
+            memory: any;
+        }>;
+        getVersions: (memoryId: string) => Promise<{
+            memory_id: string;
+            versions: any[];
+            count: number;
+        }>;
+        update: (memoryId: string, params: Parameters<WhisperContext["updateMemory"]>[1]) => Promise<{
+            success: boolean;
+            new_memory_id: string;
+            old_memory_id: string;
+        }>;
+        delete: (memoryId: string) => Promise<{
+            success: boolean;
+            deleted: string;
+        }>;
+        getRelations: (memoryId: string) => Promise<{
+            memory_id: string;
+            relations: any[];
+            count: number;
+        }>;
+        getGraph: (params: Parameters<WhisperContext["getMemoryGraph"]>[0]) => Promise<any>;
+        getConversationGraph: (params: Parameters<WhisperContext["getConversationGraph"]>[0]) => Promise<any>;
+        consolidate: (params: Parameters<WhisperContext["consolidateMemories"]>[0]) => Promise<any>;
+        updateDecay: (params: Parameters<WhisperContext["updateImportanceDecay"]>[0]) => Promise<{
+            success: boolean;
+            memories_updated: number;
+            average_importance: number;
+            memories_archived: number;
+            config: any;
+        }>;
+        getImportanceStats: (project?: string) => Promise<{
+            project_id: string;
+            statistics: any;
+        }>;
+    };
+    readonly keys: {
+        create: (params: Parameters<WhisperContext["createApiKey"]>[0]) => Promise<{
+            key: string;
+            prefix: string;
+            name: string;
+        }>;
+        list: () => Promise<{
+            keys: any[];
+        }>;
+        getUsage: (days?: number) => Promise<any>;
+    };
+    readonly oracle: {
+        search: (params: Parameters<WhisperContext["oracleSearch"]>[0]) => Promise<any>;
+    };
+    readonly context: {
+        createShare: (params: Parameters<WhisperContext["createSharedContext"]>[0]) => Promise<{
+            success: boolean;
+            share_id: string;
+            share_url: string;
+            title: string;
+            memories_count: number;
+            messages_count: number;
+            expires_at: string;
+        }>;
+        loadShare: (shareId: string) => Promise<{
+            share_id: string;
+            title: string;
+            created_at: string;
+            expires_at: string;
+            memories: any[];
+            messages: any[];
+            chunks?: any[];
+            metadata: any;
+        }>;
+        resumeShare: (params: Parameters<WhisperContext["resumeFromSharedContext"]>[0]) => Promise<{
+            success: boolean;
+            session_id: string;
+            memories_restored: number;
+            messages_restored: number;
+            chunks_restored: number;
+        }>;
+    };
+    readonly optimization: {
+        getCacheStats: () => Promise<{
+            cache_type: string;
+            hit_rate: number;
+            total_requests: number;
+            hits: number;
+            misses: number;
+            size_bytes: number;
+            keys_count: number;
+            average_latency_ms: number;
+            uptime_seconds: number;
+        }>;
+        warmCache: (params: Parameters<WhisperContext["warmCache"]>[0]) => Promise<{
+            success: boolean;
+            queries_warmed: number;
+            errors: string[];
+            cache_size_increase_bytes: number;
+        }>;
+        clearCache: (params: Parameters<WhisperContext["clearCache"]>[0]) => Promise<{
+            success: boolean;
+            keys_cleared: number;
+            bytes_freed: number;
+        }>;
+        getCostSummary: (params?: Parameters<WhisperContext["getCostSummary"]>[0]) => Promise<any>;
+        getCostBreakdown: (params?: Parameters<WhisperContext["getCostBreakdown"]>[0]) => Promise<any>;
+        getCostSavings: (params?: Parameters<WhisperContext["getCostSavings"]>[0]) => Promise<any>;
+    };
+}
+
+export { type WhisperEnvironment as $, type AgentRunContext as A, type MemoryKind as B, type CanonicalSourceCreateParams as C, type MemoryLatencyBreakdown as D, type ExtractedMemory as E, type MemorySearchResponse as F, type MemoryWriteAck as G, type MemoryWriteResult as H, type Project as I, type QueryResult as J, type TurnInput as K, LangChainMemoryAdapter as L, type MemoryRouterConfig as M, type VideoSourceMetadata as N, Whisper as O, type PreparedTurn as P, type QueryParams as Q, type RunContext as R, type Source as S, type TurnCaptureResult as T, WhisperAgentMiddleware as U, type VideoIngestionStatus as V, type WhisperToolDefinition as W, type WithWhisperOptions, WhisperClient as X, type WhisperClientConfig as Y, type WhisperConfig as Z, WhisperContext as _, type WhisperToolsOptions as a, WhisperError as a0, type WhisperErrorCode as a1, type WhisperIdentityMode as a2, type WhisperPreflightCheck as a3, type WhisperPreflightResult as a4, type WhisperResolvedIdentity as a5, type WorkEvent as a6, type WorkEventKind as a7, type WorkEventSalience as a8, createAgentMiddleware as a9, createLangChainMemoryAdapter as aa, createLangGraphCheckpointAdapter as ab, memoryGraphToMermaid as ac, type MemoryRouterFallbackReason as b, type MemoryRouterResult as c, type MemoryRouterTrace as d, WhisperMemoryRouter as e, createMemoryRouter as f, type AgentRuntimeOptions as g, type AgentRuntimeRankWeights as h, type AgentRuntimeRetrievalOptions as i, type AgentRuntimeSourceActivityOptions as j, type AgentRuntimeStatus as k, type CanonicalSourceCreateResult as l, type CanonicalSourceType as m, LangGraphCheckpointAdapter as n, type LearnConversationInput as o, type LearnConversationResult as p, type LearnInput as q, type LearnResult as r, type LearnSourceInput as s, type LearnSourceResult as t, type LearnSourceType as u, type LearnTextInput as v, whisperTools as w, withWhisper, type LearnTextResult as x, type Memory as y, type MemoryExtractionResult as z };