@kodax-ai/kodax 0.7.55 → 0.7.57

package/dist/types-chunks/{types.d-D4jL-gAA.d.ts → guardrail.d-BP3yyr6u.d.ts}

@@ -1,4 +1,4 @@
-import { y as Guardrail, aG as RunnerToolCall, d as Agent, f as AgentMessage, aJ as RunnerToolResult, aS as Span } from './process.d-Bj82oJhD.js';
+import { y as Guardrail, aG as RunnerToolCall, d as Agent, f as AgentMessage, aJ as RunnerToolResult, aS as Span } from './process.d-BZncyzEj.js';
 
 /**
  * Guardrail Runtime — FEATURE_085 (v0.7.26).
@@ -151,123 +151,5 @@ declare function runToolBeforeGuardrails(call: RunnerToolCall, guardrails: reado
  */
 declare function runToolAfterGuardrails(call: RunnerToolCall, result: RunnerToolResult, guardrails: readonly ToolGuardrail[], ctx: GuardrailContext, agentSpan: Span | null): Promise<RunnerToolResult>;
 
-/**
- * @kodax-ai/agent/messaging — Message queue types
- *
- * FEATURE_115 (v0.7.36): agentId-scoped 2-tier priority queue infrastructure.
- *
- * Per ADR-021: messaging is a generic agent-platform primitive (not coding-
- * specific). Downstream consumers:
- *   - @kodax-ai/coding runner-driven mid-turn drain
- *   - @kodax-ai/repl InkREPL ESC soft-pause + text injection (FEATURE_111 absorbed)
- *   - subagent task-notification routing (FEATURE_155 idle-yield wakeup)
- *
- * Phase 0.6 study (`c:/tmp/claude-code-actual-usage.md`): Claude Code's
- * `'now'` priority has zero production usage; KodaX simplifies to 2 tiers.
- */
-type MessagePriority = 'user' | 'background';
-type MessageMode = 'prompt' | 'task-notification' | 'system-reminder';
-interface QueuedMessage {
-    /** Stable id for tracing / dedup. Format: `msg-<sequence>`. */
-    readonly id: string;
-    readonly priority: MessagePriority;
-    /**
-     * Routing key:
-     *   undefined = main thread / coordinator agent
-     *   'agent-id-XYZ' = subagent / specific consumer
-     *
-     * Drain consumers MUST filter by agentId match — undefined matches only
-     * undefined-agentId messages, not "any agent".
-     */
-    readonly agentId?: string;
-    readonly mode: MessageMode;
-    readonly content: string;
-    /** Wall-clock timestamp (`Date.now()`) for tracing only — not used for ordering. */
-    readonly enqueuedAt: number;
-}
-interface DequeueFilter {
-    /**
-     * Only return messages with this agentId.
-     * undefined matches messages with no agentId (main-thread messages only).
-     */
-    readonly agentId?: string;
-    /**
-     * Highest priority level included in the drain.
-     *   'user'       → only user priority drained, background stays queued
-     *   'background' → both user + background drained (Sleep-gated case)
-     */
-    readonly maxPriority: MessagePriority;
-    /**
-     * Optional cap on number of messages drained in this call.
-     * Defaults to unlimited (drains all matching).
-     */
-    readonly limit?: number;
-    /**
-     * FEATURE_159 (v0.7.40) — optional mode filter. Lets REPL split the
-     * single queue into mode-typed views (e.g. `mode:'prompt'` for user
-     * input vs `mode:'task-notification'` for child completion banners)
-     * without separate queues. When omitted, all modes match.
-     */
-    readonly mode?: MessageMode;
-    /**
-     * FEATURE_159 (v0.7.40) — optional precise-id filter. Single-message
-     * targeted removal — drives Esc-pop-this-uuid in REPL. When set, all
-     * other filters still apply (agentId / priority / mode mismatches still
-     * skip the message), so callers can't accidentally remove a message
-     * outside their scope.
-     */
-    readonly id?: string;
-    /**
-     * FEATURE_159 (v0.7.40) — optional escape-hatch predicate, AND-ed with
-     * the structured filters. Lets SDK consumers express conditions the
-     * typed fields don't cover (e.g. timestamp ranges, content-match) without
-     * forcing every new use case to extend `DequeueFilter`. KodaX-internal
-     * code should prefer the typed fields for readability; this is the
-     * "data-driven main path + predicate escape" pattern.
-     *
-     * Evaluated AFTER the typed filters succeed — so a `predicate` that
-     * inspects `message.content` never runs on messages outside the
-     * caller's `agentId` / `mode` / `id` scope.
-     */
-    readonly predicate?: (message: QueuedMessage) => boolean;
-}
-/**
- * FEATURE_159 (v0.7.40) — structured queue event emitted to subscribers.
- *
- * Replaces the prior `() => void` bare-notify signal. Carries the kind +
- * affected messages so SDK observability consumers (logging, tracing,
- * metrics) can react per-event without re-diffing snapshots.
- *
- * Event granularity rules:
- *   - `enqueued` fires ONCE per `enqueue()` call (always 1 message).
- *   - `dequeued` fires ONCE per `dequeue()` call that removed ≥1 message,
- *     carrying ALL drained messages in priority+FIFO order. No-op drains
- *     (filter matched nothing) fire no event — quiet by design so the
- *     `waitForWakeEvent` 100ms poll doesn't spam idle subscribers.
- *   - `cleared` fires ONCE per `clear()` call that removed ≥1 message,
- *     carrying the pre-clear messages. Empty-queue clear fires nothing.
- *
- * The `useSyncExternalStore` React hook ignores the event payload (it
- * only needs the change signal); SDK / tracer consumers read the event.
- */
-type QueueEvent = {
-    readonly kind: 'enqueued';
-    readonly message: QueuedMessage;
-} | {
-    readonly kind: 'dequeued';
-    readonly messages: readonly QueuedMessage[];
-} | {
-    readonly kind: 'cleared';
-    readonly messages: readonly QueuedMessage[];
-};
-/** FEATURE_159 — `MessageQueue.subscribe` listener signature. */
-type QueueEventListener = (event: QueueEvent) => void;
-interface EnqueueInput {
-    readonly priority: MessagePriority;
-    readonly mode: MessageMode;
-    readonly content: string;
-    readonly agentId?: string;
-}
-
-export { GuardrailBlockedError as G, GuardrailEscalateError as b, collectGuardrails as g, runOutputGuardrails as h, runToolAfterGuardrails as i, runToolBeforeGuardrails as j, runInputGuardrails as r };
-export type { DequeueFilter as D, EnqueueInput as E, InputGuardrail as I, MessageMode as M, OutputGuardrail as O, QueueEventListener as Q, ToolBeforeOutcome as T, GuardrailContext as a, GuardrailVerdict as c, MessagePriority as d, QueuedMessage as e, ToolGuardrail as f };
+export { GuardrailBlockedError as G, GuardrailEscalateError as b, collectGuardrails as e, runOutputGuardrails as f, runToolAfterGuardrails as g, runToolBeforeGuardrails as h, runInputGuardrails as r };
+export type { InputGuardrail as I, OutputGuardrail as O, ToolBeforeOutcome as T, GuardrailContext as a, GuardrailVerdict as c, ToolGuardrail as d };

