@kodax-ai/kodax 0.7.57 → 0.7.59

package/dist/types-chunks/capability-learning.d-DRV80ISB.d.ts

@@ -0,0 +1,29 @@
+import { F as KodaXReasoningProfile } from './types.d-Ci5YPFEh.js';
+
+type CapabilityCacheSource = 'observed' | 'probed';
+interface CapabilityCacheEntry {
+    /** Efforts this provider/model rejected; removed from the effective ladder. */
+    readonly rejected: readonly string[];
+    /** How the rejection was learned. */
+    readonly source: CapabilityCacheSource;
+    /** ISO timestamp of the last update. */
+    readonly updatedAt: string;
+}
+/** Keyed by `provider/model`. */
+type CapabilityCache = Record<string, CapabilityCacheEntry>;
+declare function capabilityCacheKey(provider: string, model: string | undefined): string;
+/**
+ * Narrow a reasoning profile by learned hard rejections.
+ *
+ * Learning only removes rungs. Provider acceptance is not proof that an effort
+ * is semantically distinct, but a hard rejection is ground truth that the rung
+ * should not be sent again for this provider/model.
+ */
+declare function narrowReasoningProfile(profile: KodaXReasoningProfile, rejected: readonly string[]): KodaXReasoningProfile;
+declare function getRejectedEfforts(cache: CapabilityCache, provider: string, model: string | undefined): readonly string[];
+declare function addRejectedEffort(cache: CapabilityCache, provider: string, model: string | undefined, effort: string, source: CapabilityCacheSource, updatedAt: string): CapabilityCache;
+declare function removeCacheEntry(cache: CapabilityCache, provider?: string, model?: string): CapabilityCache;
+declare function sanitizeCapabilityCache(raw: unknown): CapabilityCache;
+
+export { addRejectedEffort as c, capabilityCacheKey as d, getRejectedEfforts as g, narrowReasoningProfile as n, removeCacheEntry as r, sanitizeCapabilityCache as s };
+export type { CapabilityCache as C, CapabilityCacheEntry as a, CapabilityCacheSource as b };

package/dist/types-chunks/{cost-tracker.d-wRtyEW9d.d.ts → cost-tracker.d-CBLk1fiD.d.ts}

