@botiverse/kimi-code-sdk 0.15.0 → 0.17.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.15.0`, 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.17.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.15.0) for Slock/Botiverse.
+Built repackage of `@moonshot-ai/kimi-code-sdk` (kimi-code @moonshot-ai/kimi-code@0.17.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

@@ -78,6 +78,7 @@ declare class Agent {
     readonly log: Logger;
     readonly telemetry: TelemetryClient;
     readonly experimentalFlags: ExperimentalFlagResolver;
+    readonly llmRequestLogger: LlmRequestLogger;
     readonly blobStore: BlobStore | undefined;
     readonly records: AgentRecords;
     readonly fullCompaction: FullCompaction;
@@ -96,15 +97,12 @@ declare class Agent {
     readonly cron: CronManager | null;
     readonly goal: GoalMode;
     readonly replayBuilder: ReplayBuilder;
-    private lastLlmConfigLogSignature?;
     constructor(options: AgentOptions);
     setKaos(kaos: Kaos): void;
     get generate(): typeof generate;
     get llm(): KosongLLM;
-    private logLlmRequest;
-    private logLlmConfigIfChanged;
     useProfile(profile: ResolvedAgentProfile, context?: PreparedSystemPromptContext): void;
-    resume(): Promise<{
+    resume(options?: AgentRecordsReplayOptions): Promise<{
         warning?: string;
     }>;
     get rpcMethods(): PromisableMethods<AgentAPI>;
@@ -215,6 +213,7 @@ declare interface AgentOptions {
     readonly telemetry?: TelemetryClient | undefined;
     readonly pluginSessionStarts?: readonly EnabledPluginSessionStart[];
     readonly experimentalFlags?: ExperimentalFlagResolver;
+    readonly replay?: ReplayBuilderOptions;
 }
 
 declare type AgentRecord = {
@@ -326,13 +325,17 @@ declare class AgentRecords {
     constructor(agent: Agent, persistence?: AgentRecordPersistence | undefined);
     get restoring(): RestoringContext | null;
     logRecord(record: AgentRecord): void;
-    restore(record: AgentRecord): void;
-    replay(): Promise<{
+    restore(record: AgentRecord): boolean;
+    replay(options?: AgentRecordsReplayOptions): Promise<{
         warning?: string;
     }>;
     flush(): Promise<void>;
 }
 
+declare interface AgentRecordsReplayOptions {
+    readonly rewriteMigratedRecords?: boolean;
+}
+
 export declare type AgentReplayRecord = {
     readonly time: number;
 } & AgentReplayRecordPayload;
@@ -448,6 +451,10 @@ declare interface ApprovalResponse_2 {
 
 export declare type ApprovalScope = 'session';
 
+declare interface ArchiveSessionPayload {
+    readonly sessionId: string;
+}
+
 export { AssistantDeltaEvent }
 
 declare interface AudioURLPart {
@@ -900,6 +907,13 @@ declare interface ChatProvider {
     uploadVideo?(input: string | VideoUploadInput, options?: GenerateOptions): Promise<VideoURLPart>;
 }
 
+declare interface ClientTelemetryInfo {
+    readonly id?: string | undefined;
+    readonly name?: string | undefined;
+    readonly version?: string | undefined;
+    readonly uiMode?: string | undefined;
+}
+
 declare interface ClockSources {
     /**
      * Wall-clock epoch milliseconds. May be overridden in tests / bench
@@ -918,10 +932,6 @@ declare interface CloseSessionPayload {
     readonly sessionId: string;
 }
 
-declare interface CompactedHistory {
-    text: string;
-}
-
 declare interface CompactionBeginData {
     instruction?: string;
     source: CompactionSource;
@@ -957,8 +967,6 @@ declare interface CompactionSummaryOrigin {
     readonly kind: 'compaction_summary';
 }
 
-declare type CompactionTelemetryTrigger = CompactionBeginData['source'] | 'manual-with-prompt' | 'unknown';
-
 export declare interface CompactOptions {
     readonly instruction?: string | undefined;
 }
@@ -1058,6 +1066,7 @@ declare interface CoreAPI extends SessionAPIWithId {
     removeKimiProvider: (payload: RemoveKimiProviderPayload) => KimiConfig;
     createSession: (payload: CreateSessionPayload) => SessionSummary_2;
     closeSession: (payload: CloseSessionPayload) => void;
+    archiveSession: (payload: ArchiveSessionPayload) => void;
     resumeSession: (payload: ResumeSessionPayload) => ResumeSessionResult;
     reloadSession: (payload: ReloadSessionPayload) => ResumeSessionResult;
     forkSession: (payload: ForkSessionPayload) => ResumeSessionResult;
@@ -1125,6 +1134,7 @@ declare interface CreateSessionPayload {
     readonly permission?: PermissionMode_2 | undefined;
     readonly metadata?: JsonObject_2 | undefined;
     readonly mcpServers?: Readonly<Record<string, McpServerConfig>>;
+    readonly client?: ClientTelemetryInfo | undefined;
 }
 
 export { CronFiredEvent }
@@ -1833,20 +1843,14 @@ declare class FullCompaction {
     protected compactionCountInTurn: number;
     protected compacting: {
         abortController: AbortController;
-        startedAt: number;
-        telemetryTrigger: CompactionTelemetryTrigger;
         promise: Promise<void>;
         blockedByTurn: boolean;
     } | null;
-    protected _compactedHistory: CompactedHistory[];
     protected readonly strategy: CompactionStrategy;
     constructor(agent: Agent, strategy?: CompactionStrategy);
     get isCompacting(): boolean;
-    get compactedHistory(): readonly CompactedHistory[];
     begin(data: Readonly<CompactionBeginData>): void;
-    private startCompactionWorker;
     cancel(): void;
-    private markCanceled;
     markCompleted(): void;
     private get tokenCountWithPending();
     resetForTurn(): void;
@@ -1857,6 +1861,7 @@ declare class FullCompaction {
     private beginAutoCompaction;
     private block;
     private compactionWorker;
+    private compactionRound;
     private triggerPreCompactHook;
     private triggerPostCompactHook;
     private postProcessSummary;
@@ -2529,6 +2534,8 @@ declare interface KaosProcess {
     wait(): Promise<number>;
     /** Send a signal to the process (defaults to `SIGTERM`). */
     kill(signal?: NodeJS.Signals): Promise<void>;
+    /** Release stdin/stdout/stderr resources owned by this process wrapper. */
+    dispose(): Promise<void> | void;
 }
 
 export declare const KIMI_ERROR_INFO: {
@@ -3260,6 +3267,7 @@ declare class KimiCore implements PromisableMethods<CoreAPI> {
     getCoreInfo(): CoreInfo;
     getExperimentalFeatures(): readonly ExperimentalFeatureState[];
     closeSession({ sessionId }: CloseSessionPayload): Promise<void>;
+    archiveSession({ sessionId }: ArchiveSessionPayload): Promise<void>;
     resumeSession(input: ResumeSessionPayload): Promise<ResumeSessionResult>;
     resumeSessionWithOverrides(input: ResumeSessionPayload, overrides: {
         kaos?: Kaos;
@@ -3531,7 +3539,6 @@ declare class KosongLLM implements LLM {
 
 declare interface KosongLLMConfig {
     readonly provider: ChatProvider;
-    readonly modelName: string;
     readonly systemPrompt: string;
     readonly capability?: ModelCapability | undefined;
     /**
@@ -3555,6 +3562,7 @@ export declare interface ListSessionsOptions {
 declare interface ListSessionsPayload {
     readonly workDir?: string;
     readonly sessionId?: string;
+    readonly includeArchive?: boolean;
 }
 
 declare interface LLM {
@@ -3569,7 +3577,7 @@ declare interface LLMChatParams {
     messages: Message[];
     tools: readonly Tool[];
     signal: AbortSignal;
-    requestLogContext?: LLMRequestLogContext;
+    requestLogFields?: LLMRequestLogFields;
     onTextDelta?: ((delta: string) => void) | undefined;
     onThinkDelta?: ((delta: string) => void) | undefined;
     onToolCallDelta?: ((delta: ToolCallDelta) => void) | undefined;
@@ -3597,12 +3605,23 @@ declare interface LLMChatResponse {
     streamTiming?: LLMStreamTiming;
 }
 
-declare interface LLMRequestLogContext {
-    readonly turnId?: string;
-    readonly step?: number;
-    readonly stepUuid?: string;
-    readonly attempt?: number;
-    readonly maxAttempts?: number;
+declare interface LLMRequestLogFields {
+    readonly turnStep: string;
+    readonly attempt?: string;
+}
+
+declare class LlmRequestLogger {
+    private readonly log;
+    private lastConfigLogSignature;
+    constructor(log: Logger);
+    logRequest(input: {
+        readonly provider: ChatProvider;
+        readonly modelAlias?: string;
+        readonly systemPrompt: string;
+        readonly tools: readonly Tool[];
+        readonly messages: readonly Message[];
+        readonly fields: LLMRequestLogFields | undefined;
+    }): void;
 }
 
 declare interface LLMStreamTiming {
@@ -3617,6 +3636,17 @@ declare interface LLMStreamTiming {
  */
 export declare function loadBuiltInCatalog(text?: string): Catalog | undefined;
 
+/**
+ * Lenient variant of `loadRuntimeConfig` that never throws: schema errors
+ * drop only the offending sections (whole entry for `providers`/`models`,
+ * whole top-level section otherwise) and a bad KIMI_MODEL_* env overlay is
+ * skipped, each reported as a warning. A file that cannot be used at all
+ * additionally sets `fileError` so startup can fail fast while mid-run
+ * reloads degrade. Runtime read paths use this; write paths must keep using
+ * the strict readers so a broken file is never silently rewritten.
+ */
+export declare function loadRuntimeConfigSafe(filePath: string, env?: Readonly<Record<string, string | undefined>>): RuntimeConfigLoadResult;
+
 /**
  * Root logger. Import and use directly for events that don't belong to any
  * session (CLI startup, harness construction, etc.):
@@ -4798,18 +4828,37 @@ declare type RenameSessionRequest = SessionScopedPayload<RenameSessionPayload>;
 
 declare class ReplayBuilder {
     readonly agent: Agent;
+    private readonly options;
     postRestoring: boolean;
     captureLiveRecords: boolean;
     protected readonly records: AgentReplayRecord[];
-    constructor(agent: Agent);
+    private frozen;
+    private segmentStart;
+    constructor(agent: Agent, options?: ReplayBuilderOptions);
     push(record: AgentReplayRecordPayload): void;
     patchLast<T extends AgentReplayRecord['type']>(type: T, patch: Partial<Extract<AgentReplayRecord, {
         type: T;
     }>>): void;
     removeLastMessages(removedMessages: ReadonlySet<ContextMessage>): void;
+    finishRestoringRecord(type: string): boolean;
     buildResult(): readonly AgentReplayRecord[];
+    private removeMessagesFrom;
+}
+
+declare interface ReplayBuilderOptions {
+    readonly range?: ReplayRangeOptions;
+}
+
+declare interface ReplayRangeOptions {
+    readonly start?: number;
+    readonly count?: number;
 }
 
+export declare function resolveConfigPath(input: {
+    readonly homeDir?: string | undefined;
+    readonly configPath?: string | undefined;
+}): string;
+
 declare interface ResolvedAgentProfile {
     name: string;
     description?: string;
@@ -4937,6 +4986,22 @@ declare interface RunSubagentOptions {
     readonly suppressRateLimitFailureEvent?: boolean;
 }
 
+declare interface RuntimeConfigLoadResult {
+    readonly config: KimiConfig;
+    /** Problems in config.toml itself; non-empty means parts (or all) of the file were ignored. */
+    readonly fileWarnings: readonly string[];
+    /** Problems applying KIMI_MODEL_* env overrides; the overlay was skipped. */
+    readonly envWarnings: readonly string[];
+    /**
+     * Set when the file is entirely unusable (unreadable, TOML syntax error, or
+     * nothing salvageable) and `config` is pure defaults. Startup fails fast on
+     * this — defaults-only means the user looks logged out, which is worse than
+     * an actionable parse error. Mid-run reloads ignore it and keep the last
+     * good config instead.
+     */
+    readonly fileError?: KimiError;
+}
+
 declare interface SDKAgentAPI {
     emitEvent: (event: AgentEvent) => void;
     requestApproval: (request: ApprovalRequest) => Promise<ApprovalResponse>;
@@ -6192,6 +6257,16 @@ declare class TurnFlow {
     /** Allocates the next monotonic turn id. */
     private allocateTurnId;
     restorePrompt(): void;
+    /**
+     * Raise the turn counter to cover a turnId observed in a replayed loop event.
+     * This is the authoritative source of the restored counter: every turn that
+     * ran — a prompted turn, a goal continuation, or a steer-launched turn —
+     * emits loop events carrying its real turnId, even though only prompted turns
+     * write a `turn.prompt` record. Resuming then continues from `max + 1`. Only
+     * ever raises the counter, never lowers it, so the live path (where `turnId`
+     * is already allocated before any loop event) is unaffected.
+     */
+    observeRestoredTurnId(turnId: number): void;
     restoreSteer(input: readonly ContentPart[], origin: PromptOrigin): void;
     cancel(turnId?: number, reason?: unknown): void;
     get currentId(): number;