package/dist/types-chunks/{guardrail.d-B18oO1gt.d.ts → guardrail.d-C1DhxnvC.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 { f as KodaXBaseProvider } from './base.d-BBNUF9nz.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-Bj82oJhD.js';
-import { f as ToolGuardrail } from './types.d-D4jL-gAA.js';
+import { aG as RunnerToolCall } from './process.d-BZncyzEj.js';
+import { d as ToolGuardrail } from './guardrail.d-BP3yyr6u.js';
 
 /**
  * FEATURE_200 Phase F (v0.7.45) — MCP domain types extracted from types.ts.
@@ -360,6 +360,21 @@ signals?: readonly ToolCallSignal[]) => Promise<AutoModeAskUserVerdict>;
 interface AutoModeGuardrailConfig {
     readonly rules: AutoRules;
     readonly claudeMd?: string;
+    /**
+     * FEATURE_092 follow-up (auto-mode classifier AGENTS.md staleness fix):
+     * live getter for the project AGENTS.md content. Takes precedence over the
+     * static `claudeMd` string and is evaluated INSIDE the classify path on
+     * every call — same live-getter pattern as `getDefaultProvider` /
+     * `getDefaultModel` (v0.7.34 hotfix-3).
+     *
+     * The bug it fixes: the guardrail is a lazy-cached singleton, so a
+     * captured `claudeMd` string froze the project rules at first
+     * construction. Even `/reload` couldn't refresh it — the classifier kept
+     * judging tool calls against a stale AGENTS.md snapshot. The REPL wires
+     * this to `loadAgentsFiles` (mtime-cached), so the classifier sees the
+     * same fresh project rules the system prompt does.
+     */
+    readonly getClaudeMd?: () => string | undefined;
     /**
      * FEATURE_092 phase 2b.7b: optional user-prompt callback for escalate
      * paths. See `AutoModeAskUser` for semantics.
@@ -470,14 +485,21 @@ interface AutoModeGuardrailConfig {
     /**
      * Speculative-classify quiet window (ms). When a classifier promise
      * settles within this window, the guardrail uses the verdict directly
-     * (no confirm dialog). When the window expires, the call escalates to
-     * the user; the background classifier is left running for cost-tracker
-     * settlement but its eventual result is discarded in v1 (UI doesn't
-     * adopt late verdicts yet).
+     * with no perceptible latency.
+     *
+     * Issue 143 (WS1): when the window expires the guardrail does NOT
+     * hard-escalate — it waits for the real classifier verdict and adopts it
+     * (late-verdict adoption). The window therefore only controls "fast path
+     * vs wait", never "dialog vs no dialog": an `allow` never surfaces a
+     * confirm dialog regardless of how long the classifier takes, and only an
+     * `escalate` verdict (explicit LLM escalation, classifier timeout, or infra
+     * error — all mapped to `escalate` by classify()) reaches the user.
+     * The background classifier's cost is settled exactly once inside
+     * classify(), so awaiting it after window expiry does not double-count.
      *
      * Precedence: explicit arg > `KODAX_AUTO_SPECULATIVE_WINDOW_MS` env >
-     * `DEFAULT_WINDOW_MS = 500`. Set to 0 to disable speculative race
-     * (degrades to synchronous classify).
+     * `DEFAULT_WINDOW_MS = 500`. Set to 0 to disable the speculative race
+     * (degrades to a synchronous classify — identical verdict outcome).
      */
     readonly speculativeWindowMs?: number;
 }