@@ -1,3 +1,25 @@
+interface KodaXLlmTimeoutConfig {
+    /** Main provider request hard timeout, in seconds. Default 600s. */
+    readonly requestTimeoutSec?: number;
+    /** Idle timeout between stream deltas, in seconds. Set 0 to disable. Default 0. */
+    readonly streamIdleTimeoutSec?: number;
+    /** Per stream chunk timeout, in seconds. Default 30s. */
+    readonly chunkTimeoutSec?: number;
+    /** Maximum retry delay, in seconds. Default 60s. */
+    readonly maxRetryDelaySec?: number;
+}
+interface KodaXResolvedLlmTimeoutConfig {
+    readonly requestTimeoutMs?: number;
+    readonly streamIdleTimeoutMs?: number;
+    readonly chunkTimeoutMs?: number;
+    readonly maxRetryDelayMs?: number;
+}
+declare function timeoutSecToMs(value: number | undefined, label: string, opts?: {
+    readonly allowZero?: boolean;
+}): number | undefined;
+declare function parseTimeoutSecEnvMs(raw: string | undefined): number | undefined;
+declare function resolveLlmTimeoutConfig(timeouts: KodaXLlmTimeoutConfig | undefined): KodaXResolvedLlmTimeoutConfig | undefined;
+
 /**
  * KodaX Cost Rates - Multi-Provider pricing table
  *
@@ -106,5 +128,5 @@ declare function getSummary(tracker: CostTracker): SessionCostSummary;
 declare function formatCost(usd: number): string;
 declare function formatCostReport(summary: SessionCostSummary): string;
 
-export { DEFAULT_COST_RATES as D, createCostTracker as b, calculateCost as c, formatCostReport as d, getSummary as e, formatCost as f, getCostRate as g, recordUsage as h, recordRetry as r };
-export type { CostRate as C, ProviderCostSummary as P, RetryRecord as R, SessionCostSummary as S, TokenUsageRecord as T, CostTracker as a };
+export { DEFAULT_COST_RATES as D, calculateCost as c, createCostTracker as d, formatCostReport as e, formatCost as f, getCostRate as g, getSummary as h, recordUsage as i, resolveLlmTimeoutConfig as j, parseTimeoutSecEnvMs as p, recordRetry as r, timeoutSecToMs as t };
+export type { CostRate as C, KodaXLlmTimeoutConfig as K, ProviderCostSummary as P, RetryRecord as R, SessionCostSummary as S, TokenUsageRecord as T, CostTracker as a, KodaXResolvedLlmTimeoutConfig as b };

package/dist/types-chunks/{guardrail.d-C1DhxnvC.d.ts → guardrail.d-CNdKuSD_.d.ts}

@@ -1,8 +1,8 @@
 import { M as McpConnectMode, a as McpServerConfig, b as McpServersConfig, c as McpTransportKind } from './config.d-CJy1WENT.js';
-import { K as KodaXBaseProvider } from './base.d-BnjQrSVf.js';
-import { a as CostTracker } from './cost-tracker.d-wRtyEW9d.js';
-import { aG as RunnerToolCall } from './process.d-BZncyzEj.js';
-import { d as ToolGuardrail } from './guardrail.d-BP3yyr6u.js';
+import { K as KodaXBaseProvider } from './base.d-BA9Doaj_.js';
+import { a as CostTracker } from './cost-tracker.d-CBLk1fiD.js';
+import { aO as RunnerToolCall } from './process.d-BOrAxjvM.js';
+import { g as ToolGuardrail } from './types.d-CE_Ter29.js';
 
 /**
  * FEATURE_200 Phase F (v0.7.45) — MCP domain types extracted from types.ts.

package/dist/types-chunks/{process.d-BZncyzEj.d.ts → process.d-BOrAxjvM.d.ts}

@@ -1,4 +1,4 @@
-import { j as KodaXMessage, _ as KodaXToolDefinition, E as KodaXReasoningMode, a6 as KodaXWireReasoningEffort, a0 as KodaXToolResultContentItem, V as KodaXThinkingBlock, H as KodaXRedactedThinkingBlock } from './types.d-6VOXvF88.js';
+import { j as KodaXMessage, _ as KodaXToolDefinition, E as KodaXReasoningMode, a6 as KodaXWireReasoningEffort, a0 as KodaXToolResultContentItem, V as KodaXThinkingBlock, H as KodaXRedactedThinkingBlock } from './types.d-Ci5YPFEh.js';
 
 /**
  * @kodax-ai/agent Types
@@ -163,7 +163,7 @@ interface KodaXSessionTreeNode {
     active: boolean;
 }
 type KodaXSessionScope = 'user' | 'managed-task-worker';
-type KodaXSessionUiTextHistoryItemType = 'user' | 'assistant' | 'system' | 'thinking' | 'error' | 'event' | 'info' | 'hint';
+type KodaXSessionUiTextHistoryItemType = 'user' | 'assistant' | 'system' | 'thinking' | 'error' | 'event' | 'info' | 'hint' | 'sidecar';
 type KodaXSessionUiHistoryItemType = KodaXSessionUiTextHistoryItemType | 'tool_group';
 interface KodaXSessionUiTextHistoryItem {
     type: KodaXSessionUiTextHistoryItemType;
@@ -197,6 +197,22 @@ interface KodaXSessionRuntimeInfo {
     executionCwd?: string;
     branch?: string;
     workspaceKind?: KodaXSessionWorkspaceKind;
+    /** SDK consumer surface/profile label, e.g. `'code'` | `'partner'`. */
+    surface?: string;
+    /** SDK consumer profile id (stable name or UUID). */
+    profileId?: string;
+    /** SDK consumer profile version. */
+    profileVersion?: string;
+    /** LLM provider alias active at session start, e.g. `'anthropic'`. */
+    provider?: string;
+    /** Model identifier active at session start. */
+    model?: string;
+    /** Reasoning mode active at session start. */
+    reasoningMode?: string;
+    /** Permission mode active at session start, e.g. `'auto'` | `'plan'`. */
+    permissionMode?: string;
+    /** Agent mode active at session start, e.g. `'sa'` | `'ama'` | `'amaw'`. */
+    agentMode?: string;
 }
 interface KodaXSessionData {
     messages: KodaXMessage[];
@@ -1856,6 +1872,9 @@ interface StopHookContext {
  * FEATURE_184 (v0.7.45) — Stop hook return surface.
  */
 type StopHookResult = undefined | string | {
+    readonly reanimate: string;
+    readonly source?: string;
+} | {
     readonly abort: true;
     readonly reason: string;
 };
@@ -2006,6 +2025,19 @@ interface AskUserQuestionItem {
         value: string;
     }>;
     multiSelect?: boolean;
+    /**
+     * FEATURE_222 — only meaningful when `multiSelect` is true. The host should
+     * reject (re-prompt / show an error, do NOT resolve) a selection with fewer
+     * than `minSelections` items. Absent ⇒ no lower bound.
+     */
+    minSelections?: number;
+    /**
+     * FEATURE_222 — only meaningful when `multiSelect` is true. The host should
+     * reject a selection with more than `maxSelections` items. Absent ⇒ no upper
+     * bound. Lets a host render + validate "pick at most N" structurally instead
+     * of parsing it out of natural-language question text.
+     */
+    maxSelections?: number;
 }
 /** Options for multi-question mode — multiple independent questions in one call. */
 interface AskUserMultiOptions {
@@ -2022,8 +2054,31 @@ interface AskUserQuestionOptions {
         value: string;
     }>;
     multiSelect?: boolean;
+    /** FEATURE_222 — see {@link AskUserQuestionItem.minSelections}. */
+    minSelections?: number;
+    /** FEATURE_222 — see {@link AskUserQuestionItem.maxSelections}. */
+    maxSelections?: number;
     default?: string;
 }
+/**
+ * FEATURE_222 — reserved option value a host may append as a synthetic option
+ * (e.g. a "← Back" entry) in `askUserMulti`'s per-question flow to mean "return
+ * to the previous question" instead of answering the current one. Only
+ * meaningful for `questions[]` index > 0 (there is no previous before the
+ * first). The coding `ask_user_question` tool rejects this as a normal
+ * `option.value` supplied by the model, so a host may safely reuse it for its
+ * own back-navigation UI. A host that ignores this constant simply never offers
+ * back-navigation — the default multi-question flow is unaffected either way.
+ */
+declare const ASK_USER_BACK_SIGNAL = "__back__";
+/**
+ * FEATURE_222 — narrow an `askUser` result to a single string for the many
+ * callers that only ever ask single-select questions (they never set
+ * `multiSelect: true`, so the array branch is unreachable at runtime). Collapses
+ * an unexpected array to its first element so a mis-configured host degrades
+ * predictably instead of leaking `[object Array]` into a string comparison.
+ */
+declare function asSingleSelection(answer: string | string[]): string;
 /**
  * The host-provided user-interaction surface. Each method is optional — a
  * headless host omits them and callers degrade gracefully. This is the single
@@ -2031,11 +2086,19 @@ interface AskUserQuestionOptions {
  * elicitation reverse capability.
  */
 interface UserInteraction {
-    /** Ask one question (select mode by default). Resolves the chosen value. */
-    askUser?: (options: AskUserQuestionOptions) => Promise<string>;
-    /** Ask several independent questions sequentially. Resolves a value map, or
-     *  undefined when the user cancels. */
-    askUserMulti?: (options: AskUserMultiOptions) => Promise<Record<string, string> | undefined>;
+    /**
+     * Ask one question (select mode by default). Single-select (multiSelect
+     * falsy) resolves the chosen value as a string — unchanged. Multi-select
+     * (multiSelect: true) resolves the selected values as a `string[]`. The union
+     * is a backward-compatible superset: a host still returning a plain string
+     * satisfies this contract, but a multi-select host SHOULD return `string[]`
+     * so option values containing `, ` are not corrupted by a join.
+     */
+    askUser?: (options: AskUserQuestionOptions) => Promise<string | string[]>;
+    /** Ask several independent questions sequentially. Resolves a per-question
+     *  value map (each entry a string for single-select, `string[]` for
+     *  multi-select), or undefined when the user cancels. */
+    askUserMulti?: (options: AskUserMultiOptions) => Promise<Record<string, string | string[]> | undefined>;
     /** Ask for free-text input. Resolves the text, or undefined when cancelled. */
     askUserInput?: (options: {
         question: string;
@@ -2047,6 +2110,35 @@ declare function setActiveUserInteraction(interaction: UserInteraction | undefin
 /** The live user-interaction surface, or undefined when none is active. */
 declare function getActiveUserInteraction(): UserInteraction | undefined;
 
+type KodaXImageMediaType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
+type KodaXVideoMediaType = 'video/mp4' | 'video/mpeg' | 'video/quicktime' | 'video/x-msvideo' | 'video/x-flv' | 'video/webm' | 'video/x-ms-wmv' | 'video/3gpp';
+type KodaXInputArtifactSource = 'user-inline' | 'clipboard' | 'drag-drop' | 'file-picker';
+interface KodaXImageInputArtifact {
+    readonly kind: 'image';
+    readonly path: string;
+    readonly mediaType?: KodaXImageMediaType;
+    readonly source?: KodaXInputArtifactSource;
+    readonly description?: string;
+}
+interface KodaXFileInputArtifact {
+    readonly kind: 'file';
+    readonly path: string;
+    readonly mediaType?: string;
+    readonly mimeType?: string;
+    readonly name?: string;
+    readonly source?: KodaXInputArtifactSource;
+    readonly description?: string;
+}
+interface KodaXVideoInputArtifact {
+    readonly kind: 'video';
+    readonly path: string;
+    readonly mediaType: KodaXVideoMediaType;
+    readonly name?: string;
+    readonly source?: KodaXInputArtifactSource;
+    readonly description?: string;
+}
+type KodaXInputArtifact = KodaXImageInputArtifact | KodaXFileInputArtifact | KodaXVideoInputArtifact;
+
 /**
  * Child task registry primitive — generic fan-out tracking.
  *
@@ -2513,7 +2605,7 @@ interface FileOperations {
  * injected clock). The run graph models agent relationships as a
  * thread/edge/event stream, not just a final summary blob.
  */
-type WorkflowEventType = 'workflow_started' | 'phase_started' | 'phase_finished' | 'agent_spawned' | 'agent_message_sent' | 'agent_completed' | 'agent_unverified' | 'agent_failed' | 'agent_summary_updated' | 'agent_stopped' | 'workflow_log' | 'artifact_written' | 'synthesis_completed' | 'workflow_completed' | 'workflow_stopped' | 'workflow_failed';
+type WorkflowEventType = 'workflow_started' | 'phase_started' | 'phase_finished' | 'agent_spawned' | 'agent_message_sent' | 'agent_completed' | 'agent_unverified' | 'agent_failed' | 'agent_summary_updated' | 'agent_stopped' | 'agent_replayed' | 'workflow_log' | 'artifact_written' | 'synthesis_completed' | 'workflow_completed' | 'workflow_stopped' | 'workflow_failed';
 interface WorkflowEvent {
     /** Monotonic sequence number — stable append ordering. */
     readonly seq: number;
@@ -2578,20 +2670,51 @@ interface WorkflowTaskVerificationResult {
 interface WorkflowSpawnAgentInput {
     /** Human-readable label for the agent — surfaces in events / UI. */
     readonly name: string;
+    /**
+     * Optional progress-group tag (FEATURE_246 Part E). When set, this agent is
+     * grouped under a phase of that name in the progress display — the per-agent
+     * equivalent of wrapping a block in `wf.phase(name, fn)`, matching the harness
+     * `agent(..., { phase })`. The phase group is created on first use. Agents
+     * with no `phase` fall under the currently-active `wf.phase(...)` block (if any).
+     */
+    readonly phase?: string;
     /** The task prompt handed to the child agent. */
     readonly prompt: string;
     /** When true, the child runs with a read-only tool whitelist. */
     readonly readOnly?: boolean;
     /** Route to a registered specialist agent (FEATURE_191). */
     readonly subagentType?: string;
-    /** Provider/model tier hint (FEATURE_120 model_hint → env tier). */
+    /**
+     * Per-agent model TIER (FEATURE_120 model_hint). The script expresses semantic
+     * intent — 'fast' (cheap), 'deep' (strong), 'balanced' (default) — NOT a
+     * concrete model name: the authoring model has no cognition of which
+     * providers/models a given operator has configured. The operator maps the
+     * tiers to concrete models via env (KODAX_FAST/DEEP_PROVIDER/MODEL); when a
+     * tier is unconfigured the child inherits the parent provider/model, so a
+     * hint is always a safe no-op at worst. 'fast' applies to read-only children
+     * only (write/codegen stays on the parent tier — a quality guard).
+     */
     readonly modelHint?: WorkflowModelHint;
     /** Isolation policy; defaults to `shared-cwd`. */
     readonly isolation?: WorkflowIsolation;
+    /** Per-child reasoning effort hint (e.g. 'low' | 'medium' | 'high' | 'max').
+     *  The backend maps it onto the child's reasoning resolver; omit to inherit
+     *  the parent/default effort. Opaque string so the agent layer needs no
+     *  coding effort-enum dependency. */
+    readonly effort?: string;
     /** Evidence refs (`task_id:<id>` etc.) seeded into the child context. */
     readonly evidenceRefs?: readonly string[];
     /** Optional machine-checkable postconditions for this child task. */
     readonly verification?: WorkflowTaskVerification;
+    /**
+     * Optional JSON Schema (FEATURE_246 Part B). When set, the child is asked to
+     * end with a fenced JSON block matching the schema; the backend parses and
+     * validates it (with one bounded repair turn on a hard miss) and returns the
+     * parsed object on `WorkflowTaskResult.structured`. Orthogonal to
+     * `verification` (which checks side-effects, not return shape). Carried as an
+     * opaque value so the agent layer needs no JSON-Schema dependency.
+     */
+    readonly outputSchema?: unknown;
 }
 /** Returned by `spawnAgent` — the child is in-flight, not yet complete. */
 interface WorkflowTaskHandle {
@@ -2615,6 +2738,10 @@ interface WorkflowTaskResult {
     readonly name: string;
     readonly status: WorkflowTaskStatus;
     readonly finalText: string;
+    /** Schema-validated structured result (FEATURE_246 Part B), present when the
+     *  spawn carried `outputSchema` and a JSON value was parsed from the child's
+     *  output. The workflow script consumes it directly (e.g. `result.structured`). */
+    readonly structured?: unknown;
     /** Short user-facing digest, separate from the full finalText used for synthesis/audit. */
     readonly digest?: string;
     /** True when a digest was attempted but failed (error/timeout/empty); the UI then labels the excerpt fallback. */
@@ -2692,8 +2819,12 @@ interface WorkflowApi {
     phase<T>(name: string, fn: () => Promise<T>): Promise<T>;
     /** Start a child agent; returns immediately with a handle. */
     spawnAgent(input: WorkflowSpawnAgentInput): Promise<WorkflowTaskHandle>;
-    /** spawnAgent + wait convenience; returns the terminal result. */
-    runAgent(input: WorkflowSpawnAgentInput): Promise<WorkflowTaskResult>;
+    /** spawnAgent + wait convenience; returns the terminal result, or `null` if
+     *  the child ended failed/stopped (FEATURE_246 Part E lenient failure — the
+     *  harness `agent()` semantics, so scripts can `.filter(Boolean)` instead of
+     *  wrapping every call in try/catch). Abort and budget/agent-cap limits still
+     *  throw. */
+    runAgent(input: WorkflowSpawnAgentInput): Promise<WorkflowTaskResult | null>;
     /** Await a spawned agent's terminal result. */
     wait(taskId: string, opts?: WorkflowWaitOptions): Promise<WorkflowTaskResult>;
     /** Snapshot a (possibly running) agent. */
@@ -2707,12 +2838,36 @@ interface WorkflowApi {
     stop(taskId: string, reason: string): Promise<void>;
     /** Run lazy thunks concurrently under the concurrency gate. Thunks
      *  MUST be `() => Promise<T>` (not already-started promises) so the
-     *  runtime can bound concurrency. */
-    parallel<T>(items: readonly (() => Promise<T>)[], opts?: WorkflowParallelOptions): Promise<T[]>;
+     *  runtime can bound concurrency. A thunk that throws (or whose agent fails)
+     *  resolves to `null` in the result array — the call itself never rejects, so
+     *  `.filter(Boolean)` before use (FEATURE_246 Part E, harness parity). Abort
+     *  still tears down the whole run. */
+    parallel<T>(items: readonly (() => Promise<T>)[], opts?: WorkflowParallelOptions): Promise<(T | null)[]>;
+    /**
+     * Stream items through ordered stages with NO barrier between stages: an
+     * item advances to stage N+1 as soon as its own stage N resolves,
+     * independent of other items (wall-clock = slowest single chain, not
+     * sum-of-slowest-per-stage). Each stage receives `(prev, item, index)`
+     * where `prev` is the previous stage's result (the original item at
+     * stage 1). A stage that throws drops that item to `null` and skips its
+     * remaining stages; results preserve input order. Agent spawns inside
+     * stages stay bounded by the workflow `maxConcurrency` gate. Optional:
+     * the restricted-script bootstrap always provides it; SDK consumers get
+     * it from the runtime. */
+    pipeline?(items: readonly unknown[], ...stages: readonly ((prev: unknown, item: unknown, index: number) => unknown)[]): Promise<unknown[]>;
     /** Synthesize across inputs. Runs as a gated agent through the runtime
      *  (spawn → wait), so it counts toward maxAgents / concurrency / budget
      *  and emits run-graph events — it is NOT a backend side-channel. */
     synthesize(input: WorkflowSynthesizeInput): Promise<WorkflowSynthesis>;
+    /**
+     * Run another saved/built-in workflow inline as a sub-step (FEATURE_246 Part E,
+     * harness parity). Resolves the module by name via the host-injected resolver
+     * and runs it under THIS run's runtime — sharing the same concurrency cap,
+     * agent counter, token budget, and abort signal. **One level only**: calling
+     * `workflow(...)` from inside a nested workflow throws. Returns whatever the
+     * sub-workflow's `run` returns. Optional: present when a resolver is wired
+     * (the restricted-script bootstrap provides it; SDK consumers may omit). */
+    workflow?(name: string, args?: unknown): Promise<unknown>;
     /** Persist a named artifact. */
     artifact(name: string, value: unknown): Promise<WorkflowArtifactRef>;
     /** Emit a free-text progress log event. */
@@ -2788,6 +2943,13 @@ interface WorkflowRunState {
 type WorkflowProcessStatus = 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
 type WorkflowProcessItemStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'skipped';
 type WorkflowProcessItemKind = 'phase' | 'agent' | 'step' | 'artifact';
+/**
+ * FEATURE_246 resume telemetry — how an agent item came to be in a resumed run.
+ * `ran` = executed live this run; `replayed-from-cache` = returned instantly from
+ * a prior run's content-addressed result cache (resumeFromRunId). Only populated
+ * on resumed runs; absent on a fresh run (treat absent as `ran`).
+ */
+type WorkflowProcessItemOrigin = 'ran' | 'replayed-from-cache';
 type WorkflowProcessSummaryStatus = 'pending' | 'result' | 'notice' | 'unavailable';
 type WorkflowProcessSource = 'command' | 'amaw' | 'review' | 'sdk' | 'capsule' | 'extension' | 'automation';
 interface WorkflowProcessItem {
@@ -2806,6 +2968,8 @@ interface WorkflowProcessItem {
     readonly summary?: string;
     readonly summaryStatus?: WorkflowProcessSummaryStatus;
     readonly error?: string;
+    /** FEATURE_246 resume telemetry — see {@link WorkflowProcessItemOrigin}. */
+    readonly origin?: WorkflowProcessItemOrigin;
 }
 interface WorkflowEventCorrelation {
     readonly workflowRunId: string;
@@ -2829,6 +2993,10 @@ interface WorkflowProcessProgress {
     readonly stoppedAgents: number;
     readonly agentCap?: number;
     readonly plannedItems?: number;
+    /** FEATURE_246 resume telemetry — count of agents that replayed from a prior
+     *  run's cache (origin `replayed-from-cache`). Present only when > 0, so a
+     *  fresh run's progress is unchanged. */
+    readonly replayedAgents?: number;
 }
 interface WorkflowProcessTokenUsage {
     readonly spent: number;
@@ -2853,6 +3021,9 @@ interface WorkflowProcessSnapshot {
     readonly sourceRunId?: string;
     readonly sourceWorkflowName?: string;
     readonly revisionOf?: string;
+    /** FEATURE_246 resume telemetry — the prior run this run resumed from
+     *  (content-addressed replay). Absent on a fresh (non-resumed) run. */
+    readonly resumedFromRunId?: string;
     readonly hostMetadata?: Record<string, string>;
     readonly activePhaseId?: string;
     readonly activePhaseIndex?: number;
@@ -2887,6 +3058,8 @@ interface WorkflowProcessTrackerOptions {
     readonly sourceRunId?: string;
     readonly sourceWorkflowName?: string;
     readonly revisionOf?: string;
+    /** FEATURE_246 resume telemetry — the prior run this run resumed from. */
+    readonly resumedFromRunId?: string;
     readonly hostMetadata?: Record<string, string>;
     readonly phases?: readonly string[];
     readonly maxAgents?: number;
@@ -2911,5 +3084,5 @@ declare function isFinalWorkflowProcessStatus(status: WorkflowProcessStatus): bo
 declare function normalizeHostMetadata(value: unknown): Record<string, string> | undefined;
 declare function createWorkflowProcessTracker(options: WorkflowProcessTrackerOptions): WorkflowProcessTracker;
 
-export { DEFAULT_SYSTEM_CAP as D, InvariantSession as M, Runner as aC, SpanImpl as aV, MAX_TOOL_LOOP_ITERATIONS as ak, _resetPresetDispatchers as b$, _resetAdmittedAgentBindings as b_, Tracer as bb, WorkflowEventRecorder as bm, buildAssistantMessageFromLlmResult as c0, buildSystemPrompt as c1, buildToolResultMessage as c2, createAgent as c3, createHandoff as c4, createInMemorySession as c5, createInvariantSessionForAgent as c6, createStateWriter as c7, createTrace as c8, createWorkflowProcessTracker as c9, defaultTracer as ca, detectInstructionsInjection as cb, discoverInstances as cc, executeRunnerToolCall as cd, extractAssistantTextFromMessage as ce, getActiveUserInteraction as cf, getAdmittedAgentBindings as cg, isFinalWorkflowProcessStatus as ch, isRunnableTool as ci, isRunnerLlmResult as cj, normalizeHostMetadata as ck, registerChildTask as cl, registerPresetDispatcher as cm, requestTaskStop as cn, runAdmissionAudit as co, setActiveUserInteraction as cp, setAdmittedAgentBindings as cq };
-export type { KodaXSessionData as $, AdmissionAuditOptions as A, HandoffSpanData as B, ChildTaskRegistry as C, EvidenceSpanData as E, FanoutSpanData as F, GenerationSpanData as G, Handoff as H, InMemorySessionOptions as I, InstanceDiscoveryFs as J, InvariantId as K, InvariantResult as L, KodaXCompactMemoryProgress as N, KodaXCompactMemorySeed as O, KodaXExtensionSessionRecord as P, KodaXExtensionSessionState as Q, KodaXExtensionStore as R, KodaXExtensionStoreEntry as S, KodaXGoalEventType as T, KodaXGoalState as U, KodaXGoalStatus as V, KodaXJsonValue as W, KodaXSessionArchiveMarkerEntry as X, KodaXSessionArtifactLedgerEntry as Y, KodaXSessionBranchSummaryEntry as Z, KodaXSessionCompactionEntry as _, AdmissionCtx as a, StopHookContext as a$, KodaXSessionEntry as a0, KodaXSessionEntryBase as a1, KodaXSessionGoalEntry as a2, KodaXSessionLabelEntry as a3, KodaXSessionLineage as a4, KodaXSessionMessageEntry as a5, KodaXSessionMeta as a6, KodaXSessionNavigationOptions as a7, KodaXSessionRuntimeInfo as a8, KodaXSessionScope as a9, RunResult as aA, RunnableTool as aB, RunnerEvent as aD, RunnerLlmResult as aE, RunnerLlmReturn as aF, RunnerToolCall as aG, RunnerToolContext as aH, RunnerToolObserver as aI, RunnerToolResult as aJ, Session as aK, SessionDispatchResult as aL, SessionEntry as aM, SessionErrorMetadata as aN, SessionExtension as aO, SessionForkOptions as aP, SessionMeta as aQ, SessionStateSnapshot as aR, Span as aS, SpanData as aT, SpanError as aU, SpanImplOptions as aW, StartTraceOptions as aX, StateWriter as aY, StateWriterFs as aZ, StateWriterOptions as a_, KodaXSessionStorage as aa, KodaXSessionTreeNode as ab, KodaXSessionUiHistoryItem as ac, KodaXSessionUiHistoryItemType as ad, KodaXSessionUiTextHistoryItem as ae, KodaXSessionUiTextHistoryItemType as af, KodaXSessionUiToolCall as ag, KodaXSessionUiToolCallStatus as ah, KodaXSessionUiToolGroupHistoryItem as ai, KodaXSessionWorkspaceKind as aj, ManifestPatch as al, MessageEntry as am, ObserveCtx as an, PersistedSessionState as ao, PresetDispatcher as ap, PresetTracingContext as aq, QualityInvariant as ar, ReadonlyMutationTracker as as, ReadonlyRecorder as at, ReasoningDepth as au, RecentlyModifiedFile as av, RequestTaskStopOptions as aw, RequestTaskStopResult as ax, RunEvent as ay, RunOptions as az, AdmissionVerdict as b, StopHookFn as b0, StopHookResult as b1, StopHookSpanData as b2, SystemCap as b3, TaskAbortRegistry as b4, TerminalCtx as b5, ToolCallSpanData as b6, ToolCapability as b7, ToolPermission as b8, Trace as b9, WorkflowProcessItemStatus as bA, WorkflowProcessProgress as bB, WorkflowProcessSnapshot as bC, WorkflowProcessSource as bD, WorkflowProcessStatus as bE, WorkflowProcessSummaryStatus as bF, WorkflowProcessTokenUsage as bG, WorkflowProcessTracker as bH, WorkflowProcessTrackerOptions as bI, WorkflowRun as bJ, WorkflowRunState as bK, WorkflowRunStatus as bL, WorkflowSpawnAgentInput as bM, WorkflowSynthesis as bN, WorkflowSynthesizeInput as bO, WorkflowTaskHandle as bP, WorkflowTaskResult as bQ, WorkflowTaskSnapshot as bR, WorkflowTaskStatus as bS, WorkflowTaskSummaryEventUpdate as bT, WorkflowTaskSummaryKind as bU, WorkflowTaskSummaryUpdate as bV, WorkflowTaskUsage as bW, WorkflowTaskVerification as bX, WorkflowTaskVerificationResult as bY, WorkflowWaitOptions as bZ, TraceOptions as ba, TracerOptions as bc, UserInteraction as bd, WorkflowAgentBackend as be, WorkflowApi as bf, WorkflowApproval as bg, WorkflowApprovalSummary as bh, WorkflowArtifactRef as bi, WorkflowBudget as bj, WorkflowEvent as bk, WorkflowEventCorrelation as bl, WorkflowEventType as bn, WorkflowIsolation as bo, WorkflowLimits as bp, WorkflowLogEvent as bq, WorkflowMeta as br, WorkflowModelHint as bs, WorkflowModule as bt, WorkflowParallelOptions as bu, WorkflowProcessArtifact as bv, WorkflowProcessCounts as bw, WorkflowProcessEvent as bx, WorkflowProcessItem as by, WorkflowProcessItemKind as bz, AdmittedHandle as c, Agent as d, AgentManifest as e, AgentMessage as f, AgentMiddlewareDeclaration as g, AgentReasoningProfile as h, AgentSpanData as i, AgentTool as j, AskUserMultiOptions as k, AskUserQuestionItem as l, AskUserQuestionOptions as m, CompactionAnchor as n, CompactionConfig as o, CompactionDetails as p, CompactionResult as q, CompactionSpanData as r, CompactionUpdate as s, CurrentTodoSummary as t, Deliverable as u, DiscoveredInstance as v, DiscoveryOptions as w, FileOperations as x, Guardrail as y, GuardrailSpanData as z };
+export { ASK_USER_BACK_SIGNAL as A, DEFAULT_SYSTEM_CAP as D, InvariantSession as N, Runner as aK, MAX_TOOL_LOOP_ITERATIONS as as, SpanImpl as b1, Tracer as bj, WorkflowEventRecorder as bu, _resetAdmittedAgentBindings as c7, _resetPresetDispatchers as c8, asSingleSelection as c9, setAdmittedAgentBindings as cA, buildAssistantMessageFromLlmResult as ca, buildSystemPrompt as cb, buildToolResultMessage as cc, createAgent as cd, createHandoff as ce, createInMemorySession as cf, createInvariantSessionForAgent as cg, createStateWriter as ch, createTrace as ci, createWorkflowProcessTracker as cj, defaultTracer as ck, detectInstructionsInjection as cl, discoverInstances as cm, executeRunnerToolCall as cn, extractAssistantTextFromMessage as co, getActiveUserInteraction as cp, getAdmittedAgentBindings as cq, isFinalWorkflowProcessStatus as cr, isRunnableTool as cs, isRunnerLlmResult as ct, normalizeHostMetadata as cu, registerChildTask as cv, registerPresetDispatcher as cw, requestTaskStop as cx, runAdmissionAudit as cy, setActiveUserInteraction as cz };
+export type { KodaXInputArtifactSource as $, GuardrailSpanData as B, ChildTaskRegistry as C, EvidenceSpanData as E, FanoutSpanData as F, GenerationSpanData as G, Handoff as H, HandoffSpanData as I, InMemorySessionOptions as J, InstanceDiscoveryFs as K, InvariantId as L, InvariantResult as M, KodaXCompactMemoryProgress as O, KodaXCompactMemorySeed as P, KodaXExtensionSessionRecord as Q, KodaXExtensionSessionState as R, KodaXExtensionStore as S, KodaXExtensionStoreEntry as T, KodaXFileInputArtifact as U, KodaXGoalEventType as V, KodaXGoalState as W, KodaXGoalStatus as X, KodaXImageInputArtifact as Y, KodaXImageMediaType as Z, KodaXInputArtifact as _, AdmissionAuditOptions as a, SpanData as a$, KodaXJsonValue as a0, KodaXSessionArchiveMarkerEntry as a1, KodaXSessionArtifactLedgerEntry as a2, KodaXSessionBranchSummaryEntry as a3, KodaXSessionCompactionEntry as a4, KodaXSessionData as a5, KodaXSessionEntry as a6, KodaXSessionEntryBase as a7, KodaXSessionGoalEntry as a8, KodaXSessionLabelEntry as a9, ReadonlyMutationTracker as aA, ReadonlyRecorder as aB, ReasoningDepth as aC, RecentlyModifiedFile as aD, RequestTaskStopOptions as aE, RequestTaskStopResult as aF, RunEvent as aG, RunOptions as aH, RunResult as aI, RunnableTool as aJ, RunnerEvent as aL, RunnerLlmResult as aM, RunnerLlmReturn as aN, RunnerToolCall as aO, RunnerToolContext as aP, RunnerToolObserver as aQ, RunnerToolResult as aR, Session as aS, SessionDispatchResult as aT, SessionEntry as aU, SessionErrorMetadata as aV, SessionExtension as aW, SessionForkOptions as aX, SessionMeta as aY, SessionStateSnapshot as aZ, Span as a_, KodaXSessionLineage as aa, KodaXSessionMessageEntry as ab, KodaXSessionMeta as ac, KodaXSessionNavigationOptions as ad, KodaXSessionRuntimeInfo as ae, KodaXSessionScope as af, KodaXSessionStorage as ag, KodaXSessionTreeNode as ah, KodaXSessionUiHistoryItem as ai, KodaXSessionUiHistoryItemType as aj, KodaXSessionUiTextHistoryItem as ak, KodaXSessionUiTextHistoryItemType as al, KodaXSessionUiToolCall as am, KodaXSessionUiToolCallStatus as an, KodaXSessionUiToolGroupHistoryItem as ao, KodaXSessionWorkspaceKind as ap, KodaXVideoInputArtifact as aq, KodaXVideoMediaType as ar, ManifestPatch as at, MessageEntry as au, ObserveCtx as av, PersistedSessionState as aw, PresetDispatcher as ax, PresetTracingContext as ay, QualityInvariant as az, AdmissionCtx as b, WorkflowTaskStatus as b$, SpanError as b0, SpanImplOptions as b2, StartTraceOptions as b3, StateWriter as b4, StateWriterFs as b5, StateWriterOptions as b6, StopHookContext as b7, StopHookFn as b8, StopHookResult as b9, WorkflowModelHint as bA, WorkflowModule as bB, WorkflowParallelOptions as bC, WorkflowProcessArtifact as bD, WorkflowProcessCounts as bE, WorkflowProcessEvent as bF, WorkflowProcessItem as bG, WorkflowProcessItemKind as bH, WorkflowProcessItemOrigin as bI, WorkflowProcessItemStatus as bJ, WorkflowProcessProgress as bK, WorkflowProcessSnapshot as bL, WorkflowProcessSource as bM, WorkflowProcessStatus as bN, WorkflowProcessSummaryStatus as bO, WorkflowProcessTokenUsage as bP, WorkflowProcessTracker as bQ, WorkflowProcessTrackerOptions as bR, WorkflowRun as bS, WorkflowRunState as bT, WorkflowRunStatus as bU, WorkflowSpawnAgentInput as bV, WorkflowSynthesis as bW, WorkflowSynthesizeInput as bX, WorkflowTaskHandle as bY, WorkflowTaskResult as bZ, WorkflowTaskSnapshot as b_, StopHookSpanData as ba, SystemCap as bb, TaskAbortRegistry as bc, TerminalCtx as bd, ToolCallSpanData as be, ToolCapability as bf, ToolPermission as bg, Trace as bh, TraceOptions as bi, TracerOptions as bk, UserInteraction as bl, WorkflowAgentBackend as bm, WorkflowApi as bn, WorkflowApproval as bo, WorkflowApprovalSummary as bp, WorkflowArtifactRef as bq, WorkflowBudget as br, WorkflowEvent as bs, WorkflowEventCorrelation as bt, WorkflowEventType as bv, WorkflowIsolation as bw, WorkflowLimits as bx, WorkflowLogEvent as by, WorkflowMeta as bz, AdmissionVerdict as c, WorkflowTaskSummaryEventUpdate as c0, WorkflowTaskSummaryKind as c1, WorkflowTaskSummaryUpdate as c2, WorkflowTaskUsage as c3, WorkflowTaskVerification as c4, WorkflowTaskVerificationResult as c5, WorkflowWaitOptions as c6, AdmittedHandle as d, Agent as e, AgentManifest as f, AgentMessage as g, AgentMiddlewareDeclaration as h, AgentReasoningProfile as i, AgentSpanData as j, AgentTool as k, AskUserMultiOptions as l, AskUserQuestionItem as m, AskUserQuestionOptions as n, CompactionAnchor as o, CompactionConfig as p, CompactionDetails as q, CompactionResult as r, CompactionSpanData as s, CompactionUpdate as t, CurrentTodoSummary as u, Deliverable as v, DiscoveredInstance as w, DiscoveryOptions as x, FileOperations as y, Guardrail as z };

package/dist/types-chunks/{resolver.d-ZvKQgl0X.d.ts → resolver.d-DFAKKUvt.d.ts}

@@ -1,6 +1,6 @@
-import { E as KodaXReasoningMode, L as KodaXStableEffortIntent, a6 as KodaXWireReasoningEffort, F as KodaXReasoningProfile, W as KodaXThinkingBudgetMap, X as KodaXThinkingDepth, p as KodaXProviderConfig, A as KodaXReasoningCapability, G as KodaXReasoningRequest, m as KodaXNormalizedReasoningRequest, S as KodaXTaskType, a4 as KodaXVerifyCredentialResult, _ as KodaXToolDefinition, j as KodaXMessage, x as KodaXProviderStreamOptions, M as KodaXStreamResult, k as KodaXModelDescriptor, o as KodaXProviderCapabilityProfile, a5 as KodaXVerifyStrategy, d as KodaXCustomProviderConfig, i as KodaXListModelsResult } from './types.d-6VOXvF88.js';
+import { E as KodaXReasoningMode, L as KodaXStableEffortIntent, a6 as KodaXWireReasoningEffort, F as KodaXReasoningProfile, W as KodaXThinkingBudgetMap, X as KodaXThinkingDepth, p as KodaXProviderConfig, A as KodaXReasoningCapability, G as KodaXReasoningRequest, m as KodaXNormalizedReasoningRequest, S as KodaXTaskType, a4 as KodaXVerifyCredentialResult, _ as KodaXToolDefinition, j as KodaXMessage, x as KodaXProviderStreamOptions, M as KodaXStreamResult, k as KodaXModelDescriptor, o as KodaXProviderCapabilityProfile, a5 as KodaXVerifyStrategy, d as KodaXCustomProviderConfig, i as KodaXListModelsResult } from './types.d-Ci5YPFEh.js';
 import Anthropic from '@anthropic-ai/sdk';
-import { K as KodaXBaseProvider } from './base.d-BnjQrSVf.js';
+import { K as KodaXBaseProvider } from './base.d-BA9Doaj_.js';
 import OpenAI from 'openai';
 
 /**
@@ -86,6 +86,60 @@ declare function resolveThinkingBudget(config: KodaXProviderConfig, depth: KodaX
 declare function clampThinkingBudget(requestedBudget: number, maxOutputTokens: number, safetyReserve?: number): number;
 declare function mapDepthToOpenAIReasoningEffort(depth: KodaXThinkingDepth): 'low' | 'medium' | 'high' | undefined;
 
+/**
+ * FEATURE_222 (R6) — canonical host-facing reasoning-effort resolver.
+ *
+ * Mapping a user's desired reasoning strength to the actual wire `effort` value
+ * for a provider/model means composing several pieces that already exist but
+ * were only wired together privately inside the REPL: the model's reasoning
+ * profile (`resolveModelCapabilities`), the learned hard-rejection cache
+ * (`narrowReasoningProfile`), and the alias/disabled/ceiling/default resolution
+ * (`resolveReasoningEffort`). A host that re-assembles these by hand drifts.
+ *
+ * `resolveWireEffort` is the single entry point: give it a provider/model + the
+ * desired effort (+ any learned rejected efforts) and it returns the legal wire
+ * effort — or `undefined`, which is a deliberate "omit reasoning_effort" signal
+ * (e.g. anthropic-adaptive, or a provider with no reasoning). It reuses the
+ * existing pure functions verbatim; no new resolution logic.
+ */
+interface ResolveWireEffortInput {
+    /** Provider id (built-in alias or registered custom provider name). */
+    readonly provider: string;
+    /** Model id. Omit to use the provider's default model. */
+    readonly model?: string;
+    /** The desired reasoning strength (a wire effort or tier the user requested).
+     *  Treated as a non-explicit session preference: an unsupported value falls
+     *  back to a legal one rather than throwing. */
+    readonly desiredEffort?: string;
+    /** Learned hard-rejected efforts for this provider/model (e.g. from the agent
+     *  layer's `getCachedRejectedEfforts`). Removed from the ladder before
+     *  resolving, so a rejected rung is never re-selected. */
+    readonly rejectedEfforts?: readonly string[];
+}
+interface ResolvedWireEffort {
+    /** The legal wire effort to send, or `undefined` to omit reasoning_effort
+     *  entirely (adaptive/none — NOT a fallback to `configuredEffort`). */
+    readonly effort: string | undefined;
+    /** What the input resolved to before profile-driven adjustment (alias/
+     *  ceiling/disable). Useful for a "requested X → sending Y" status label. */
+    readonly configuredEffort: string | undefined;
+    /**
+     * True when the wire effort differs from the configured one — aliased, ceiled,
+     * disabled-folded, or narrowed by a rejection. NOTE: this is also true for a
+     * plain `desiredEffort: 'auto'` (configuredEffort `'auto'` resolves to a
+     * concrete rung), so do NOT read `adjusted` as "the user's explicit choice was
+     * overridden"; compare `configuredEffort` vs `effort` yourself if you need to
+     * exclude the auto→concrete case in a status label.
+     */
+    readonly adjusted: boolean;
+}
+/**
+ * Resolve the wire-level reasoning effort for a provider/model + desired
+ * strength, honoring alias/disabled/ceiling/default rules and learned
+ * rejections. Pure — no I/O, no throw.
+ */
+declare function resolveWireEffort(input: ResolveWireEffortInput): ResolvedWireEffort;
+
 /**
  * KodaX Anthropic Compatible Provider
  *
@@ -141,6 +195,14 @@ declare abstract class KodaXAnthropicCompatProvider extends KodaXBaseProvider {
      * original string unchanged so prompt caching can be disabled at
      * runtime without redeploying.
      */
+    /**
+     * Run-scoped (concurrency-safe) config wins over the global env, in BOTH
+     * directions: an SDK caller that explicitly sets `disablePromptCache: false`
+     * re-enables caching even when `KODAX_DISABLE_PROMPT_CACHE=1` is set at
+     * startup (e.g. bridged from `config.json`). A plain `||` would let the env
+     * win in that re-enable case, breaking the documented SDK > env precedence.
+     */
+    private isPromptCacheDisabled;
     protected applyCacheControlToSystem(systemText: string): string | Anthropic.Messages.TextBlockParam[];
     /**
      * FEATURE_116 (v0.7.37) — Mark the last tool definition as the cache
@@ -151,6 +213,27 @@ declare abstract class KodaXAnthropicCompatProvider extends KodaXBaseProvider {
      * Returns a new array; never mutates input.
      */
     protected applyCacheControlToTools(tools: KodaXToolDefinition[]): Anthropic.Messages.Tool[];
+    /**
+     * FEATURE_116 follow-up — Place an incremental cache breakpoint on the
+     * conversation history (Anthropic breakpoint 3). The system prompt and
+     * tools already carry breakpoints 1 & 2 (applyCacheControlToSystem /
+     * applyCacheControlToTools); without a message-level breakpoint the whole
+     * growing transcript is re-billed as uncached input every turn.
+     *
+     * Strategy: mark the LAST content block of the second-to-last `user` turn.
+     * The most recent user turn is skipped — it is the current, still-changing
+     * input. The prior user turn's content is settled, so its prefix is a stable
+     * cache write-point that later turns read back incrementally (Anthropic caches
+     * the whole prefix up to and including the marked block: tools + system + all
+     * earlier messages). Total breakpoints stay at 3 (≤ Anthropic's limit of 4).
+     *
+     * Only anthropic-compat providers reach this path; OpenAI/ACP strip cache
+     * markers and rely on upstream automatic prefix caching. Escape hatch:
+     * `KODAX_DISABLE_PROMPT_CACHE=1` returns the array untouched.
+     *
+     * Returns a new array; never mutates input.
+     */
+    protected applyCacheControlToMessages(messages: Anthropic.Messages.MessageParam[]): Anthropic.Messages.MessageParam[];
     stream(messages: KodaXMessage[], tools: KodaXToolDefinition[], system: string, reasoning?: boolean | KodaXReasoningRequest, streamOptions?: KodaXProviderStreamOptions, signal?: AbortSignal): Promise<KodaXStreamResult>;
     supportsNonStreamingFallback(): boolean;
     complete(messages: KodaXMessage[], tools: KodaXToolDefinition[], system: string, reasoning?: boolean | KodaXReasoningRequest, streamOptions?: KodaXProviderStreamOptions, signal?: AbortSignal): Promise<KodaXStreamResult>;
@@ -565,5 +648,5 @@ declare function listProviderModels(name: string, _opts?: {
     signal?: AbortSignal;
 }): Promise<KodaXListModelsResult>;
 
-export { parseReasoningEffortEnv as $, getModelCapabilities as A, getProvider as B, getProviderConfiguredCapabilityProfile as C, getProviderConfiguredReasoningCapability as D, getProviderList as E, getProviderModel as F, getProviderModelDescriptors as G, getProviderModels as H, getReasoningCapability as I, getRuntimeModelProvider as J, KODAX_DEFAULT_PROVIDER as K, getRuntimeModelProviderNames as L, isCustomProviderName as M, isKnownProvider as N, isProviderConfigured as O, isProviderName as Q, isReasoningEnabled as R, isRuntimeModelProviderName as S, listAllModelCapabilities as T, listBuiltinModelCapabilities as U, listCustomProviderModelCapabilities as V, listProviderModels as W, mapDepthToOpenAIReasoningEffort as X, mapLegacyReasoningModeToEffortIntent as Y, normalizeReasoningEffortValue as Z, normalizeReasoningRequest as _, KODAX_DEFAULT_THINKING_BUDGETS as a, registerCustomProviders as a0, registerModelProvider as a1, resolveModelCapabilities as a2, resolveProvider as a3, resolveProviderModelDescriptors as a4, resolveReasoningEffort as a5, resolveReasoningEffortForModelSwitch as a6, resolveThinkingBudget as a7, validateCustomProviderConfig as a8, verifyProviderCredential as a9, KODAX_PROVIDERS as b, KODAX_PROVIDER_SNAPSHOTS as c, KODAX_REASONING_MODE_SEQUENCE as d, KODAX_REASONING_SAFETY_RESERVE as e, KODAX_STABLE_EFFORT_INTENTS as f, KodaXAnthropicCompatProvider as g, KodaXError as h, KodaXNetworkError as j, KodaXOpenAICompatProvider as k, KodaXProviderError as l, KodaXRateLimitError as m, KodaXToolCallIdError as n, clampThinkingBudget as o, clearRuntimeModelProviders as p, createCustomProvider as q, effortToLegacyReasoningMode as r, getAvailableProviderNames as s, getCustomModelCapabilities as t, getCustomProvider as u, getCustomProviderList as v, getCustomProviderModelDescriptors as w, getCustomProviderModels as x, getCustomProviderNames as y, getDefaultThinkingDepthForMode as z };
-export type { ProviderName as P, KodaXModelCapabilities as i };
+export { normalizeReasoningEffortValue as $, getDefaultThinkingDepthForMode as A, getModelCapabilities as B, getProvider as C, getProviderConfiguredCapabilityProfile as D, getProviderConfiguredReasoningCapability as E, getProviderList as F, getProviderModel as G, getProviderModelDescriptors as H, getProviderModels as I, getReasoningCapability as J, KODAX_DEFAULT_PROVIDER as K, getRuntimeModelProvider as L, getRuntimeModelProviderNames as M, isCustomProviderName as N, isKnownProvider as O, isProviderConfigured as Q, isProviderName as S, isReasoningEnabled as T, isRuntimeModelProviderName as U, listAllModelCapabilities as V, listBuiltinModelCapabilities as W, listCustomProviderModelCapabilities as X, listProviderModels as Y, mapDepthToOpenAIReasoningEffort as Z, mapLegacyReasoningModeToEffortIntent as _, KODAX_DEFAULT_THINKING_BUDGETS as a, normalizeReasoningRequest as a0, parseReasoningEffortEnv as a1, registerCustomProviders as a2, registerModelProvider as a3, resolveModelCapabilities as a4, resolveProvider as a5, resolveProviderModelDescriptors as a6, resolveReasoningEffort as a7, resolveReasoningEffortForModelSwitch as a8, resolveThinkingBudget as a9, resolveWireEffort as aa, validateCustomProviderConfig as ab, verifyProviderCredential as ac, KODAX_PROVIDERS as b, KODAX_PROVIDER_SNAPSHOTS as c, KODAX_REASONING_MODE_SEQUENCE as d, KODAX_REASONING_SAFETY_RESERVE as e, KODAX_STABLE_EFFORT_INTENTS as f, KodaXAnthropicCompatProvider as g, KodaXError as h, KodaXNetworkError as j, KodaXOpenAICompatProvider as k, KodaXProviderError as l, KodaXRateLimitError as m, KodaXToolCallIdError as n, clampThinkingBudget as p, clearRuntimeModelProviders as q, createCustomProvider as r, effortToLegacyReasoningMode as s, getAvailableProviderNames as t, getCustomModelCapabilities as u, getCustomProvider as v, getCustomProviderList as w, getCustomProviderModelDescriptors as x, getCustomProviderModels as y, getCustomProviderNames as z };
+export type { ProviderName as P, ResolveWireEffortInput as R, KodaXModelCapabilities as i, ResolvedWireEffort as o };