@kodax-ai/kodax 0.7.41 → 0.7.43

package/dist/types-chunks/storage.d-DPAEX7zS.d.ts

@@ -0,0 +1,115 @@
+import { k as KodaXSessionData, o as KodaXSessionLineage, r as KodaXSessionNavigationOptions, s as KodaXSessionRuntimeInfo, u as KodaXSessionStorage } from './types.d-mM8vqvhT.js';
+
+/**
+ * Session Storage - Session storage abstraction layer
+ *
+ * Provides a shared persistence interface across memory and filesystem storage.
+ */
+
+/**
+ * Session data structure.
+ */
+type SessionData = KodaXSessionData;
+/**
+ * Session storage interface.
+ */
+interface SessionStorage {
+    save(id: string, data: SessionData): Promise<void>;
+    load(id: string): Promise<SessionData | null>;
+    getLineage?(id: string): Promise<KodaXSessionLineage | null>;
+    setActiveEntry?(id: string, selector: string, options?: KodaXSessionNavigationOptions): Promise<SessionData | null>;
+    setLabel?(id: string, selector: string, label?: string): Promise<SessionData | null>;
+    rewind?(id: string, selector?: string): Promise<SessionData | null>;
+    fork?(id: string, selector?: string, options?: {
+        sessionId?: string;
+        title?: string;
+    }): Promise<{
+        sessionId: string;
+        data: SessionData;
+    } | null>;
+    list(gitRoot?: string): Promise<Array<{
+        id: string;
+        title: string;
+        msgCount: number;
+        runtimeInfo?: KodaXSessionRuntimeInfo;
+    }>>;
+    delete?(id: string): Promise<void>;
+    deleteAll?(gitRoot?: string): Promise<void>;
+}
+/**
+ * In-memory session storage implementation.
+ */
+declare class MemorySessionStorage implements SessionStorage {
+    private sessions;
+    save(id: string, data: SessionData): Promise<void>;
+    load(id: string): Promise<SessionData | null>;
+    getLineage(id: string): Promise<KodaXSessionLineage | null>;
+    setActiveEntry(id: string, selector: string, options?: KodaXSessionNavigationOptions): Promise<SessionData | null>;
+    setLabel(id: string, selector: string, label?: string): Promise<SessionData | null>;
+    fork(id: string, selector?: string, options?: {
+        sessionId?: string;
+        title?: string;
+    }): Promise<{
+        sessionId: string;
+        data: SessionData;
+    } | null>;
+    rewind(id: string, selector?: string): Promise<SessionData | null>;
+    list(_gitRoot?: string): Promise<Array<{
+        id: string;
+        title: string;
+        msgCount: number;
+    }>>;
+    delete(id: string): Promise<void>;
+    deleteAll(_gitRoot?: string): Promise<void>;
+}
+declare function createMemorySessionStorage(): SessionStorage;
+
+/**
+ * KodaX session storage - filesystem implementation.
+ */
+
+declare class FileSessionStorage implements KodaXSessionStorage {
+    private readonly sessionsDir;
+    constructor(opts?: {
+        sessionsDir?: string;
+    });
+    private writeQueues;
+    private serializedWrite;
+    private appendState;
+    /** Update watermarks. Only overwrites fields the caller actually provided. */
+    private syncAppendState;
+    private getSessionFilePath;
+    private getArchiveFilePath;
+    private readSession;
+    private writeSessionInternal;
+    private mergeAndWriteInternal;
+    appendSessionDelta(id: string, data: SessionData): Promise<void>;
+    private shouldRunMaintenance;
+    private runMaintenance;
+    save(id: string, data: SessionData): Promise<void>;
+    load(id: string): Promise<SessionData | null>;
+    getLineage(id: string): Promise<KodaXSessionLineage | null>;
+    setActiveEntry(id: string, selector: string, options?: {
+        summarizeCurrentBranch?: boolean;
+    }): Promise<SessionData | null>;
+    rewind(id: string, selector?: string): Promise<SessionData | null>;
+    setLabel(id: string, selector: string, label?: string): Promise<SessionData | null>;
+    fork(id: string, selector?: string, options?: {
+        sessionId?: string;
+        title?: string;
+    }): Promise<{
+        sessionId: string;
+        data: SessionData;
+    } | null>;
+    list(gitRoot?: string): Promise<Array<{
+        id: string;
+        title: string;
+        msgCount: number;
+        runtimeInfo?: KodaXSessionRuntimeInfo;
+    }>>;
+    delete(id: string): Promise<void>;
+    deleteAll(gitRoot?: string): Promise<void>;
+}
+
+export { FileSessionStorage as F, MemorySessionStorage as M, createMemorySessionStorage as c };
+export type { SessionData as S, SessionStorage as a };

package/dist/types-chunks/{capability.d-BxNgd1-c.d.ts → types.d-B1uGoVTE.d.ts}

@@ -13,10 +13,40 @@ interface KodaXToolUseBlock {
     name: string;
     input: Record<string, unknown>;
 }