package/dist/types-chunks/{manager.d-DLmDhX3i.d.ts → manager.d-DBD7SOTT.d.ts}

@@ -47,6 +47,11 @@ interface McpCatalogSearchOptions {
 }
 declare function defaultMcpCacheDir(): string;
 declare function createMcpCapabilityId(serverId: string, kind: McpCapabilityKind, name: string): string;
+/**
+ * Applied defensively at handler, provider, and parse boundaries.
+ * Keep this idempotent so stacked normalization remains harmless.
+ */
+declare function normalizeMcpCapabilityId(id: string): string;
 declare function parseMcpCapabilityId(id: string): {
     serverId: string;
     kind: McpCapabilityKind;
@@ -678,7 +683,7 @@ declare class McpManager {
     }): Promise<readonly McpCatalogItem[]>;
     /** v0.7.42 — escape hatch for advanced uses; usually consumers use {@link listTools}. */
     describe(id: string): Promise<McpCapabilityDescriptor | undefined>;
-    /** v0.7.42 — invoke a tool by capability id (`mcp://<serverId>/<kind>/<name>`). */
+    /** v0.7.42 — invoke a tool by capability id (`mcp:<serverId>:tool:<name>`). */
     execute(id: string, input: Record<string, unknown>): Promise<CapabilityResult>;
     /** v0.7.42 — read a resource by capability id. */
     read(id: string, options?: Record<string, unknown>): Promise<CapabilityResult>;
