@kodax-ai/kodax 0.7.46 → 0.7.47

package/dist/types-chunks/{bash-prefix-extractor.d-BICYx8pt.d.ts → bash-prefix-extractor.d-D6hL0Cuv.d.ts}

@@ -2,6 +2,7 @@ import { M as McpConnectMode, a as McpServerConfig, b as McpServersConfig, c as
 import { g as KodaXGoalState, s as KodaXSessionLineage, x as KodaXSessionScope, y as KodaXSessionStorage, i as KodaXJsonValue, k as KodaXSessionArtifactLedgerEntry, S as SessionErrorMetadata } from './types.d-B_MIIApc.js';
 import { X as KodaXTokenUsage, n as KodaXMessage, E as KodaXReasoningMode, k as KodaXHarnessProfile, S as KodaXTaskWorkIntent, I as KodaXReviewScale, O as KodaXTaskComplexity, a as KodaXAmaFanoutClass, Q as KodaXTaskRoutingDecision, R as KodaXTaskType, J as KodaXRiskLevel, i as KodaXExecutionMode, c as KodaXAmaProfile, d as KodaXAmaTactic, b as KodaXAmaFanoutPolicy } from './types.d-Cf-GCzac.js';
 import { f as AgentMessage, av as StopHookFn, C as ChildTaskRegistry, p as CompactionUpdate, v as Guardrail, s as DiscoveredInstance, az as TaskAbortRegistry, aa as RunnerToolCall, aE as ToolGuardrail } from './types.d-D2RNa5Y7.js';
+import { Diagnostic, Position, Location, Hover, DocumentSymbol, SymbolInformation } from 'vscode-languageserver-protocol';
 import { C as CapabilityKind, b as CapabilityResult } from './capability.d-3C62G8Eq.js';
 import { K as KodaXBaseProvider } from './base.d-BdJKSPO2.js';
 import { a as CostTracker } from './cost-tracker.d-wRtyEW9d.js';
@@ -391,6 +392,200 @@ interface TodoStore {
     reset(): void;
 }
 
+/**
+ * FEATURE_132 — language-server registry + discovery (cascade step ①).
+ *
+ * Each `LspServerInfo` is data describing one server: which languageIds it
+ * serves, the project-root markers it should be rooted at, how to discover
+ * an installed binary, an optional opt-in `acquire()` (cascade step ②), and
+ * one line of actionable install guidance for when it is absent (step ③).
+ * Adding a language = appending one entry here (data-driven, LLM-First).
+ *
+ * Phase A: TypeScript/JavaScript. Phase B: Python (pyright) + Go (gopls).
+ * Phase C appends Rust, Java.
+ */
+
+/** A resolved server launch: program + args + optional init options. */
+interface LspServerLaunch {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly initializationOptions?: Record<string, unknown>;
+}
+interface DiscoverContext {
+    /** Project root the server will be rooted at. */
+    readonly root: string;
+    /** `import.meta.url` of the LSP module, used for bundled-TypeScript fallback. */
+    readonly moduleUrl?: string;
+}
+interface AcquireContext {
+    readonly root: string;
+    readonly signal?: AbortSignal;
+    readonly onProgress?: (message: string) => void;
+    readonly debug?: (message: string) => void;
+}
+interface LspServerInfo {
+    readonly id: string;
+    readonly languageIds: readonly string[];
+    readonly rootMarkers: readonly string[];
+    /** Locate an installed server, or `undefined` if not installed. */
+    discover(ctx: DiscoverContext): LspServerLaunch | undefined;
+    /**
+     * Opt-in auto-install (only attempted when `KODAX_LSP_DOWNLOAD=1`). Installs
+     * the server, then returns its launch (typically by re-running discovery).
+     * Absent for servers KodaX won't auto-install.
+     */
+    acquire?(ctx: AcquireContext): Promise<LspServerLaunch | undefined>;
+    /** One actionable line shown when discovery + acquire fail (step ③). */
+    readonly installGuidance: string;
+}
+/** All servers KodaX knows how to drive. */
+declare const LSP_SERVERS: readonly LspServerInfo[];
+
+/**
+ * FEATURE_132 — JSON-RPC LSP client (one spawned server, one project root).
+ *
+ * Push-diagnostics model: after `didOpen`/`didChange`, the server emits
+ * `textDocument/publishDiagnostics`; we cache the latest set per file and
+ * let callers wait (debounced) for a fresh publish. All five servers KodaX
+ * targets (typescript-language-server, pyright, gopls, rust-analyzer, jdtls)
+ * push diagnostics, so we deliberately do NOT port opencode's pull-diagnostic
+ * machinery (YAGNI — add it only if a future server requires it).
+ *
+ * Navigation requests (definition/hover/references/symbols) are added in
+ * Phase E.
+ */
+
+interface DiagnosticsWaitOptions {
+    /** Only a publish with timestamp ≥ this counts as fresh (set before notify). */
+    readonly afterMs: number;
+    /** Give up waiting after this long and return what we have. */
+    readonly timeoutMs: number;
+}
+interface LspClient {
+    readonly serverId: string;
+    readonly root: string;
+    /**
+     * Send didOpen (first touch) or didChange (subsequent) for a file, and
+     * return the timestamp the notification was sent — pass it as
+     * `waitForDiagnostics`'s `afterMs` so only a publish triggered by THIS
+     * change counts as fresh.
+     */
+    notifyOpenOrChange(file: string): Promise<number>;
+    /** Resolve once a fresh diagnostics publish arrives for the file, or on timeout. */
+    waitForDiagnostics(file: string, options: DiagnosticsWaitOptions): Promise<void>;
+    /** Latest cached diagnostics for a file (empty when none/unknown). */
+    diagnostics(file: string): readonly Diagnostic[];
+    /** Resolve the definition site(s) of the symbol at a position. */
+    definition(file: string, position: Position): Promise<Location[]>;
+    /** Type/signature/doc hover for the symbol at a position (null if none). */
+    hover(file: string, position: Position): Promise<Hover | null>;
+    /** All references to the symbol at a position (incl. its declaration). */
+    references(file: string, position: Position): Promise<Location[]>;
+    /** The document's symbol outline. */
+    documentSymbols(file: string): Promise<Array<DocumentSymbol | SymbolInformation>>;
+    /** Graceful shutdown (await server exit so the OS releases handles). */
+    shutdown(): Promise<void>;
+    /** Synchronous best-effort kill, for a `process.on('exit')` last resort. */
+    killSync(): void;
+}
+interface CreateLspClientParams {
+    readonly serverId: string;
+    readonly root: string;
+    readonly launch: LspServerLaunch;
+    readonly initializeTimeoutMs?: number;
+    readonly debug?: (message: string) => void;
+}
+
+/**
+ * FEATURE_132 — LSP service: spawns/caches one client per (root, server) and
+ * exposes the post-edit diagnostics façade the write-family tools call.
+ *
+ * State machine mirrors opencode:
+ *   - `clients`  — live clients, keyed `root|serverId`.
+ *   - `broken`   — keys that failed discovery or startup; skipped forever
+ *                  (no retry storm — a one-shot blacklist).
+ *   - `spawning` — in-flight startups, so concurrent edits never double-spawn.
+ *
+ * `getDiagnosticsBlock` is deliberately SILENT when no server is installed
+ * (returns `""`): nagging an install hint on every edit would be noise.
+ * Install guidance is surfaced on explicit, user-initiated surfaces instead
+ * (Phase E navigation tools / status), not the diagnostics reflux path.
+ */
+
+/** Per-edit hints the service needs to root + cancel work. */
+interface DiagnosticsRequest {
+    /** Project root (git root) — bounds the upward root-marker search. */
+    readonly gitRoot?: string;
+    /** Cancels the work when the host aborts the turn. */
+    readonly signal?: AbortSignal;
+    /** Live progress line (e.g. "Starting typescript language server…"). */
+    readonly onProgress?: (message: string) => void;
+}
+interface LspServiceConfig {
+    /** `import.meta.url` used to resolve the bundled TypeScript fallback. */
+    readonly moduleUrl?: string;
+    /** How long to wait for a fresh diagnostics publish per file. Default 5s. */
+    readonly documentTimeoutMs?: number;
+    /** Server registry override (tests). Defaults to {@link LSP_SERVERS}. */
+    readonly servers?: readonly LspServerInfo[];
+    /** Client factory override (tests). Defaults to {@link createLspClient}. */
+    readonly createClient?: (params: CreateLspClientParams) => Promise<LspClient>;
+    /** Debug sink (off unless wired). */
+    readonly debug?: (message: string) => void;
+}
+declare class LspService {
+    private readonly config;
+    private readonly clients;
+    private readonly broken;
+    private readonly spawning;
+    private readonly servers;
+    private shuttingDown;
+    constructor(config?: LspServiceConfig);
+    /**
+     * Touch a just-written file and return an appendable diagnostics block
+     * (`"\n\n…"`) when the language server reports errors, or `""` when there
+     * are none / no server is available. Never throws.
+     */
+    getDiagnosticsBlock(file: string, request?: DiagnosticsRequest): Promise<string>;
+    /** Definition site(s) of the symbol at `position` (0-based), as text. */
+    getDefinition(file: string, position: Position, request?: DiagnosticsRequest): Promise<string>;
+    /** Hover (type/signature/doc) for the symbol at `position` (0-based). */
+    getHover(file: string, position: Position, request?: DiagnosticsRequest): Promise<string>;
+    /** All references to the symbol at `position` (0-based), as text. */
+    getReferences(file: string, position: Position, request?: DiagnosticsRequest): Promise<string>;
+    /** The file's symbol outline, as indented text. */
+    getDocumentSymbols(file: string, request?: DiagnosticsRequest): Promise<string>;
+    /**
+     * Resolve the primary client for a navigation request, opening the file so
+     * the server has current content. Returns guidance text when no server is
+     * installed (navigation is user-initiated, so — unlike diagnostics — it is
+     * NOT silent), or an unsupported message for non-LSP file types.
+     */
+    private navClient;
+    /** Shut down all spawned servers gracefully (call on session teardown). */
+    shutdownAll(): Promise<void>;
+    /** Synchronous best-effort kill of all servers — for `process.on('exit')`. */
+    killAllSync(): void;
+    /**
+     * Clear the broken blacklist so a server that failed earlier (e.g. installed
+     * mid-session, or a transient startup failure) can be retried. Pass a
+     * `root|serverId` key to clear one entry, or omit to clear all.
+     */
+    resetBroken(key?: string): void;
+    private getClient;
+    private spawnClient;
+    /** Cascade step ②: opt-in auto-install, only when the user enabled it. */
+    private acquireIfEnabled;
+}
+/**
+ * Process-wide default service used by the write-family tools when the host
+ * does not inject one. `KODAX_LSP=0` disables it entirely (returns undefined,
+ * so tools no-op). `KODAX_DEBUG_LSP` routes internal logs to stderr.
+ */
+declare function getDefaultLspService(): LspService | undefined;
+/** Gracefully shut down the process-wide default service (host teardown). */
+declare function shutdownDefaultLspService(): Promise<void>;
+
 /**
  * FEATURE_192 v0.7.44 Phase B — Goal lifecycle hook composer.
  *
@@ -630,6 +825,58 @@ interface GoalRuntimeBinding {
  */
 declare function buildGoalRuntimeBinding(deps: GoalRuntimeBindingDeps): GoalRuntimeBinding;
 
+/**
+ * FEATURE_218 — KodaX Self-Knowledge Manual types.
+ *
+ * A bundled, version-bound product manual that answers "how do I use /
+ * configure / install / troubleshoot KodaX?" questions. Pure data + a
+ * deterministic resolver — no RAG, no vector store, no network fetch.
+ */
+type KodaXManualTopicId = 'overview' | 'install' | 'quickstart' | 'providers' | 'custom-providers' | 'config' | 'permissions' | 'commands' | 'tools' | 'agents' | 'skills' | 'mcp' | 'repo-intelligence' | 'sessions' | 'doctor' | 'sdk' | 'troubleshooting';
+/** A pointer to the code/doc the topic is derived from (for traceability). */
+interface KodaXManualSource {
+    readonly label: string;
+    readonly path: string;
+}
+interface ResolveKodaXManualInput {
+    /** Exact topic id or alias. Takes precedence over `query`. */
+    readonly topic?: string;
+    /** Free-text question; resolved by alias + token overlap. */
+    readonly query?: string;
+}
+/**
+ * FEATURE_221 — a topic an SDK consumer (e.g. a product built on KodaX)
+ * injects via `KodaXOptions.selfManual.topics`. Same shape as a KodaX base
+ * topic but `id` is a free string (new id = add; existing base id = override),
+ * and aliases/nextTopics/sources are optional to lower the authoring burden.
+ * Bodies are still byte-capped by the resolver (no unbounded items).
+ */
+interface KodaXManualTopicInput {
+    readonly id: string;
+    readonly title: string;
+    readonly summary: string;
+    readonly body: string;
+    readonly aliases?: readonly string[];
+    readonly nextTopics?: readonly string[];
+    readonly sources?: readonly KodaXManualSource[];
+}
+/** Per-call resolver options — consumer topic injection + product re-branding. */
+interface ResolveKodaXManualOptions {
+    /** Injected consumer topics, merged over the KodaX base (override by id). */
+    readonly extraTopics?: readonly KodaXManualTopicInput[];
+    /** Product name used in the scope anchor (default "KodaX"). */
+    readonly productName?: string;
+}
+interface ResolveKodaXManualResult {
+    /** A topic id (KodaX base or injected consumer topic), or 'index'. */
+    readonly matchedTopic: string;
+    readonly title: string;
+    /** Assembled, byte-capped content (scope anchor + body, or index list). */
+    readonly content: string;
+    readonly sources: readonly KodaXManualSource[];
+    readonly nextTopics: readonly string[];
+}
+
 /**
  * FEATURE_093 (v0.7.24): minimal contract interface for the coding extension
  * runtime. Extracted so `@kodax-ai/coding/src/types.ts` can reference the
@@ -1695,6 +1942,26 @@ interface KodaXContextOptions {
      * the lifecycle hooks pass through unmodified.
      */
     goalRuntime?: GoalRuntimeBinding;
+    /**
+     * FEATURE_132 (v0.7.47) — native LSP service for edit-time diagnostics
+     * reflux. When omitted, `buildToolExecutionContext` falls back to the
+     * process-wide default (`getDefaultLspService()`), so diagnostics work
+     * out of the box; hosts/tests inject their own to control or disable it.
+     *
+     * See `packages/coding/src/lsp/service.ts`.
+     */
+    lspService?: LspService;
+}
+/**
+ * FEATURE_221 — an SDK consumer (a product built on KodaX, e.g. KodaX-Space)
+ * injects its own product manual so that when ITS users ask "how do I use /
+ * configure <product>?", the kodax_manual tool answers with the consumer's
+ * topics. `topics` extend the KodaX base (override by id); `productName`
+ * re-brands the routing rule + scope anchor. Topics are still byte-capped.
+ */
+interface KodaXSelfManualConfig {
+    readonly productName?: string;
+    readonly topics?: readonly KodaXManualTopicInput[];
 }
 interface KodaXOptions {
     provider: string;
@@ -1708,6 +1975,8 @@ interface KodaXOptions {
     context?: KodaXContextOptions;
     events?: KodaXEvents;
     extensionRuntime?: ExtensionRuntimeContract;
+    /** FEATURE_221: SDK-consumer self-manual injection (product name + topics). */
+    selfManual?: KodaXSelfManualConfig;
     /**
      * FEATURE_092 (v0.7.33): caller-supplied run-scoped guardrails forwarded
      * to `Runner.run` via `RunOptions.guardrails`. Merged with the START
@@ -2001,6 +2270,8 @@ interface KodaXToolExecutionContext {
     backups: Map<string, string>;
     /** Git root directory - Git 根目录 */
     gitRoot?: string;
+    /** FEATURE_221: SDK-consumer self-manual injection, forwarded from KodaXOptions. */
+    selfManual?: KodaXSelfManualConfig;
     /** Working directory used to resolve relative paths and execute shell commands. */
     executionCwd?: string;
     /** Shared extension capability runtime used by retrieval-family tools. */
@@ -2160,6 +2431,13 @@ interface KodaXToolExecutionContext {
      * See `packages/coding/src/multi-instance/content-hash-cache.ts`.
      */
     contentHashCache?: ContentHashCache;
+    /**
+     * FEATURE_132 (v0.7.47) — native LSP service. The write-family tools call
+     * `getDiagnosticsBlock(filePath, …)` after a successful write to reflux any
+     * type errors into the tool result. Forwarded by `buildToolExecutionContext`
+     * from `options.context.lspService` or the process-wide default.
+     */
+    lspService?: LspService;
     /**
      * FEATURE_177 v0.7.42 — per-task read-file-state cache (anti-loop).
      *
@@ -2921,5 +3199,5 @@ interface CreateBashPrefixExtractorOptions {
  */
 declare function createBashPrefixExtractor(opts: CreateBashPrefixExtractorOptions): BashPrefixExtractor;
 
-export { BASH_POLICY_SPEC as B, CONSECUTIVE_THRESHOLD as C, ERROR_THRESHOLD as E, createCircuitBreaker as a$, WINDOW_MS as aV, buildGoalRuntimeBinding as aW, collectAllSignals as aX, computeRulesFingerprint as aY, createAutoModeToolGuardrail as aZ, createBashPrefixExtractor as a_, createDenialTracker as b0, extractCommandPrefix as b1, formatAgentsForPrompt as b2, getKodaxGlobalDir as b3, loadAgentsFiles as b4, loadAutoRules as b5, makeDisabledGoalToolsContext as b6, parseAutoRules as b7, readTrustState as b8, recordAllow as b9, recordBlock as ba, recordError as bb, shouldFallback$1 as bc, shouldFallback as bd, trustProjectRules as be, withGoalBeforeNextTurn as bf, withGoalStopHook as bg, CUMULATIVE_THRESHOLD as n };
-export type { KodaXMcpTransport as $, AgentsFile as A, DenialTracker as D, FailureStage as F, GoalBlockedResult as G, KodaXChildAgentResult as H, KodaXChildContextBundle as I, KodaXContextOptions as J, KodaXAgentMode as K, KodaXContextTokenSnapshot as L, KodaXEvents as M, KodaXFanoutBranchLifecycle as N, KodaXFanoutBranchRecord as O, KodaXFanoutBranchTransition as P, KodaXFanoutSchedulerInput as Q, KodaXFanoutSchedulerPlan as R, KodaXInputArtifact as S, KodaXManagedBudgetSnapshot as T, KodaXManagedProtocolPayload as U, KodaXManagedTask as V, KodaXManagedTaskRuntimeState as W, KodaXManagedTaskStatusEvent as X, KodaXMcpConnectMode as Y, KodaXMcpServerConfig as Z, KodaXMcpServersConfig as _, AskUserMultiOptions as a, KodaXMemoryStrategy as a0, KodaXOptions as a1, KodaXOrchestrationVerdict as a2, KodaXParentReductionContract as a3, KodaXProviderPolicyHints as a4, KodaXRepoIntelligenceCapability as a5, KodaXRepoIntelligenceMode as a6, KodaXRepoIntelligenceResolvedMode as a7, KodaXRepoIntelligenceTrace as a8, KodaXRepoIntelligenceTraceEvent as a9, LoadAgentsOptions as aA, LoadedRulesSource as aB, ProviderExecutionState as aC, ProviderRecoveryEvent as aD, ProviderResilienceConfig as aE, ProviderResiliencePolicy as aF, RecoveryAction as aG, RecoveryDecision as aH, RecoveryLadderStep as aI, RecoveryResult as aJ, ResilienceClassification as aK, ResilienceErrorClass as aL, RulesLoadError as aM, RulesLoadResult as aN, SignalCollector as aO, SkippedRulesSource as aP, TodoItem as aQ, TodoList as aR, TodoStatus as aS, ToolCallSignal as aT, TrustState as aU, KodaXRepoRoutingSignals as aa, KodaXResult as ab, KodaXRoleRoundSummary as ac, KodaXRuntimeVerificationContract as ad, KodaXSessionControl as ae, KodaXSessionMutators as af, KodaXSessionOptions as ag, KodaXSkillInvocationContext as ah, KodaXSkillMap as ai, KodaXSkillProjectionConfidence as aj, KodaXTaskCapabilityHint as ak, KodaXTaskContract as al, KodaXTaskEvidenceArtifact as am, KodaXTaskEvidenceBundle as an, KodaXTaskEvidenceEntry as ao, KodaXTaskRole as ap, KodaXTaskRoleAssignment as aq, KodaXTaskStatus as ar, KodaXTaskSurface as as, KodaXTaskToolPolicy as at, KodaXTaskVerificationContract as au, KodaXTaskVerificationCriterion as av, KodaXTaskWorkItem as aw, KodaXToolExecutionContext as ax, KodaXVerificationScorecard as ay, KodaXVerificationScorecardCriterion as az, AskUserQuestionItem as b, AskUserQuestionOptions as c, AutoModeAskUser as d, AutoModeAskUserVerdict as e, AutoModeEngine as f, AutoModeGuardrailConfig as g, AutoModeSharedState as h, AutoModeStats as i, AutoModeToolGuardrail as j, AutoRules as k, BashPrefixExtractor as l, BashPrefixResult as m, CircuitBreaker as o, CreateBashPrefixExtractorOptions as p, ExtensionRuntimeContract as q, ExtractCommandPrefixOptions as r, GoalCompleteResult as s, GoalCreateInput as t, GoalLifecycleContext as u, GoalRuntimeBinding as v, GoalRuntimeBindingDeps as w, GoalToolsContext as x, KodaXBudgetDisclosureZone as y, KodaXBudgetExtensionRequest as z };
+export { BASH_POLICY_SPEC as B, CONSECUTIVE_THRESHOLD as C, ERROR_THRESHOLD as E, LSP_SERVERS as aE, LspService as aI, WINDOW_MS as b4, buildGoalRuntimeBinding as b5, collectAllSignals as b6, computeRulesFingerprint as b7, createAutoModeToolGuardrail as b8, createBashPrefixExtractor as b9, createCircuitBreaker as ba, createDenialTracker as bb, extractCommandPrefix as bc, formatAgentsForPrompt as bd, getDefaultLspService as be, getKodaxGlobalDir as bf, loadAgentsFiles as bg, loadAutoRules as bh, makeDisabledGoalToolsContext as bi, parseAutoRules as bj, readTrustState as bk, recordAllow as bl, recordBlock as bm, recordError as bn, shouldFallback$1 as bo, shouldFallback as bp, shutdownDefaultLspService as bq, trustProjectRules as br, withGoalBeforeNextTurn as bs, withGoalStopHook as bt, CUMULATIVE_THRESHOLD as n };
+export type { KodaXMcpConnectMode as $, AgentsFile as A, DenialTracker as D, FailureStage as F, GoalBlockedResult as G, KodaXBudgetExtensionRequest as H, KodaXChildAgentResult as I, KodaXChildContextBundle as J, KodaXAgentMode as K, KodaXContextOptions as L, KodaXContextTokenSnapshot as M, KodaXEvents as N, KodaXFanoutBranchLifecycle as O, KodaXFanoutBranchRecord as P, KodaXFanoutBranchTransition as Q, KodaXFanoutSchedulerInput as R, KodaXFanoutSchedulerPlan as S, KodaXInputArtifact as T, KodaXManagedBudgetSnapshot as U, KodaXManagedProtocolPayload as V, KodaXManagedTask as W, KodaXManagedTaskRuntimeState as X, KodaXManagedTaskStatusEvent as Y, KodaXManualTopicId as Z, KodaXManualTopicInput as _, AskUserMultiOptions as a, TodoItem as a$, KodaXMcpServerConfig as a0, KodaXMcpServersConfig as a1, KodaXMcpTransport as a2, KodaXMemoryStrategy as a3, KodaXOptions as a4, KodaXOrchestrationVerdict as a5, KodaXParentReductionContract as a6, KodaXProviderPolicyHints as a7, KodaXRepoIntelligenceCapability as a8, KodaXRepoIntelligenceMode as a9, KodaXTaskWorkItem as aA, KodaXToolExecutionContext as aB, KodaXVerificationScorecard as aC, KodaXVerificationScorecardCriterion as aD, LoadAgentsOptions as aF, LoadedRulesSource as aG, LspServerInfo as aH, LspServiceConfig as aJ, ProviderExecutionState as aK, ProviderRecoveryEvent as aL, ProviderResilienceConfig as aM, ProviderResiliencePolicy as aN, RecoveryAction as aO, RecoveryDecision as aP, RecoveryLadderStep as aQ, RecoveryResult as aR, ResilienceClassification as aS, ResilienceErrorClass as aT, ResolveKodaXManualInput as aU, ResolveKodaXManualOptions as aV, ResolveKodaXManualResult as aW, RulesLoadError as aX, RulesLoadResult as aY, SignalCollector as aZ, SkippedRulesSource as a_, KodaXRepoIntelligenceResolvedMode as aa, KodaXRepoIntelligenceTrace as ab, KodaXRepoIntelligenceTraceEvent as ac, KodaXRepoRoutingSignals as ad, KodaXResult as ae, KodaXRoleRoundSummary as af, KodaXRuntimeVerificationContract as ag, KodaXSelfManualConfig as ah, KodaXSessionControl as ai, KodaXSessionMutators as aj, KodaXSessionOptions as ak, KodaXSkillInvocationContext as al, KodaXSkillMap as am, KodaXSkillProjectionConfidence as an, KodaXTaskCapabilityHint as ao, KodaXTaskContract as ap, KodaXTaskEvidenceArtifact as aq, KodaXTaskEvidenceBundle as ar, KodaXTaskEvidenceEntry as as, KodaXTaskRole as at, KodaXTaskRoleAssignment as au, KodaXTaskStatus as av, KodaXTaskSurface as aw, KodaXTaskToolPolicy as ax, KodaXTaskVerificationContract as ay, KodaXTaskVerificationCriterion as az, AskUserQuestionItem as b, TodoList as b0, TodoStatus as b1, ToolCallSignal as b2, TrustState as b3, AskUserQuestionOptions as c, AutoModeAskUser as d, AutoModeAskUserVerdict as e, AutoModeEngine as f, AutoModeGuardrailConfig as g, AutoModeSharedState as h, AutoModeStats as i, AutoModeToolGuardrail as j, AutoRules as k, BashPrefixExtractor as l, BashPrefixResult as m, CircuitBreaker as o, CreateBashPrefixExtractorOptions as p, DiagnosticsRequest as q, ExtensionRuntimeContract as r, ExtractCommandPrefixOptions as s, GoalCompleteResult as t, GoalCreateInput as u, GoalLifecycleContext as v, GoalRuntimeBinding as w, GoalRuntimeBindingDeps as x, GoalToolsContext as y, KodaXBudgetDisclosureZone as z };

package/dist/types-chunks/{manager.d-87belpiS.d.ts → manager.d-U3UEwY1P.d.ts}

@@ -3,6 +3,15 @@ import { a as CapabilityProvider, C as CapabilityKind, b as CapabilityResult } f
 
 type McpCapabilityKind = 'tool' | 'resource' | 'prompt';
 type McpCapabilityRisk = 'read' | 'write' | 'network' | 'exec';
+/** Per-tool task-augmentation support (2025-11-25 `execution.taskSupport`). */
+type McpToolTaskSupport = 'forbidden' | 'optional' | 'required';
+/** Icon metadata (2025-11-25) attached to tools / resources / prompts. */
+interface McpIcon {
+    src: string;
+    mimeType?: string;
+    sizes?: string[];
+    theme?: 'light' | 'dark';
+}
 interface McpCatalogItem {
     id: string;
     serverId: string;
@@ -21,6 +30,10 @@ interface McpCapabilityDescriptor extends McpCatalogItem {
     promptArgsSchema?: unknown;
     uri?: string;
     mimeType?: string;
+    /** Sanitized icon metadata (unsafe-scheme icons dropped). */
+    icons?: McpIcon[];
+    /** Tool only — `execution.taskSupport`. Absent is treated as 'forbidden'. */
+    taskSupport?: McpToolTaskSupport;
 }
 interface McpServerCatalogSnapshot {
     serverId: string;
@@ -96,6 +109,7 @@ declare class McpServerRuntime {
     private doConnect;
     private listDescriptors;
     private request;
+    private sendRequest;
     private notify;
     private handleMessage;
     private failPending;
@@ -180,6 +194,7 @@ interface McpTransport {
     open(events: McpTransportEvents): Promise<void>;
     /** Send a JSON string. The transport handles framing. */
     send(json: string): Promise<void>;
+    setProtocolVersion?(version: string | undefined): void;
     close(): Promise<void>;
     readonly connected: boolean;
 }

package/dist/types-chunks/{utils.d-pzHPkrb8.d.ts → utils.d-umRKgMAu.d.ts}

@@ -1,4 +1,4 @@
-import { l as BashPrefixExtractor, a1 as KodaXOptions, L as KodaXContextTokenSnapshot, K as KodaXAgentMode, a6 as KodaXRepoIntelligenceMode, A as AgentsFile, i as AutoModeStats, ah as KodaXSkillInvocationContext, _ as KodaXMcpServersConfig } from './bash-prefix-extractor.d-BICYx8pt.js';
+import { l as BashPrefixExtractor, a4 as KodaXOptions, M as KodaXContextTokenSnapshot, K as KodaXAgentMode, a9 as KodaXRepoIntelligenceMode, A as AgentsFile, i as AutoModeStats, al as KodaXSkillInvocationContext, a1 as KodaXMcpServersConfig } from './bash-prefix-extractor.d-D6hL0Cuv.js';
 import { a as SessionStorage$1 } from './storage.d-B1Jk6ryM.js';
 import { y as KodaXSessionStorage, n as KodaXSessionData, A as KodaXSessionUiHistoryItem, s as KodaXSessionLineage, k as KodaXSessionArtifactLedgerEntry, w as KodaXSessionRuntimeInfo } from './types.d-B_MIIApc.js';
 import { n as KodaXMessage, E as KodaXReasoningMode, r as KodaXProviderCapabilityProfile, F as KodaXReasoningOverride, h as KodaXCustomProviderConfig } from './types.d-Cf-GCzac.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodax-ai/kodax",
-  "version": "0.7.46",
+  "version": "0.7.47",
   "description": "极致轻量化 Coding Agent - TypeScript 实现，支持 12 个 LLM 提供商，可发布为免 Node 单文件二进制",
   "type": "module",
   "private": false,
@@ -122,6 +122,7 @@
     "terminal-size": "^4.0.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
+    "vscode-languageserver-protocol": "^3.17.5",
     "widest-line": "^6.0.0",
     "wrap-ansi": "^8.1.0",
     "ws": "^8.18.0",