@botiverse/kimi-code-sdk 0.19.2-botiverse.0 → 0.20.0-botiverse.0

package/NOTICE.md

@@ -1,5 +1,5 @@
 # NOTICE
 
 @botiverse/kimi-code-sdk is a repackage of the built **@moonshot-ai/kimi-code-sdk** node-sdk
-from [MoonshotAI/kimi-code](https://github.com/MoonshotAI/kimi-code) at `@moonshot-ai/kimi-code@0.19.2`, distributed under upstream's MIT License (see LICENSE). Sibling packages are bundled into `dist`.
+from [MoonshotAI/kimi-code](https://github.com/MoonshotAI/kimi-code) at `@moonshot-ai/kimi-code@0.20.0`, distributed under upstream's MIT License (see LICENSE). Sibling packages are bundled into `dist`.
 Mirror + provenance: https://github.com/botiverse/kimi-code-sdk

package/README.md

@@ -1,6 +1,6 @@
 # @botiverse/kimi-code-sdk
 
-Built repackage of `@moonshot-ai/kimi-code-sdk` (kimi-code @moonshot-ai/kimi-code@0.19.2) for Slock/Botiverse.
+Built repackage of `@moonshot-ai/kimi-code-sdk` (kimi-code @moonshot-ai/kimi-code@0.20.0) for Slock/Botiverse.
 Read-only mirror + release notes: https://github.com/botiverse/kimi-code-sdk
 
 > Not affiliated with Moonshot AI. MIT (see LICENSE).

package/dist/index.d.mts

@@ -24,6 +24,7 @@ import type { OAuthDiscoveryState } from '@modelcontextprotocol/sdk/client/auth.
 import type { OAuthTokens } from '@modelcontextprotocol/sdk/shared/auth.js';
 import type { Readable } from 'node:stream';
 import { SessionMetaUpdatedEvent } from '@moonshot-ai/protocol';
+import type { SessionWarning } from '@moonshot-ai/protocol';
 import { SkillActivatedEvent } from '@moonshot-ai/protocol';
 import { SubagentCompletedEvent } from '@moonshot-ai/protocol';
 import { SubagentFailedEvent } from '@moonshot-ai/protocol';
@@ -145,6 +146,8 @@ declare class Agent {
 
 declare interface AgentAPI {
     prompt: (payload: PromptPayload) => void;
+    runShellCommand: (payload: RunShellCommandPayload) => Promise<ShellCommandResult>;
+    cancelShellCommand: (payload: CancelShellCommandPayload) => void;
     steer: (payload: SteerPayload) => void;
     cancel: (payload: CancelPayload) => void;
     undoHistory: (payload: UndoHistoryPayload) => void;
@@ -577,6 +580,7 @@ declare class BackgroundManager {
     readOutput(taskId: string, tail?: number): Promise<string>;
     suppressTerminalNotification(taskId: string): Promise<void>;
     detach(taskId: string): BackgroundTaskInfo | undefined;
+    persistOutput(taskId: string): void;
     /** Stop a running task. SIGTERM → 5s grace → SIGKILL. */
     stop(taskId: string, reason?: string): Promise<BackgroundTaskInfo | undefined>;
     stopAll(reason?: string): Promise<readonly BackgroundTaskInfo[]>;
@@ -847,6 +851,10 @@ declare interface CancelPlanPayload {
     readonly id?: string;
 }
 
+declare interface CancelShellCommandPayload {
+    readonly commandId: string;
+}
+
 /** Top-level catalog: `{ [providerId]: ProviderEntry }` (e.g. models.dev/api.json). */
 export declare type Catalog = Record<string, CatalogProviderEntry>;
 
@@ -1087,7 +1095,18 @@ declare class ContextMemory {
     get lastAssistantAt(): number | null;
     appendUserMessage(content: readonly ContentPart[], origin?: PromptOrigin): void;
     appendSystemReminder(content: string, origin: PromptOrigin): void;
+    /**
+     * Inject a user-invisible message and immediately send it to the model by
+     * launching/steering a turn. The content is used as-is (no wrapper tag), so
+     * callers can pass raw tool-result-style text or wrap it themselves. The
+     * message is skipped on replay / transcript (so the user never sees it) but
+     * is included in the context sent to the model. Use this for events the
+     * model must react to right away without surfacing a user-visible message.
+     */
+    injectAndNotify(content: string, origin?: PromptOrigin): void;
     appendLocalCommandStdout(content: string): void;
+    appendBashInput(command: string): void;
+    appendBashOutput(stdout: string, stderr: string, isError?: boolean): void;
     popMatchedMessage(matcher: (origin: PromptOrigin | undefined) => boolean): boolean;
     clear(): void;
     undo(count: number): void;
@@ -1663,6 +1682,12 @@ declare interface ExecutableToolContext {
     readonly metadata?: unknown;
     readonly signal: AbortSignal;
     readonly onUpdate?: ((update: ToolUpdate_2) => void) | undefined;
+    /**
+     * Fired once when a foreground (non-background) process task is registered,
+     * carrying its task id. Used by the `!` shell-command path so the TUI can
+     * later detach (ctrl+b) that exact task. Background runs skip it.
+     */
+    readonly onForegroundTaskStart?: ((taskId: string) => void) | undefined;
 }
 
 declare interface ExecutableToolErrorResult {
@@ -1672,6 +1697,8 @@ declare interface ExecutableToolErrorResult {
     readonly message?: string | undefined;
     /** See {@link ExecutableToolSuccessResult.stopTurn}. */
     readonly stopTurn?: boolean | undefined;
+    /** See {@link ExecutableToolSuccessResult.truncated}. */
+    readonly truncated?: boolean | undefined;
 }
 
 declare type ExecutableToolOutput = string | ContentPart[];
@@ -1695,6 +1722,12 @@ declare interface ExecutableToolSuccessResult {
      * this to the user.
      */
     readonly message?: string | undefined;
+    /**
+     * True when the tool has already returned a partial result because it
+     * truncated, paged, or otherwise dropped original output. Later generic
+     * budgeting must not treat the visible output as complete source text.
+     */
+    readonly truncated?: boolean | undefined;
 }
 
 export declare interface ExperimentalFeatureState {
@@ -2806,7 +2839,7 @@ export declare const KIMI_ERROR_INFO: {
         readonly title: "Turn exceeded max steps";
         readonly retryable: false;
         readonly public: true;
-        readonly action: "Increase loop_control.max_steps_per_turn or split the task.";
+        readonly action: "Increase loop_control.max_steps_per_turn in config.toml or split the task.";
     };
     readonly 'provider.api_error': {
         readonly title: "Provider API error";
@@ -3337,6 +3370,7 @@ declare class KimiCore implements PromisableMethods<CoreAPI> {
     resumeSessionWithOverrides(input: ResumeSessionPayload, overrides: {
         kaos?: Kaos;
         persistenceKaos?: Kaos;
+        forcePluginSessionStartReminder?: boolean;
     }): Promise<ResumeSessionResult>;
     reloadSession(input: ReloadSessionPayload): Promise<ResumeSessionResult>;
     forkSession(input: ForkSessionPayload): Promise<ResumeSessionResult>;
@@ -3348,6 +3382,8 @@ declare class KimiCore implements PromisableMethods<CoreAPI> {
     setKimiConfig(input: SetKimiConfigPayload): Promise<KimiConfig>;
     removeKimiProvider(input: RemoveKimiProviderPayload): Promise<KimiConfig>;
     prompt({ sessionId, ...payload }: SessionAgentPayload<PromptPayload>): Promise<void>;
+    runShellCommand({ sessionId, ...payload }: SessionAgentPayload<RunShellCommandPayload>): Promise<ShellCommandResult>;
+    cancelShellCommand({ sessionId, ...payload }: SessionAgentPayload<CancelShellCommandPayload>): Promise<void>;
     steer({ sessionId, ...payload }: SessionAgentPayload<SteerPayload>): Promise<void>;
     cancel({ sessionId, ...payload }: SessionAgentPayload<CancelPayload>): Promise<void>;
     undoHistory({ sessionId, ...payload }: SessionAgentPayload<UndoHistoryPayload>): Promise<void>;
@@ -3385,6 +3421,7 @@ declare class KimiCore implements PromisableMethods<CoreAPI> {
     getMcpStartupMetrics({ sessionId, ...payload }: SessionScopedPayload<EmptyPayload>): Promise<McpStartupMetrics>;
     reconnectMcpServer({ sessionId, ...payload }: SessionScopedPayload<ReconnectMcpServerPayload>): Promise<void>;
     generateAgentsMd({ sessionId, ...payload }: SessionScopedPayload<EmptyPayload>): Promise<void>;
+    getSessionWarnings({ sessionId, ...payload }: SessionScopedPayload<EmptyPayload>): Promise<readonly SessionWarning[]>;
     addAdditionalDir({ sessionId, ...payload }: SessionScopedPayload<AddAdditionalDirPayload>): Promise<AddAdditionalDirResult_2>;
     startBtw({ sessionId, ...payload }: SessionAgentPayload<EmptyPayload>): Promise<string>;
     createGoal({ sessionId, ...payload }: SessionAgentPayload<CreateGoalPayload>): Promise<GoalSnapshot>;
@@ -3525,7 +3562,7 @@ export declare class KimiHarness {
     setTelemetryContext(patch: TelemetryContextPatch): void;
     createSession(options: CreateSessionOptions): Promise<Session>;
     resumeSession(input: ResumeSessionInput): Promise<Session>;
-    reloadSession(input: ResumeSessionInput): Promise<Session>;
+    reloadSession(input: ReloadSessionInput): Promise<Session>;
     forkSession(input: ForkSessionInput): Promise<Session>;
     getSession(id: string): Session | undefined;
     closeSession(id: string): Promise<void>;
@@ -3974,6 +4011,7 @@ declare class McpConnectionManager {
 
 declare interface McpConnectionManagerOptions {
     readonly envLookup?: (name: string) => string | undefined;
+    readonly stdioCwd?: string;
     /**
      * Optional OAuth orchestrator. When provided, remote servers without a
      * static bearer token participate in the OAuth-via-synthetic-tool flow:
@@ -4687,7 +4725,10 @@ export declare interface PluginSummary {
     readonly github?: PluginGithubMetadata;
 }
 
-declare type PreparedSystemPromptContext = Pick<SystemPromptContext, 'cwdListing' | 'agentsMd' | 'additionalDirsInfo'>;
+declare interface PreparedSystemPromptContext extends Pick<SystemPromptContext, 'cwdListing' | 'agentsMd' | 'additionalDirsInfo'> {
+    /** Present when the combined AGENTS.md content exceeds the recommended size. */
+    readonly agentsMdWarning?: string;
+}
 
 declare interface PrepareToolExecutionResult extends AuthorizeToolExecutionResult {
     readonly updatedArgs?: unknown;
@@ -4714,7 +4755,7 @@ declare type Promisify<T> = [T] extends [Promise<any>] ? T : Promise<T>;
 
 export declare type PromptInput = readonly PromptPart[];
 
-export declare type PromptOrigin = UserPromptOrigin | SkillActivationOrigin | InjectionOrigin | CompactionSummaryOrigin | SystemTriggerOrigin | BackgroundTaskOrigin | CronJobOrigin | CronMissedOrigin | HookResultOrigin | RetryOrigin;
+export declare type PromptOrigin = UserPromptOrigin | SkillActivationOrigin | InjectionOrigin | ShellCommandOrigin | CompactionSummaryOrigin | SystemTriggerOrigin | BackgroundTaskOrigin | CronJobOrigin | CronMissedOrigin | HookResultOrigin | RetryOrigin;
 
 export declare type PromptPart = Extract<ContentPart, {
     type: 'text' | 'image_url' | 'video_url';
@@ -4865,6 +4906,12 @@ declare interface RegisterBackgroundTaskOptions {
     readonly detached?: boolean;
     /** Deadline owned by BackgroundManager. `0` and `undefined` do not arm a timer. */
     readonly timeoutMs?: number;
+    /**
+     * When set, detaching a foreground task resets its deadline to this value
+     * (counted from the detach moment). Lets a command started with a short
+     * foreground timeout run longer once it is moved to the background.
+     */
+    readonly detachTimeoutMs?: number;
     /** Foreground caller signal. Ignored for tasks created already detached. */
     readonly signal?: AbortSignal;
 }
@@ -4877,8 +4924,27 @@ declare interface RegisterToolPayload {
 
 declare type ReloadPluginsResult = ReloadSummary;
 
+export declare interface ReloadSessionInput extends ResumeSessionInput {
+    readonly forcePluginSessionStartReminder?: boolean;
+}
+
+export declare interface ReloadSessionOptions {
+    readonly forcePluginSessionStartReminder?: boolean;
+}
+
 declare interface ReloadSessionPayload {
     readonly sessionId: string;
+    /**
+     * When true, append a fresh `<plugin_session_start>` system reminder to the
+     * main agent after the session is reloaded, reflecting the currently enabled
+     * plugins. Used by the explicit `/reload` command so the model sees plugin
+     * changes without starting a new session. Defaults to false.
+     */
+    readonly forcePluginSessionStartReminder?: boolean;
+}
+
+declare interface ReloadSessionRpcInput extends SessionIdRpcInput {
+    readonly forcePluginSessionStartReminder?: boolean;
 }
 
 export declare interface ReloadSummary {
@@ -5060,6 +5126,16 @@ declare interface RunnableToolExecution {
     readonly execute: (ctx: ExecutableToolContext) => Promise<ExecutableToolResult>;
 }
 
+declare interface RunShellCommandPayload {
+    readonly command: string;
+    /**
+     * TUI-generated correlation id echoed back on every `shell.output` live event
+     * so the client can route chunks to the matching entry and drop stale events
+     * from a prior run. Optional for callers that don't stream.
+     */
+    readonly commandId?: string;
+}
+
 declare interface RunSubagentOptions {
     readonly parentToolCallId: string;
     readonly parentToolCallUuid?: string;
@@ -5130,7 +5206,7 @@ export declare abstract class SDKRpcClientBase {
     createSessionWithKaos(input: CreateSessionOptions, kaos: Kaos, persistenceKaos?: Kaos): Promise<SessionSummary>;
     resumeSession(input: ResumeSessionInput): Promise<ResumedSessionSummary>;
     resumeSessionWithKaos(input: ResumeSessionInput, kaos: Kaos, persistenceKaos?: Kaos): Promise<ResumedSessionSummary>;
-    reloadSession(input: SessionIdRpcInput): Promise<ResumedSessionSummary>;
+    reloadSession(input: ReloadSessionRpcInput): Promise<ResumedSessionSummary>;
     forkSession(input: ForkSessionInput): Promise<SessionSummary>;
     closeSession(input: SessionIdRpcInput): Promise<void>;
     listSessions(input?: ListSessionsOptions): Promise<readonly SessionSummary[]>;
@@ -5142,8 +5218,27 @@ export declare abstract class SDKRpcClientBase {
     setConfig(input: KimiConfigPatch): Promise<KimiConfig>;
     removeProvider(providerId: string): Promise<KimiConfig>;
     prompt(input: SessionPromptRpcInput): Promise<void>;
+    runShellCommand(input: {
+        sessionId: string;
+        command: string;
+        commandId?: string;
+    }): Promise<{
+        stdout: string;
+        stderr: string;
+        isError?: boolean;
+        backgrounded?: boolean;
+    }>;
+    cancelShellCommand(input: {
+        sessionId: string;
+        commandId: string;
+    }): Promise<void>;
     steer(input: SessionPromptRpcInput): Promise<void>;
     generateAgentsMd(input: SessionIdRpcInput): Promise<void>;
+    getSessionWarnings(input: SessionIdRpcInput): Promise<readonly {
+        code: string;
+        message: string;
+        severity: "error" | "info" | "warning";
+    }[]>;
     addAdditionalDir(input: AddAdditionalDirInput): Promise<AddAdditionalDirResult>;
     startBtw(input: SessionIdRpcInput): Promise<string>;
     cancel(input: SessionIdRpcInput): Promise<void>;
@@ -5268,14 +5363,32 @@ export declare class Session {
     private closed;
     constructor(options: SessionOptions);
     getResumeState(): ResumedSessionState | undefined;
-    reloadSession(): Promise<ResumedSessionSummary>;
+    reloadSession(options?: ReloadSessionOptions): Promise<ResumedSessionSummary>;
     onEvent(listener: (event: Event_2) => void): Unsubscribe;
     setApprovalHandler(handler: ApprovalHandler | undefined): void;
     setQuestionHandler(handler: QuestionHandler | undefined): void;
     prompt(input: string | PromptInput): Promise<void>;
+    /** Execute a user-initiated `!` shell command (silent — does not prompt the
+     *  model). Resolves with the command's stdout/stderr for immediate display.
+     *  Pass `commandId` to receive live `shell.output` events for this command. */
+    runShellCommand(command: string, options?: {
+        commandId?: string;
+    }): Promise<{
+        stdout: string;
+        stderr: string;
+        isError?: boolean;
+        backgrounded?: boolean;
+    }>;
+    /** Cancel a running `!` shell command by its commandId (e.g. on Esc / Ctrl+C). */
+    cancelShellCommand(commandId: string): Promise<void>;
     steer(input: string | PromptInput): Promise<void>;
     swarm(input: string | PromptInput): Promise<void>;
     init(): Promise<void>;
+    getSessionWarnings(): Promise<readonly {
+        code: string;
+        message: string;
+        severity: "error" | "info" | "warning";
+    }[]>;
     addAdditionalDir(path: string, options?: AddAdditionalDirOptions): Promise<AddAdditionalDirResult>;
     startBtw(): Promise<string>;
     cancel(): Promise<void>;
@@ -5371,6 +5484,7 @@ declare class Session_2 {
     private readonly skillsReady;
     metadata: SessionMeta;
     private writeMetadataPromise;
+    private agentsMdWarning;
     constructor(options: SessionOptions_2);
     setToolKaos(kaos: Kaos): void;
     getAdditionalDirs(): readonly string[];
@@ -5408,7 +5522,24 @@ declare class Session_2 {
      * through here so the two paths cannot drift apart.
      */
     private bootstrapAgentProfile;
+    getSessionWarnings(): Promise<readonly SessionWarning[]>;
+    private computeAgentsMdWarning;
     generateAgentsMd(): Promise<void>;
+    /**
+     * Appends a fresh `<plugin_session_start>` system reminder to the main agent
+     * using the currently enabled plugins, then flushes records so the reminder is
+     * persisted and visible on the wire. Used by the explicit `/reload` flow after
+     * the session has been re-resumed with reloaded plugin state.
+     *
+     * When no plugin session start is currently resolvable but an earlier
+     * When no plugin session start is currently resolvable but the context may still
+     * carry stale plugin guidance — either an earlier `<plugin_session_start>`
+     * reminder, or a compaction summary that may have folded one in — appends a
+     * neutralizing reminder instead, so the model does not keep following stale
+     * plugin instructions and the turn-loop injector does not dedup against them.
+     */
+    appendPluginSessionStartReminder(): Promise<void>;
+    private shouldNeutralizePluginSessionStart;
     get hasActiveTurn(): boolean;
     protected get metadataPath(): string;
     writeMetadata(): Promise<void>;
@@ -5444,6 +5575,7 @@ declare interface SessionAPI extends AgentAPIWithId {
     getMcpStartupMetrics: (payload: EmptyPayload) => McpStartupMetrics;
     reconnectMcpServer: (payload: ReconnectMcpServerPayload) => void;
     generateAgentsMd: (payload: EmptyPayload) => void;
+    getSessionWarnings: (payload: EmptyPayload) => readonly SessionWarning[];
     addAdditionalDir: (payload: AddAdditionalDirPayload) => AddAdditionalDirResult_2;
 }
 
@@ -5751,6 +5883,26 @@ declare interface SetThinkingPayload {
     readonly level: string;
 }
 
+declare interface ShellCommandOrigin {
+    readonly kind: 'shell_command';
+    readonly phase: 'input' | 'output';
+    /** Only present on `phase: 'output'` — whether the command failed, so replay
+     *  can colour stderr red only for actual failures (not warnings). */
+    readonly isError?: boolean;
+}
+
+declare interface ShellCommandResult {
+    readonly stdout: string;
+    readonly stderr: string;
+    /** True when the command failed (non-zero exit / timeout / killed) — used by
+     *  the TUI to render stderr in red only for actual failures, not warnings. */
+    readonly isError?: boolean;
+    /** True when the command was detached to the background (ctrl+b) instead of
+     *  completing in the foreground. The TUI uses this to skip the normal final
+     *  render (the backgrounding path owns the UI + model notification). */
+    readonly backgrounded?: boolean;
+}
+
 export declare interface ShellEnvironment {
     readonly term?: string | undefined;
     readonly termProgram?: string | undefined;
@@ -6250,10 +6402,26 @@ declare class ToolManager {
     private mcpAccessPatterns;
     protected readonly store: Partial<ToolStoreData>;
     private mcpToolStatusUnsubscribe;
+    /** Abort controllers for in-flight `!` shell commands, keyed by commandId so
+     *  the TUI can cancel (Esc / Ctrl+C) a running command. */
+    private readonly shellCommandControllers;
     constructor(agent: Agent);
     protected get toolStore(): ToolStore;
     attachMcpTools(): void;
     updateStore<K extends ToolStoreKey>(key: K, value: ToolStoreData[K]): void;
+    /**
+     * Execute a user-initiated `!` shell command. Reuses the builtin Bash tool
+     * (same kaos / cwd / BackgroundManager as the agent), recording the command
+     * and its output as `shell_command`-origin messages. It does NOT start a turn
+     * — the model is not prompted (parity with claude-code's `shouldQuery: false`).
+     */
+    runShellCommand(command: string, commandId?: string): Promise<{
+        stdout: string;
+        stderr: string;
+        isError?: boolean;
+        backgrounded?: boolean;
+    }>;
+    cancelShellCommand(commandId: string): void;
     registerUserTool(input: UserToolRegistration): void;
     unregisterUserTool(name: string): void;
     inheritUserTools(parent: ToolManager): void;