@@ -692,5 +697,5 @@ declare class McpManager {
  */
 declare function createMcpManager(servers: McpServersConfig | undefined, options?: McpProviderOptions): McpManager;
 
-export { buildInitializeCapabilities as C, createMcpCapabilityId as E, createMcpManager as F, createMcpTransport as G, defaultMcpCacheDir as H, discoverAuthorizationServerMetadata as I, discoverOAuthEndpoints as J, discoverProtectedResourceMetadata as K, extractInsufficientScope as L, McpAuthRequiredError as M, extractResourceMetadataUrl as N, getMcpCachePaths as Q, loadValidToken as R, parseMcpCapabilityId as S, performOAuthLogin as T, registerOAuthClient as U, searchMcpCatalog as V, McpCapabilityProvider as c, McpExpiredSessionError as h, McpManager as j, McpServerRuntime as s };
+export { buildInitializeCapabilities as C, createMcpCapabilityId as E, createMcpManager as F, createMcpTransport as G, defaultMcpCacheDir as H, discoverAuthorizationServerMetadata as I, discoverOAuthEndpoints as J, discoverProtectedResourceMetadata as K, extractInsufficientScope as L, McpAuthRequiredError as M, extractResourceMetadataUrl as N, getMcpCachePaths as Q, loadValidToken as R, normalizeMcpCapabilityId as S, parseMcpCapabilityId as T, performOAuthLogin as U, registerOAuthClient as V, searchMcpCatalog as X, McpCapabilityProvider as c, McpExpiredSessionError as h, McpManager as j, McpServerRuntime as s };
 export type { AuthorizationServerMetadata as A, ProtectedResourceMetadata as B, DiscoveredOAuthEndpoints as D, OAuthClientInfo as O, PerformOAuthLoginOptions as P, WwwAuthenticateChallenge as W, McpCapabilityDescriptor as a, McpCapabilityKind as b, McpCapabilityRisk as d, McpCatalogItem as e, McpElicitRequest as f, McpElicitResult as g, McpIcon as i, McpProviderOptions as k, McpReverseCapabilities as l, McpRoot as m, McpSamplingRequest as n, McpSamplingResult as o, McpServerCatalog as p, McpServerCatalogSnapshot as q, McpServerLogs as r, McpServerRuntimeDiagnostics as t, McpServerStatus as u, McpServerToolList as v, McpToolTaskSupport as w, McpTransport as x, McpTransportEvents as y, OAuthLoginConsent as z };

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

@@ -1,4 +1,4 @@
-import { o as KodaXMessage, $ as KodaXToolDefinition, G as KodaXReasoningMode, a1 as KodaXToolResultContentItem, X as KodaXThinkingBlock, J as KodaXRedactedThinkingBlock } from './base.d-BBNUF9nz.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-6VOXvF88.js';
 
 /**
  * @kodax-ai/agent Types
@@ -447,6 +447,7 @@ interface Agent<TContext = unknown> {
     readonly outputSchema?: unknown;
     readonly model?: string;
     readonly provider?: string;
+    readonly effort?: KodaXWireReasoningEffort;
     /**
      * FEATURE_100 (v0.7.29) substrate executor: when set, `Runner.run`
      * delegates execution to this function instead of consulting the

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

@@ -1,5 +1,6 @@
-import { G as KodaXReasoningMode, Y as KodaXThinkingBudgetMap, Z as KodaXThinkingDepth, u as KodaXProviderConfig, F as KodaXReasoningCapability, I as KodaXReasoningRequest, U as KodaXTaskType, H as KodaXReasoningOverride, f as KodaXBaseProvider, a5 as KodaXVerifyCredentialResult, $ as KodaXToolDefinition, o as KodaXMessage, C as KodaXProviderStreamOptions, O as KodaXStreamResult, p as KodaXModelDescriptor, t as KodaXProviderCapabilityProfile, a6 as KodaXVerifyStrategy, i as KodaXCustomProviderConfig, n as KodaXListModelsResult } from './base.d-BBNUF9nz.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-6VOXvF88.js';
 import Anthropic from '@anthropic-ai/sdk';
+import { K as KodaXBaseProvider } from './base.d-BnjQrSVf.js';
 import OpenAI from 'openai';
 
 /**
@@ -33,23 +34,58 @@ declare class KodaXToolCallIdError extends KodaXError {
 }
 
 declare const KODAX_REASONING_MODE_SEQUENCE: KodaXReasoningMode[];
+declare const KODAX_STABLE_EFFORT_INTENTS: KodaXStableEffortIntent[];
 declare const KODAX_DEFAULT_THINKING_BUDGETS: KodaXThinkingBudgetMap;
 declare const KODAX_REASONING_SAFETY_RESERVE = 4096;
 declare function getReasoningCapability(config: KodaXProviderConfig): KodaXReasoningCapability;
 declare function isReasoningEnabled(reasoning?: boolean | KodaXReasoningRequest): boolean;
-declare function normalizeReasoningRequest(reasoning?: boolean | KodaXReasoningRequest): Required<KodaXReasoningRequest>;
+declare function normalizeReasoningRequest(reasoning?: boolean | KodaXReasoningRequest): KodaXNormalizedReasoningRequest;
+type KodaXReasoningEffortEnvOverride = {
+    kind: 'unset';
+} | {
+    kind: 'clear';
+} | {
+    kind: 'value';
+    value: KodaXWireReasoningEffort;
+};
+type KodaXReasoningEffortSource = 'env' | 'explicit' | 'session' | 'legacy' | 'model-default' | 'provider-default' | 'fallback';
+interface KodaXResolvedReasoningEffort {
+    readonly configuredEffort: KodaXWireReasoningEffort;
+    readonly effectiveEffort?: KodaXWireReasoningEffort;
+    readonly source: KodaXReasoningEffortSource;
+    readonly isExplicit: boolean;
+    readonly diagnostics: readonly string[];
+}
+interface KodaXResolveReasoningEffortInput {
+    readonly capability?: KodaXReasoningProfile;
+    readonly envEffort?: string;
+    readonly explicitEffort?: string;
+    readonly sessionEffort?: string;
+    readonly legacyReasoningMode?: KodaXReasoningMode;
+    readonly thinking?: boolean;
+    readonly modelDefaultEffort?: string;
+    readonly providerDefaultEffort?: string;
+    readonly fallbackEffort?: string;
+}
+interface KodaXModelSwitchEffortResolution {
+    readonly effectiveEffort?: KodaXWireReasoningEffort;
+    readonly preserved: boolean;
+    readonly diagnostic?: string;
+}
+declare function normalizeReasoningEffortValue(value: string): KodaXWireReasoningEffort;
+declare function mapLegacyReasoningModeToEffortIntent(mode: KodaXReasoningMode): KodaXStableEffortIntent;
+declare function effortToLegacyReasoningMode(effort: string | undefined): KodaXReasoningMode | undefined;
+declare function parseReasoningEffortEnv(raw: string | undefined): KodaXReasoningEffortEnvOverride;
+declare function resolveReasoningEffort(input: KodaXResolveReasoningEffortInput): KodaXResolvedReasoningEffort;
+declare function resolveReasoningEffortForModelSwitch(input: {
+    readonly currentEffort: string | undefined;
+    readonly capability?: KodaXReasoningProfile;
+}): KodaXModelSwitchEffortResolution;
 declare function getDefaultThinkingDepthForMode(mode: KodaXReasoningMode): KodaXThinkingDepth;
 declare function resolveThinkingBudget(config: KodaXProviderConfig, depth: KodaXThinkingDepth, taskType?: KodaXTaskType): number;
 declare function clampThinkingBudget(requestedBudget: number, maxOutputTokens: number, safetyReserve?: number): number;
 declare function mapDepthToOpenAIReasoningEffort(depth: KodaXThinkingDepth): 'low' | 'medium' | 'high' | undefined;
 
-declare function reasoningCapabilityToOverride(capability: KodaXReasoningCapability): KodaXReasoningOverride | undefined;
-declare function reasoningOverrideToCapability(override: KodaXReasoningOverride): KodaXReasoningCapability;
-declare function buildReasoningOverrideKey(providerName: string, config: Pick<KodaXProviderConfig, 'baseUrl' | 'model'>, modelOverride?: string): string;
-declare function loadReasoningOverride(providerName: string, config: Pick<KodaXProviderConfig, 'baseUrl' | 'model'>, modelOverride?: string): KodaXReasoningOverride | undefined;
-declare function saveReasoningOverride(providerName: string, config: Pick<KodaXProviderConfig, 'baseUrl' | 'model'>, override: KodaXReasoningOverride, modelOverride?: string): void;
-declare function clearReasoningOverride(providerName: string, config: Pick<KodaXProviderConfig, 'baseUrl' | 'model'>, modelOverride?: string): void;
-
 /**
  * KodaX Anthropic Compatible Provider
  *
@@ -72,6 +108,9 @@ declare abstract class KodaXAnthropicCompatProvider extends KodaXBaseProvider {
     protected set client(client: Anthropic);
     protected buildClient(): Anthropic;
     protected onStaleConnection(): void;
+    private buildMessageCreateOptions;
+    private applyReasoningProfile;
+    private resolveReasoningProfileBudget;
     /**
      * FEATURE_216 v0.7.45 — Lightweight credential verification.
      * Dispatches by `this.config.verifyStrategy`:
@@ -118,6 +157,24 @@ declare abstract class KodaXAnthropicCompatProvider extends KodaXBaseProvider {
     private serializeSystemMessageContent;
     private buildSystemPrompt;
     private convertMessages;
+    /**
+     * Wire-only defense-in-depth: drop orphan `tool_use` / `tool_result` blocks
+     * so the Anthropic API never 400s on "tool_use ids ... were not found in
+     * tool_result blocks" or "unexpected tool_result". The upstream
+     * `validateAndFixToolHistory` (run every turn before serialization) is the
+     * primary guard; this mirrors the OpenAI-side `repairToolCallHistory` so
+     * both provider families have the same last-mile net for any path that
+     * bypasses validate (custom callers, side queries). Never mutates input.
+     *
+     * Pairing is computed against adjacent messages (same rule as validate): a
+     * `tool_use` is orphan when the immediately-following user message has no
+     * matching `tool_result`; a `tool_result` is orphan when the
+     * immediately-preceding assistant message has no matching `tool_use`. A
+     * message emptied by repair is replaced with a minimal wire-only `'...'`
+     * text block to keep user/assistant alternation and satisfy gateways that
+     * reject empty content.
+     */
+    private repairToolCallHistory;
 }
 
 /**
@@ -192,6 +249,8 @@ declare abstract class KodaXOpenAICompatProvider extends KodaXBaseProvider {
     private appendExtraBody;
     private resetReasoningCapabilityParams;
     private applyReasoningCapability;
+    private applyReasoningProfile;
+    private resolveReasoningProfileBudget;
     private getFallbackTerms;
     stream(messages: KodaXMessage[], tools: KodaXToolDefinition[], system: string, reasoning?: boolean | KodaXReasoningRequest, streamOptions?: KodaXProviderStreamOptions, signal?: AbortSignal): Promise<KodaXStreamResult>;
     supportsNonStreamingFallback(): boolean;
@@ -207,10 +266,10 @@ declare abstract class KodaXOpenAICompatProvider extends KodaXBaseProvider {
 /**
  * KodaX Provider Registry
  *
- * Provider 注册表 - 统一管理所有 Provider
+  * Provider 注册表 - 统一管理所有 Provider
  */
 
