@kodax-ai/kodax 0.7.76 → 0.7.78

package/dist/types-chunks/{commands.d-DUxnK2TU.d.ts → repl.d-Ie_ZXb_U.d.ts}

@@ -1,8 +1,8 @@
-import { X as SessionStorage$1, R as PermissionMode, L as LearningBinding } from './public-api.d-CX4B11qY.js';
-import { a1 as KodaXOptions, ab as KodaXResult } from './bash-prefix-extractor.d-r1beOESM.js';
-import { n as ResolvedAutoModeSettings, p as RuntimeSurfaceStatus, b as CommandDefinition, e as CommandSource, c as CommandInfo, C as Command$1, I as InteractiveContext, a as CommandCallbacks, g as CurrentConfig, d as CommandInvocationRequest, f as CommandWorkflowInvocationRequest } from './utils.d-D0wPxz8y.js';
-import { bV as KodaXSessionStorage, bH as KodaXSessionData } from './types.d-sRLugmjy.js';
-import { r as AutoModeStats } from './guardrail.d-qjuKJZ31.js';
+import { n as ResolvedAutoModeSettings, b as CommandDefinition, e as CommandSource, c as CommandInfo, C as Command$1, I as InteractiveContext, a as CommandCallbacks, g as CurrentConfig, d as CommandInvocationRequest, f as CommandWorkflowInvocationRequest, p as RuntimeSurfaceStatus } from './utils.d-CVp6bFl9.js';
+import { X as SessionStorage$1, R as PermissionMode, L as LearningBinding } from './public-api.d-B3AohsxN.js';
+import { a1 as KodaXOptions, ad as KodaXResult } from './bash-prefix-extractor.d-uAe2Oqda.js';
+import { c1 as KodaXSessionStorage, bP as KodaXSessionData } from './types.d-BA-Jwpfs.js';
+import { s as AutoModeStats } from './guardrail.d-CXDYRgZ3.js';
 
 interface ReplRuntimePermissionGrantSuggestion {
     readonly id: string;
@@ -49,77 +49,6 @@ interface ReplRuntimeAutoModeSettings {
 }
 declare function toReplRuntimeAutoModeSettings(settings: ResolvedAutoModeSettings): ReplRuntimeAutoModeSettings;
 
-/**
- * InkREPL - Ink-based REPL Adapter
- *
- * Bridges Ink UI components with existing KodaX command processing logic.
- * Replaces the Node.js readline-based input with Ink's React components.
- *
- * Architecture based on Gemini CLI:
- * - Uses UIStateContext for global state
- * - Uses KeypressContext for priority-based keyboard handling
- * - Uses StreamingContext for streaming response management
- */
-
-interface InkRuntimeRunnerInput {
-    readonly options: KodaXOptions;
-    readonly prompt: string;
-    readonly sessionId: string;
-    readonly permissionMode: PermissionMode;
-    readonly autoModeSettings?: ReplRuntimeAutoModeSettings;
-    readonly requestPermission?: ReplRuntimePermissionPrompt;
-    /** Marks the callback installed by the REPL's legacy permission UI. */
-    readonly legacyPermissionHook?: true;
-}
-type InkRuntimeRunner = (input: InkRuntimeRunnerInput) => Promise<KodaXResult>;
-type InkRuntimeStatusProvider = () => Promise<RuntimeSurfaceStatus | undefined>;
-interface InkREPLOptions extends KodaXOptions {
-    storage?: SessionStorage$1;
-    hardExitOnClose?: boolean;
-    runtimeRunner?: InkRuntimeRunner;
-    runtimeAutoModeControl?: ReplRuntimeAutoModeControl;
-    getRuntimeStatus?: InkRuntimeStatusProvider;
-    learning?: LearningBinding;
-}
-/**
- * Run Ink-based interactive mode
- */
-declare function runInkInteractiveMode(options: InkREPLOptions): Promise<void>;
-
-interface SessionStorage extends KodaXSessionStorage {
-    list(gitRoot?: string, options?: {
-        limit?: number;
-        includeArchived?: boolean;
-    }): Promise<Array<{
-        id: string;
-        title: string;
-        msgCount: number;
-        tag?: string;
-        runtimeInfo?: KodaXSessionData['runtimeInfo'];
-    }>>;
-}
-interface ReplRuntimeRunnerInput {
-    readonly options: KodaXOptions;
-    readonly prompt: string;
-    readonly sessionId: string;
-    readonly permissionMode: PermissionMode;
-    readonly autoModeSettings?: ReplRuntimeAutoModeSettings;
-    readonly requestPermission?: ReplRuntimePermissionPrompt;
-    /** Marks the callback installed by the REPL's legacy permission UI. */
-    readonly legacyPermissionHook?: true;
-}
-type ReplRuntimeRunner = (input: ReplRuntimeRunnerInput) => Promise<KodaXResult>;
-type ReplRuntimeStatusProvider = () => Promise<RuntimeSurfaceStatus | undefined>;
-interface RepLOptions extends KodaXOptions {
-    storage?: SessionStorage;
-    runtimeRunner?: ReplRuntimeRunner;
-    runtimeAutoModeControl?: ReplRuntimeAutoModeControl;
-    getRuntimeStatus?: ReplRuntimeStatusProvider;
-    learning?: LearningBinding;
-}
-declare function runInteractiveMode(options: RepLOptions): Promise<void>;
-declare function processSpecialSyntax(input: string, executionCwd?: string): Promise<string>;
-
 /**
  * Command Registry - Dynamic command registration system
  * 命令注册表 - 动态命令注册系统
@@ -270,5 +199,87 @@ declare function executeCommand(parsed: {
     };
 }, context: InteractiveContext, callbacks: CommandCallbacks, currentConfig: CurrentConfig): Promise<CommandResult>;
 
-export { BUILTIN_COMMANDS as B, RUNTIME_PERMISSION_PENDING_NOTICE as R, executeCommand as n, getCommandRegistry as o, parseCommand as p, processSpecialSyntax as q, runInkInteractiveMode as r, runInteractiveMode as s, toReplRuntimeAutoModeSettings as t };
-export type { Command as C, InkREPLOptions as I, InkRuntimeRunner as a, InkRuntimeRunnerInput as b, InkRuntimeStatusProvider as c, RepLOptions as d, ReplRuntimeAutoModeControl as e, ReplRuntimeAutoModeSettings as f, ReplRuntimePermissionDecision as g, ReplRuntimePermissionGrantSuggestion as h, ReplRuntimePermissionPrompt as i, ReplRuntimePermissionRequest as j, ReplRuntimeRunner as k, ReplRuntimeRunnerInput as l, ReplRuntimeStatusProvider as m };
+/**
+ * InkREPL - Ink-based REPL Adapter
+ *
+ * Bridges Ink UI components with existing KodaX command processing logic.
+ * Replaces the Node.js readline-based input with Ink's React components.
+ *
+ * Architecture based on Gemini CLI:
+ * - Uses UIStateContext for global state
+ * - Uses KeypressContext for priority-based keyboard handling
+ * - Uses StreamingContext for streaming response management
+ */
+
+interface InkRuntimeRunnerInput {
+    readonly options: KodaXOptions;
+    readonly prompt: string;
+    readonly sessionId: string;
+    readonly permissionMode: PermissionMode;
+    readonly autoModeSettings?: ReplRuntimeAutoModeSettings;
+    readonly requestPermission?: ReplRuntimePermissionPrompt;
+    /** Marks the callback installed by the REPL's legacy permission UI. */
+    readonly legacyPermissionHook?: true;
+}
+type InkRuntimeRunner = (input: InkRuntimeRunnerInput) => Promise<KodaXResult>;
+type InkRuntimeStatusProvider = () => Promise<RuntimeSurfaceStatus | undefined>;
+interface InkTransientNotice {
+    readonly text: string;
+    readonly tone: "success" | "warning";
+}
+interface InkREPLOptions extends KodaXOptions {
+    storage?: SessionStorage$1;
+    hardExitOnClose?: boolean;
+    runtimeRunner?: InkRuntimeRunner;
+    runtimeAutoModeControl?: ReplRuntimeAutoModeControl;
+    getRuntimeStatus?: InkRuntimeStatusProvider;
+    validateSetupA2AConfig?: (value: unknown) => unknown;
+    prepareSetupSandbox?: CommandCallbacks['prepareSetupSandbox'];
+    inspectSandbox?: CommandCallbacks['inspectSandbox'];
+    learning?: LearningBinding;
+    subscribeTransientNotices?: (listener: (notice: InkTransientNotice) => void) => () => void;
+}
+/**
+ * Run Ink-based interactive mode
+ */
+declare function runInkInteractiveMode(options: InkREPLOptions): Promise<void>;
+
+interface SessionStorage extends KodaXSessionStorage {
+    list(gitRoot?: string, options?: {
+        limit?: number;
+        includeArchived?: boolean;
+    }): Promise<Array<{
+        id: string;
+        title: string;
+        msgCount: number;
+        tag?: string;
+        runtimeInfo?: KodaXSessionData['runtimeInfo'];
+    }>>;
+}
+interface ReplRuntimeRunnerInput {
+    readonly options: KodaXOptions;
+    readonly prompt: string;
+    readonly sessionId: string;
+    readonly permissionMode: PermissionMode;
+    readonly autoModeSettings?: ReplRuntimeAutoModeSettings;
+    readonly requestPermission?: ReplRuntimePermissionPrompt;
+    /** Marks the callback installed by the REPL's legacy permission UI. */
+    readonly legacyPermissionHook?: true;
+}
+type ReplRuntimeRunner = (input: ReplRuntimeRunnerInput) => Promise<KodaXResult>;
+type ReplRuntimeStatusProvider = () => Promise<RuntimeSurfaceStatus | undefined>;
+interface RepLOptions extends KodaXOptions {
+    storage?: SessionStorage;
+    runtimeRunner?: ReplRuntimeRunner;
+    runtimeAutoModeControl?: ReplRuntimeAutoModeControl;
+    getRuntimeStatus?: ReplRuntimeStatusProvider;
+    validateSetupA2AConfig?: (value: unknown) => unknown;
+    prepareSetupSandbox?: CommandCallbacks['prepareSetupSandbox'];
+    inspectSandbox?: CommandCallbacks['inspectSandbox'];
+    learning?: LearningBinding;
+}
+declare function runInteractiveMode(options: RepLOptions): Promise<void>;
+declare function processSpecialSyntax(input: string, executionCwd?: string): Promise<string>;
+
+export { BUILTIN_COMMANDS as B, RUNTIME_PERMISSION_PENDING_NOTICE as R, executeCommand as o, getCommandRegistry as p, parseCommand as q, processSpecialSyntax as r, runInkInteractiveMode as s, runInteractiveMode as t, toReplRuntimeAutoModeSettings as u };
+export type { Command as C, InkREPLOptions as I, InkRuntimeRunner as a, InkRuntimeRunnerInput as b, InkRuntimeStatusProvider as c, InkTransientNotice as d, RepLOptions as e, ReplRuntimeAutoModeControl as f, ReplRuntimeAutoModeSettings as g, ReplRuntimePermissionDecision as h, ReplRuntimePermissionGrantSuggestion as i, ReplRuntimePermissionPrompt as j, ReplRuntimePermissionRequest as k, ReplRuntimeRunner as l, ReplRuntimeRunnerInput as m, ReplRuntimeStatusProvider as n };

package/dist/types-chunks/{side-query.d-DWTMsndP.d.ts → resolver.d-iAQ9ocLB.d.ts}

@@ -1,8 +1,7 @@
-import { F as KodaXReasoningMode, M as KodaXStableEffortIntent, a9 as KodaXWireReasoningEffort, G as KodaXReasoningProfile, Z as KodaXThinkingBudgetMap, _ as KodaXThinkingDepth, q as KodaXProviderConfig, B as KodaXReasoningCapability, H as KodaXReasoningRequest, n as KodaXNormalizedReasoningRequest, V as KodaXTaskType, a7 as KodaXVerifyCredentialResult, a1 as KodaXToolDefinition, k as KodaXMessage, y as KodaXProviderStreamOptions, N as KodaXStreamResult, l as KodaXModelDescriptor, p as KodaXProviderCapabilityProfile, a8 as KodaXVerifyStrategy, d as KodaXCustomProviderConfig, j as KodaXListModelsResult, a0 as KodaXTokenUsage } from './types.d-CSmF0t0n.js';
+import { F as KodaXReasoningMode, M as KodaXStableEffortIntent, a9 as KodaXWireReasoningEffort, G as KodaXReasoningProfile, Z as KodaXThinkingBudgetMap, _ as KodaXThinkingDepth, q as KodaXProviderConfig, B as KodaXReasoningCapability, H as KodaXReasoningRequest, n as KodaXNormalizedReasoningRequest, V as KodaXTaskType, a7 as KodaXVerifyCredentialResult, a1 as KodaXToolDefinition, k as KodaXMessage, y as KodaXProviderStreamOptions, N as KodaXStreamResult, l as KodaXModelDescriptor, p as KodaXProviderCapabilityProfile, a8 as KodaXVerifyStrategy, d as KodaXCustomProviderConfig, j as KodaXListModelsResult } from './types.d-DIpZJKUl.js';
 import Anthropic from '@anthropic-ai/sdk';
-import { K as KodaXBaseProvider } from './base.d-ChvpaKjZ.js';
+import { K as KodaXBaseProvider } from './base.d-4e74xDdy.js';
 import OpenAI from 'openai';
-import { a as CostTracker } from './cost-tracker.d-BeaenODW.js';
 
 /**
  * KodaX AI Errors
@@ -203,7 +202,6 @@ declare abstract class KodaXAnthropicCompatProvider extends KodaXBaseProvider {
      * 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
@@ -221,12 +219,12 @@ declare abstract class KodaXAnthropicCompatProvider extends KodaXBaseProvider {
      * 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).
+     * Strategy: mark the LAST content block of the latest `user` message.
+     * Anthropic writes the whole prefix through that breakpoint. On the next
+     * request its lookback can match the previous turn's write even though the
+     * breakpoint has advanced to the new current turn. This also lets a
+     * single-call run seed the cache for the next run. 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:
@@ -235,6 +233,7 @@ declare abstract class KodaXAnthropicCompatProvider extends KodaXBaseProvider {
      * Returns a new array; never mutates input.
      */
     protected applyCacheControlToMessages(messages: Anthropic.Messages.MessageParam[]): Anthropic.Messages.MessageParam[];
+    supportsEphemeralSuffix(): boolean;
     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>;
@@ -272,6 +271,7 @@ declare abstract class KodaXOpenAICompatProvider extends KodaXBaseProvider {
     readonly supportsThinking = true;
     protected abstract readonly config: KodaXProviderConfig;
     private _client?;
+    supportsEphemeralSuffix(): boolean;
     /**
      * The SDK client is built lazily on first use. Constructing it requires the
      * API key (`getApiKey()` throws when the env var is unset), so deferring it
@@ -573,6 +573,7 @@ declare function registerModelProvider(name: string, factory: ModelProviderFacto
 declare function getRuntimeModelProvider(name: string): KodaXBaseProvider | undefined;
 declare function isRuntimeModelProviderName(name: string): boolean;
 declare function getRuntimeModelProviderNames(): string[];
+declare function getRuntimeModelProviderCredentialEnvironmentNames(): string[];
 declare function clearRuntimeModelProviders(): void;
 
 /**
@@ -595,6 +596,16 @@ declare function isKnownProvider(name: string): boolean;
  * Get all available provider names (built-in + custom).
  */
 declare function getAvailableProviderNames(): string[];
+/**
+ * Exact environment-variable names that may carry credentials for any
+ * registered Provider. Shell execution uses the complete set so switching the
+ * active Provider cannot make an inactive Provider's credential visible.
+ *
+ * Runtime Provider factories are evaluated because their public registration
+ * contract does not otherwise expose credential metadata. A failing factory is
+ * intentionally fail-closed for configured shell execution.
+ */
+declare function getProviderCredentialEnvironmentNames(): string[];
 /**
  * Model descriptors for any registered provider (built-in or custom).
  * Default model first, then alternatives. Empty array if name unknown.
@@ -649,67 +660,5 @@ declare function listProviderModels(name: string, _opts?: {
     signal?: AbortSignal;
 }): Promise<KodaXListModelsResult>;
 
-/**
- * sideQuery — independent one-shot LLM invocation.
- *
- * Used by features that need a clean LLM call outside the main agent loop.
- * The auto mode classifier (FEATURE_092) is the first consumer; future
- * users include compaction, title generation, and SA mutation reflection.
- *
- * Constraints (deliberate):
- *   - tools=[] hardcoded — sideQuery is single-turn, no tool loop
- *   - text-only output — tool_use blocks from the model produce stopReason='error'
- *   - independent timeout (default 30s; callers may supply a bounded deadline)
- *   - independent cost bucket via querySource (mapped to TokenUsageRecord.role)
- *
- * Failure handling: never throws. Timeout, abort, provider error, and
- * unexpected tool_use all produce a result with stopReason='timeout' /
- * 'aborted' / 'error' so callers implement their own degradation.
- */
-
-type SideQueryStopReason = 'end_turn' | 'max_tokens' | 'timeout' | 'aborted' | 'error';
-interface SideQueryRequest {
-    readonly provider: KodaXBaseProvider;
-    readonly model: string;
-    readonly system: string;
-    readonly messages: readonly KodaXMessage[];
-    readonly reasoning?: KodaXReasoningRequest;
-    /** Optional per-request cap for small structured sidecar responses. */
-    readonly maxOutputTokens?: number;
-    readonly timeoutMs?: number;
-    readonly abortSignal?: AbortSignal;
-    readonly querySource: string;
-    readonly costTracker?: CostTracker;
-}
-interface SideQueryResult {
-    readonly text: string;
-    readonly usage: KodaXTokenUsage;
-    readonly costTracker?: CostTracker;
-    readonly stopReason: SideQueryStopReason;
-    /**
-     * Bounded request metadata only; prompts and response text are never copied.
-     * The built-in `sideQuery()` always supplies it. Optionality preserves source
-     * compatibility for existing SDK mocks and structural result adapters.
-     */
-    readonly diagnostics?: SideQueryDiagnostics;
-    readonly error?: Error;
-}
-type SideQueryTerminalPhase = 'completed' | 'pre_output' | 'streaming' | 'contract_error';
-interface SideQueryDiagnostics {
-    readonly provider: string;
-    readonly model: string;
-    readonly timeoutMs: number;
-    readonly elapsedMs: number;
-    readonly retryCount: number;
-    readonly retryWaitMs: number;
-    /** Time until the first non-empty text delta, when the adapter exposes it. */
-    readonly firstOutputMs?: number;
-    /** Time from the first observed text delta until termination. */
-    readonly streamMs?: number;
-    /** Honest coarse phase; provider adapters cannot split DNS/connect/remote queue. */
-    readonly terminalPhase: SideQueryTerminalPhase;
-}
-declare function sideQuery(req: SideQueryRequest): Promise<SideQueryResult>;
-
-export { listBuiltinModelCapabilities as $, getCustomProviderList as A, getCustomProviderModelDescriptors as B, getCustomProviderModels as C, getCustomProviderNames as D, getDefaultThinkingDepthForMode as E, getModelCapabilities as F, getProvider as G, getProviderConfiguredCapabilityProfile as H, getProviderConfiguredReasoningCapability as I, getProviderList as J, KODAX_DEFAULT_PROVIDER as K, getProviderModel as L, getProviderModelDescriptors as M, getProviderModels as N, getReasoningCapability as O, getRuntimeModelProvider as Q, getRuntimeModelProviderNames as T, isCustomProviderName as U, isKnownProvider as V, isProviderConfigured as W, isProviderName as X, isReasoningEnabled as Y, isRuntimeModelProviderName as Z, listAllModelCapabilities as _, KODAX_DEFAULT_THINKING_BUDGETS as a, listCustomProviderModelCapabilities as a0, listProviderModels as a1, mapDepthToOpenAIReasoningEffort as a2, mapLegacyReasoningModeToEffortIntent as a3, normalizeReasoningEffortValue as a4, normalizeReasoningRequest as a5, parseReasoningEffortEnv as a6, registerCustomProviders as a7, registerModelProvider as a8, resolveModelCapabilities as a9, resolveProvider as aa, resolveProviderModelDescriptors as ab, resolveReasoningEffort as ac, resolveReasoningEffortForModelSwitch as ad, resolveThinkingBudget as ae, resolveWireEffort as af, sideQuery as ag, validateCustomProviderConfig as ah, verifyProviderCredential as ai, 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 t, clearRuntimeModelProviders as u, createCustomProvider as v, effortToLegacyReasoningMode as w, getAvailableProviderNames as x, getCustomModelCapabilities as y, getCustomProvider as z };
-export type { ProviderName as P, ResolveWireEffortInput as R, SideQueryDiagnostics as S, KodaXModelCapabilities as i, ResolvedWireEffort as o, SideQueryRequest as p, SideQueryResult as q, SideQueryStopReason as r, SideQueryTerminalPhase as s };
+export { mapDepthToOpenAIReasoningEffort as $, getDefaultThinkingDepthForMode as A, getModelCapabilities as B, getProvider as C, getProviderConfiguredCapabilityProfile as D, getProviderConfiguredReasoningCapability as E, getProviderCredentialEnvironmentNames as F, getProviderList as G, getProviderModel as H, getProviderModelDescriptors as I, getProviderModels as J, KODAX_DEFAULT_PROVIDER as K, getReasoningCapability as L, getRuntimeModelProvider as M, getRuntimeModelProviderCredentialEnvironmentNames as N, getRuntimeModelProviderNames as O, isCustomProviderName as Q, isKnownProvider as S, isProviderConfigured as T, isProviderName as U, isReasoningEnabled as V, isRuntimeModelProviderName as W, listAllModelCapabilities as X, listBuiltinModelCapabilities as Y, listCustomProviderModelCapabilities as Z, listProviderModels as _, KODAX_DEFAULT_THINKING_BUDGETS as a, mapLegacyReasoningModeToEffortIntent as a0, normalizeReasoningEffortValue as a1, normalizeReasoningRequest as a2, parseReasoningEffortEnv as a3, registerCustomProviders as a4, registerModelProvider as a5, resolveModelCapabilities as a6, resolveProvider as a7, resolveProviderModelDescriptors as a8, resolveReasoningEffort as a9, resolveReasoningEffortForModelSwitch as aa, resolveThinkingBudget as ab, resolveWireEffort as ac, validateCustomProviderConfig as ad, verifyProviderCredential as ae, 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 };

package/dist/types-chunks/{run-manager.d-B9fEIjZk.d.ts → run-manager.d-D1twIhF9.d.ts}

@@ -1,4 +1,4 @@
-import { eg as WorkflowProcessTrackerOptions, dO as WorkflowEvent, ea as WorkflowProcessSnapshot, e4 as WorkflowProcessEvent } from './types.d-sRLugmjy.js';
+import { f4 as WorkflowProcessTrackerOptions, eC as WorkflowEvent, e_ as WorkflowProcessSnapshot, eU as WorkflowProcessEvent } from './types.d-BA-Jwpfs.js';
 
 /**
  * FEATURE_246 Part A0 (ADR-046) — neutral workflow run lifecycle manager.

package/dist/types-chunks/{sdk-session-B0fhAOPa.d.ts → sdk-session-DB9KksIx.d.ts}

@@ -1,6 +1,6 @@
-import { g as CreatableHistoryItem, a8 as ToolCall } from './public-api.d-CX4B11qY.js';
-import { k as KodaXMessage, c as KodaXContentBlock } from './types.d-CSmF0t0n.js';
-import { bX as KodaXSessionUiHistoryItem, b$ as KodaXSessionUiToolCall } from './types.d-sRLugmjy.js';
+import { g as CreatableHistoryItem, a8 as ToolCall } from './public-api.d-B3AohsxN.js';
+import { k as KodaXMessage, c as KodaXContentBlock } from './types.d-DIpZJKUl.js';
+import { c3 as KodaXSessionUiHistoryItem, c7 as KodaXSessionUiToolCall } from './types.d-BA-Jwpfs.js';
 
 interface RestoreHistoryItemsFromSessionInput {
     messages: readonly KodaXMessage[];

package/dist/types-chunks/side-query.d-DTuLPcC5.d.ts

@@ -0,0 +1,77 @@
+import { k as KodaXMessage, H as KodaXReasoningRequest, a0 as KodaXTokenUsage } from './types.d-DIpZJKUl.js';
+import { K as KodaXBaseProvider } from './base.d-4e74xDdy.js';
+import { a as CostTracker } from './cost-tracker.d-BeaenODW.js';
+
+/**
+ * sideQuery — independent one-shot LLM invocation.
+ *
+ * Used by features that need a clean LLM call outside the main agent loop.
+ * The auto mode classifier (FEATURE_092) is the first consumer; future
+ * users include compaction, title generation, and SA mutation reflection.
+ *
+ * Constraints (deliberate):
+ *   - tools=[] hardcoded — sideQuery is single-turn, no tool loop
+ *   - text-only output — tool_use blocks from the model produce stopReason='error'
+ *   - independent timeout (default 30s; callers may supply a bounded deadline)
+ *   - independent cost bucket via querySource (mapped to TokenUsageRecord.role)
+ *
+ * Failure handling: never throws. Timeout, abort, provider error, and
+ * unexpected tool_use all produce a result with stopReason='timeout' /
+ * 'aborted' / 'error' so callers implement their own degradation.
+ */
+
+type SideQueryStopReason = 'end_turn' | 'max_tokens' | 'timeout' | 'aborted' | 'error';
+interface SideQueryRequest {
+    readonly provider: KodaXBaseProvider;
+    readonly model: string;
+    readonly system: string;
+    readonly messages: readonly KodaXMessage[];
+    readonly reasoning?: KodaXReasoningRequest;
+    /** Optional per-request cap for small structured sidecar responses. */
+    readonly maxOutputTokens?: number;
+    readonly timeoutMs?: number;
+    readonly abortSignal?: AbortSignal;
+    readonly querySource: string;
+    readonly costTracker?: CostTracker;
+}
+interface SideQueryResult {
+    readonly text: string;
+    readonly usage: KodaXTokenUsage;
+    readonly costTracker?: CostTracker;
+    readonly stopReason: SideQueryStopReason;
+    /**
+     * Bounded request metadata only; prompts and response text are never copied.
+     * The built-in `sideQuery()` always supplies it. Optionality preserves source
+     * compatibility for existing SDK mocks and structural result adapters.
+     */
+    readonly diagnostics?: SideQueryDiagnostics;
+    readonly error?: Error;
+}
+type SideQueryTerminalPhase = 'completed' | 'pre_output' | 'awaiting_text' | 'thinking' | 'streaming' | 'contract_error';
+interface SideQueryDiagnostics {
+    readonly provider: string;
+    readonly model: string;
+    readonly timeoutMs: number;
+    readonly elapsedMs: number;
+    readonly systemBytes: number;
+    readonly messageBytes: number;
+    readonly promptBytes: number;
+    readonly retryCount: number;
+    readonly retryWaitMs: number;
+    /** Time until the first lifecycle/data event exposed by the provider adapter. */
+    readonly firstUpstreamEventMs?: number;
+    /** Time until the first non-empty thinking delta. */
+    readonly firstThinkingDeltaMs?: number;
+    /** Time until the first non-empty text delta. */
+    readonly firstTextDeltaMs?: number;
+    /** Time until the first non-empty text delta, when the adapter exposes it. */
+    readonly firstOutputMs?: number;
+    /** Time from the first observed text delta until termination. */
+    readonly streamMs?: number;
+    /** Honest coarse phase; provider adapters cannot split DNS/connect/remote queue. */
+    readonly terminalPhase: SideQueryTerminalPhase;
+}
+declare function sideQuery(req: SideQueryRequest): Promise<SideQueryResult>;
+
+export { sideQuery as s };
+export type { SideQueryDiagnostics as S, SideQueryRequest as a, SideQueryResult as b, SideQueryStopReason as c, SideQueryTerminalPhase as d };