+/**
+ * Tool-result content blocks — a structural subset of the full
+ * `KodaXContentBlock` union, restricted to what providers actually accept
+ * inside a tool_result envelope. Anthropic / OpenAI multimodal APIs accept
+ * text and image blocks inside tool_result; thinking / tool_use / nested
+ * tool_result / cache-boundary are not valid there.
+ *
+ * Carrying these as a stricter subtype (instead of the full union) lets
+ * provider serializers narrow without exhaustive type assertions and
+ * documents to tool authors what they can actually return.
+ */
+interface KodaXToolResultTextItem {
+    type: 'text';
+    text: string;
+}
+interface KodaXToolResultImageItem {
+    type: 'image';
+    /** Absolute path to the image file. Provider serializers read it into base64 at wire-send time. */
+    path: string;
+    mediaType?: string;
+}
+type KodaXToolResultContentItem = KodaXToolResultTextItem | KodaXToolResultImageItem;
 interface KodaXToolResultBlock {
     type: 'tool_result';
     tool_use_id: string;
-    content: string;
+    /**
+     * Either a plain text string (backwards-compatible default) OR an array
+     * of content items. The array form lets multimodal-capable tools (e.g.
+     * `read` on an image path) emit images via tool_result, mirroring
+     * claudecode's `Read` tool behavior. Providers serialize each variant
+     * to their wire format; text-only providers (e.g. older OpenAI-compat
+     * gateways) downgrade image items to a placeholder rather than rejecting.
+     */
+    content: string | readonly KodaXToolResultContentItem[];
     is_error?: boolean;
 }
 interface KodaXImageBlock {
@@ -189,6 +219,24 @@ interface KodaXModelDescriptor {
     maxOutputTokens?: number;
     thinkingBudgetCap?: number;
     reasoningCapability?: KodaXReasoningCapability;
+    /**
+     * Per-model override for `replayReasoningContent`. Falls through to the
+     * provider-level flag when undefined. Lets a single gateway endpoint
+     * route models that need the flag (DeepSeek V4) alongside models that
+     * would 400 if the flag were on (OpenAI proper).
+     */
+    replayReasoningContent?: boolean;
+    /**
+     * Per-model override for `strictThinkingSignature`. Falls through to
+     * the provider-level flag when undefined.
+     */
+    strictThinkingSignature?: boolean;
+    /**
+     * Per-model override for `streamMaxDurationMs`. Falls through to the
+     * provider-level cap when undefined; undefined at both levels disables
+     * the watchdog.
+     */
+    streamMaxDurationMs?: number;
 }
 type KodaXProtocolFamily = 'anthropic' | 'openai';
 type KodaXProviderUserAgentMode = 'compat' | 'sdk';
@@ -217,6 +265,28 @@ interface KodaXCustomProviderConfig {
     contextWindow?: number;
     maxOutputTokens?: number;
     thinkingBudgetCap?: number;
+    /**
+     * Provider-level default for OpenAI-compat `reasoning_content` echo.
+     * Required by DeepSeek V4 thinking mode (replay 400s without it).
+     * Defaults to false — must stay false for OpenAI proper or any gateway
+     * that rejects unknown fields. Per-model values in `models[]` can
+     * override on a model-by-model basis.
+     */
+    replayReasoningContent?: boolean;
+    /**
+     * Provider-level default for strict Anthropic thinking-signature
+     * verification. Only Anthropic proper cryptographically verifies
+     * signatures — third-party Anthropic-compat gateways must keep this
+     * false (default). Per-model values in `models[]` can override.
+     */
+    strictThinkingSignature?: boolean;
+    /**
+     * Provider-level default streaming wall-clock cap (ms). Set just below
+     * a known server-side kill window (zhipu-coding 308s → 300_000). Leave
+     * unset to disable the watchdog. Per-model values in `models[]` can
+     * override.
+     */
+    streamMaxDurationMs?: number;
 }
 interface KodaXProviderConfig {
     apiKeyEnv: string;
@@ -327,42 +397,4 @@ interface KodaXProviderStreamOptions {
     signal?: AbortSignal;
 }
 
-/**
- * Layer A Primitive: Capability provider contract.
- *
- * FEATURE_082 (v0.7.24): extracted from `@kodax-ai/coding/src/extensions/types.ts`
- * so third-party capability sources (MCP, RAG, custom indexes, …) can
- * implement `CapabilityProvider` without importing from the coding preset.
- *
- * The richer "extension runtime" concept (command registration, file
- * contributions, logger plumbing) stays in `@kodax-ai/coding/src/extensions/`
- * because it is coupled to the coding CLI surface.
- */
-type CapabilityKind = 'tool' | 'resource' | 'prompt';
-interface CapabilityResult {
-    kind: CapabilityKind;
-    content?: string;
-    structuredContent?: unknown;
-    evidence?: unknown[];
-    artifacts?: unknown[];
-    metadata?: Record<string, unknown>;
-}
-interface CapabilityProvider {
-    id: string;
-    kinds: CapabilityKind[];
-    search?: (query: string, options?: {
-        kind?: CapabilityKind;
-        limit?: number;
-        server?: string;
-    }) => Promise<unknown[]>;
-    describe?: (id: string) => Promise<unknown>;
-    execute?: (id: string, input: Record<string, unknown>) => Promise<CapabilityResult>;
-    read?: (id: string, options?: Record<string, unknown>) => Promise<CapabilityResult>;
-    getPrompt?: (id: string, args?: Record<string, unknown>) => Promise<unknown>;
-    getPromptContext?: () => Promise<string | undefined> | string | undefined;
-    getDiagnostics?: () => Record<string, unknown> | undefined;
-    refresh?: () => Promise<void>;
-    dispose?: () => Promise<void>;
-}
-
-export type { KodaXToolResultBlock as $, KodaXProviderSessionSupport as A, KodaXProviderStreamOptions as B, CapabilityKind as C, KodaXProviderToolCallingFidelity as D, KodaXProviderTransport as E, KodaXReasoningCapability as F, KodaXReasoningMode as G, KodaXReasoningOverride as H, KodaXReasoningRequest as I, KodaXRedactedThinkingBlock as J, KodaXAmaControllerDecision as K, KodaXReviewScale as L, KodaXRiskLevel as M, KodaXStreamResult as N, KodaXTaskActionability as O, KodaXTaskBudgetOverrides as P, KodaXTaskComplexity as Q, KodaXTaskFamily as R, KodaXTaskRoutingDecision as S, KodaXTaskType as T, KodaXTaskWorkIntent as U, KodaXTextBlock as V, KodaXThinkingBlock as W, KodaXThinkingBudgetMap as X, KodaXThinkingDepth as Y, KodaXTokenUsage as Z, KodaXToolDefinition as _, CapabilityProvider as a, KodaXToolUseBlock as a0, CapabilityResult as b, KodaXAmaFanoutClass as c, KodaXAmaFanoutPolicy as d, KodaXAmaProfile as e, KodaXAmaTactic as f, KodaXAssuranceIntent as g, KodaXCacheBoundary as h, KodaXContentBlock as i, KodaXCustomProviderConfig as j, KodaXExecutionMode as k, KodaXExecutionPattern as l, KodaXHarnessProfile as m, KodaXImageBlock as n, KodaXMessage as o, KodaXModelDescriptor as p, KodaXMutationSurface as q, KodaXProtocolFamily as r, KodaXProviderCapabilityProfile as s, KodaXProviderConfig as t, KodaXProviderContextFidelity as u, KodaXProviderConversationSemantics as v, KodaXProviderEvidenceSupport as w, KodaXProviderLongRunningSupport as x, KodaXProviderMcpSupport as y, KodaXProviderMultimodalSupport as z };
+export type { KodaXToolResultTextItem as $, KodaXProviderToolCallingFidelity as A, KodaXProviderTransport as B, KodaXReasoningCapability as C, KodaXReasoningMode as D, KodaXReasoningOverride as E, KodaXReasoningRequest as F, KodaXRedactedThinkingBlock as G, KodaXReviewScale as H, KodaXRiskLevel as I, KodaXStreamResult as J, KodaXAmaControllerDecision as K, KodaXTaskActionability as L, KodaXTaskBudgetOverrides as M, KodaXTaskComplexity as N, KodaXTaskFamily as O, KodaXTaskRoutingDecision as P, KodaXTaskType as Q, KodaXTaskWorkIntent as R, KodaXTextBlock as S, KodaXThinkingBlock as T, KodaXThinkingBudgetMap as U, KodaXThinkingDepth as V, KodaXTokenUsage as W, KodaXToolDefinition as X, KodaXToolResultBlock as Y, KodaXToolResultContentItem as Z, KodaXToolResultImageItem as _, KodaXAmaFanoutClass as a, KodaXToolUseBlock as a0, KodaXAmaFanoutPolicy as b, KodaXAmaProfile as c, KodaXAmaTactic as d, KodaXAssuranceIntent as e, KodaXCacheBoundary as f, KodaXContentBlock as g, KodaXCustomProviderConfig as h, KodaXExecutionMode as i, KodaXExecutionPattern as j, KodaXHarnessProfile as k, KodaXImageBlock as l, KodaXMessage as m, KodaXModelDescriptor as n, KodaXMutationSurface as o, KodaXProtocolFamily as p, KodaXProviderCapabilityProfile as q, KodaXProviderConfig as r, KodaXProviderContextFidelity as s, KodaXProviderConversationSemantics as t, KodaXProviderEvidenceSupport as u, KodaXProviderLongRunningSupport as v, KodaXProviderMcpSupport as w, KodaXProviderMultimodalSupport as x, KodaXProviderSessionSupport as y, KodaXProviderStreamOptions as z };