-type ProviderName = 'anthropic' | 'openai' | 'deepseek' | 'kimi' | 'kimi-code' | 'qwen' | 'zhipu' | 'zhipu-coding' | 'minimax-coding' | 'mimo-coding' | 'mimo' | 'ark-coding' | 'gemini-cli' | 'codex-cli';
+type ProviderName = 'anthropic' | 'openai' | 'deepseek' | 'kimi' | 'kimi-code' | 'qwen' | 'zhipu' | 'zhipu-coding' | 'zai-coding' | 'minimax-coding' | 'mimo-coding' | 'mimo' | 'ark-coding' | 'gemini-cli' | 'codex-cli';
 /**
  * Per-provider static metadata. v0.7.43 promoted this from a partial
  * descriptor (`models: string[]`) to the full capability surface so
@@ -239,6 +298,7 @@ type ProviderSnapshot = {
     readonly models?: readonly KodaXModelDescriptor[];
     readonly apiKeyEnv: string;
     readonly reasoningCapability: KodaXReasoningCapability;
+    readonly reasoningProfile?: KodaXReasoningProfile;
     readonly modelReasoningCapabilities?: Readonly<Record<string, KodaXReasoningCapability>>;
     readonly capabilityProfile: KodaXProviderCapabilityProfile;
     /** Maximum input context window (tokens). Provider-level default. */
@@ -270,6 +330,7 @@ declare function getProviderList(): Array<{
     models: string[];
     configured: boolean;
     reasoningCapability: KodaXReasoningCapability;
+    reasoningProfile?: KodaXReasoningProfile;
     capabilityProfile: KodaXProviderCapabilityProfile;
 }>;
 declare function getProviderModels(name: string): string[];
@@ -304,6 +365,8 @@ interface KodaXModelCapabilities {
     supportsThinking: boolean;
     /** Effective reasoning capability for THIS model (per-model override aware). */
     reasoningCapability: KodaXReasoningCapability;
+    /** Effort-first reasoning capability metadata for THIS model, when known. */
+    reasoningProfile?: KodaXReasoningProfile;
     /** Maximum input context window (tokens). `undefined` for CLI-bridge providers. */
     contextWindow?: number;
     /**
@@ -330,10 +393,12 @@ interface KodaXModelCapabilities {
  */
 declare function getProviderModelDescriptors(name: string): KodaXModelDescriptor[];
 /**
- * Effective per-model capability surface for a built-in provider. Returns
- * `undefined` for unknown provider name or unknown model under a known
- * provider — caller should fall back to `DEFAULT_CONTEXT_WINDOW` from
- * `@kodax-ai/kodax/agent` when nothing is advertised.
+ * Effective per-model capability surface for a built-in provider.
+ *
+ * Returns `undefined` only for an unknown PROVIDER name. An unknown MODEL under
+ * a known provider inherits the provider-level capability (optimistic-wide
+ * default — see the inline note below), so callers always get a usable surface
+ * for any model id routed to a known provider.
  *
  * No API key required.
  */
@@ -500,5 +565,5 @@ declare function listProviderModels(name: string, _opts?: {
     signal?: AbortSignal;
 }): Promise<KodaXListModelsResult>;
 
-export { reasoningOverrideToCapability 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, loadReasoningOverride as X, mapDepthToOpenAIReasoningEffort as Y, normalizeReasoningRequest as Z, reasoningCapabilityToOverride as _, KODAX_DEFAULT_THINKING_BUDGETS as a, registerCustomProviders as a0, registerModelProvider as a1, resolveModelCapabilities as a2, resolveProvider as a3, resolveProviderModelDescriptors as a4, resolveThinkingBudget as a5, saveReasoningOverride as a6, validateCustomProviderConfig as a7, verifyProviderCredential as a8, KODAX_PROVIDERS as b, KODAX_PROVIDER_SNAPSHOTS as c, KODAX_REASONING_MODE_SEQUENCE as d, KODAX_REASONING_SAFETY_RESERVE as e, KodaXAnthropicCompatProvider as f, KodaXError as g, KodaXNetworkError as i, KodaXOpenAICompatProvider as j, KodaXProviderError as k, KodaXRateLimitError as l, KodaXToolCallIdError as m, buildReasoningOverrideKey as n, clampThinkingBudget as o, clearReasoningOverride as p, clearRuntimeModelProviders as q, createCustomProvider 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 h };
+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 };

package/dist/types-chunks/{sdk-session-SjrnWb4-.d.ts → sdk-session-DAScB0rW.d.ts}

@@ -1,7 +1,7 @@
-import { b as PermissionMode, S as SessionData, F as FileSessionStorage } from './storage.d-BAuJ0Ks7.js';
-import { G as KodaXReasoningMode, o as KodaXMessage, h as KodaXContentBlock } from './base.d-BBNUF9nz.js';
-import { m as KodaXAgentMode } from './bash-prefix-extractor.d-LUGkQHcd.js';
-import { ac as KodaXSessionUiHistoryItem, ag as KodaXSessionUiToolCall } from './process.d-Bj82oJhD.js';
+import { b as PermissionMode, S as SessionData, F as FileSessionStorage } from './storage.d-CPvn9qI0.js';
+import { E as KodaXReasoningMode, j as KodaXMessage, c as KodaXContentBlock } from './types.d-6VOXvF88.js';
+import { m as KodaXAgentMode } from './bash-prefix-extractor.d-BgvMbfq6.js';
+import { ac as KodaXSessionUiHistoryItem, ag as KodaXSessionUiToolCall } from './process.d-BZncyzEj.js';
 
 /**
  * TextBuffer - Text buffer management class - 文本缓冲区管理类
@@ -412,6 +412,8 @@ interface StatusBarProps {
     activeToolCount?: number;
     thinking?: boolean;
     reasoningMode?: KodaXReasoningMode;
+    effort?: string;
+    reasoningEffortLabel?: string;
     reasoningCapability?: string;
     /** Is context currently compacting - 是否正在压缩上下文 */
     isCompacting?: boolean;

package/dist/types-chunks/{storage.d-BAuJ0Ks7.d.ts → storage.d-CPvn9qI0.d.ts}

@@ -1,5 +1,5 @@
-import { a as BashPrefixExtractor } from './bash-prefix-extractor.d-LUGkQHcd.js';
-import { $ as KodaXSessionData, a4 as KodaXSessionLineage, a7 as KodaXSessionNavigationOptions, a8 as KodaXSessionRuntimeInfo, aa as KodaXSessionStorage } from './process.d-Bj82oJhD.js';
+import { a as BashPrefixExtractor } from './bash-prefix-extractor.d-BgvMbfq6.js';
+import { $ as KodaXSessionData, a4 as KodaXSessionLineage, a7 as KodaXSessionNavigationOptions, a8 as KodaXSessionRuntimeInfo, aa as KodaXSessionStorage } from './process.d-BZncyzEj.js';
 
 /**
  * Permission Types