@khorsheed/dsh-local-agent-kimi 0.2.0 → 0.2.2

package/lib/types/member-bridge-config.js

@@ -12,6 +12,8 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 /** Kimi's user-level MCP config filename inside the scoped home. */
 const MCP_CONFIG_FILENAME = 'mcp.json';
+/** The member bridge's per-call bound: as long as a question card waits for the human (30 min). */
+export const MEMBER_TOOL_TIMEOUT_MS = 30 * 60_000;
 /** Server-key prefix marking the family's per-run bridge entries. */
 export const MEMBER_BRIDGE_SERVER_PREFIX = 'dsh-member-';
 /**
@@ -60,7 +62,9 @@ export function injectMemberBridge(homeDir, key, command, env) {
         if (name.startsWith(MEMBER_BRIDGE_SERVER_PREFIX) && name !== key)
             delete servers[name];
     }
-    servers[key] = { command: command.command, args: command.args, env };
+    // A bridge call may wait for the human (ask_user_question, a mode tool's
+    // approval): kimi's 60s MCP default fails it first and the answer is lost.
+    servers[key] = { command: command.command, args: command.args, env, toolTimeoutMs: MEMBER_TOOL_TIMEOUT_MS };
     writeMcpConfig(file, { ...config, mcpServers: servers });
 }
 /**

package/lib/types/session-mirror.js

@@ -71,6 +71,14 @@ export function nextWrittenKimiStep(childSession, turn) {
     }
     return last + 1;
 }
+/** Wire usage records already counted, per child session (see mirrorKimiSessionDelta). */
+const countedUsage = new WeakMap();
+const usageSeen = (childSession) => {
+    let seen = countedUsage.get(childSession);
+    if (seen === undefined)
+        countedUsage.set(childSession, seen = new Set());
+    return seen;
+};
 /** The run-progress delta text for one transcript line (any kind). */
 export function kimiLineProgressText(line) {
     if (line.kind !== 'tool')
@@ -245,6 +253,13 @@ export async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSes
     // step-tagged unit claims its own line span's records; records no tagged
     // unit claims (untagged spans on older wires, or the boundary) sum onto the
     // pass's last folded content unit — the pre-tagging shape.
+    // A record counts once per child session, ever: the boundary is inclusive, so
+    // a pass whose offset cannot advance (a held unit) re-reads the same boundary
+    // record on every poll — one 320k-token record was carried ten times onto a
+    // cancelled round's step (3.2M). Wire line numbers only grow, so the line
+    // identifies the record across passes and rounds.
+    const seen = usageSeen(childSession);
+    const usageRecords = transcript.usageRecords.filter(record => !seen.has(record.line));
     const unitUsage = [];
     const claimed = [];
     let unitStart = fromLines;
@@ -254,15 +269,18 @@ export async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSes
         const head = unit[0];
         if (head.kind !== 'user' && head.wireStep !== undefined) {
             claimed.push({ from: start, to: unitStart });
-            unitUsage.push(sumUsageRecords(transcript.usageRecords.filter(record => record.line >= start && record.line < unitStart)));
+            unitUsage.push(sumUsageRecords(usageRecords.filter(record => record.line >= start && record.line < unitStart)));
         }
         else {
             unitUsage.push(undefined);
         }
     }
-    const unclaimedUsage = sumUsageRecords(transcript.usageRecords.filter(record => record.line >= fromLines && record.line <= consumedTotal
+    const unclaimedUsage = sumUsageRecords(usageRecords.filter(record => record.line >= fromLines && record.line <= consumedTotal
         && !claimed.some(span => record.line >= span.from && record.line < span.to)));
-    const deltaUsage = sumUsageRecords(transcript.usageRecords.filter(record => record.line >= fromLines && record.line <= consumedTotal));
+    const windowRecords = usageRecords.filter(record => record.line >= fromLines && record.line <= consumedTotal);
+    const deltaUsage = sumUsageRecords(windowRecords);
+    for (const record of windowRecords)
+        seen.add(record.line);
     // The steps a fold may NOT take: every step already written (the session's
     // own event ledger), consulted per turn. A round mirrored across several
     // live polls keeps its earlier writes, so later polls never reuse them.
@@ -296,6 +314,20 @@ export async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSes
         written.add(step);
         takenSteps.set(turn, written);
     };
+    // Turns the log has already closed take no more writes: the released-log
+    // reader admits events only inside the open turn. A backlog the offset never
+    // covered (a fold that failed for rounds, then an offset lost on restart)
+    // would otherwise land old content inside a finished turn — or, after the
+    // next turn opened, corrupt the whole log. Those units are skipped; the
+    // offset still moves past them.
+    const closedTurns = new Set();
+    for (const event of childSession.snapshotEvents()) {
+        if (event.type !== 'turn/end')
+            continue;
+        const closed = event.data.turn;
+        if (typeof closed === 'number')
+            closedTurns.add(closed);
+    }
     /** The window's accounting that no fold carried (dropped units' sums). */
     let carryUsage;
     // The pass's last content unit carries the records no tagged unit claimed.
@@ -319,6 +351,8 @@ export async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSes
         // numbering) is the dsh round; no offset is needed because both count the
         // same rounds.
         const turn = head.turn;
+        if (closedTurns.has(turn))
+            continue;
         if (head.kind === 'user') {
             // The live driver appends the round's user/message at turn start (so the
             // question renders before the streamed think/text instead of after it).

package/lib/types/session-view.d.ts

@@ -104,6 +104,17 @@ export declare function findKimiSessionDir(homeDir: string, sessionId: string):
  * @returns the transcript.
  */
 export declare function readKimiTranscript(sessionDir: string): Promise<KimiSessionTranscript>;
+/**
+ * A wire tool result's output as display text. Most tools report a string;
+ * a media read (ReadMediaFile) reports content parts — text parts keep their
+ * text, an image part becomes a short marker (its bytes stay in kimi's blob
+ * store). Anything else reads as no output, never a parse failure: one
+ * unreadable result must not stop the whole transcript (and the round's
+ * usage) from folding.
+ * @param raw - the result's `output` field.
+ * @returns the text, or undefined when there is none.
+ */
+export declare function toolOutputText(raw: unknown): string | undefined;
 /**
  * Map a wire `usage.record` payload onto the shared usage contract. kimi
  * reports input (uncached), cache read, cache creation, and output; the

package/lib/types/session-view.js

@@ -105,6 +105,8 @@ function editArgsOf(name, record) {
         return patch;
     return undefined;
 }
+/** Cap on a structured tool call's mirrored JSON arguments. */
+const STRUCTURED_ARGS_MAX = 16_000;
 /** Render a tool call's arguments into a compact summary. */
 function argsOf(name, args) {
     if (args === undefined)
@@ -119,6 +121,13 @@ function argsOf(name, args) {
     const edit = editArgsOf(name, record);
     if (edit !== undefined)
         return edit;
+    // Structured arguments (an MCP tool's nested questions, options, lists)
+    // keep their full JSON: the one-line summary below keeps only scalars and
+    // dropped them, so the member's ask_user_question read as called with nothing.
+    if (Object.values(record).some(value => typeof value === 'object' && value !== null)) {
+        const json = JSON.stringify(record);
+        return json.length <= STRUCTURED_ARGS_MAX ? json : `${json.slice(0, STRUCTURED_ARGS_MAX)}…`;
+    }
     // WebSearch/FetchURL expose a query/url; prefer the most meaningful scalar.
     for (const key of ['query', 'url', 'path', 'command']) {
         const value = record[key];
@@ -168,6 +177,8 @@ export async function readKimiTranscript(sessionDir) {
     // turn/start numbering.
     let turn = 0;
     let turnSeen = false;
+    /** The wire marks rounds with turn.prompt (current kimi): a user message it did not prompt is an injection. */
+    let promptsMarkTurns = false;
     // Tool calls by uuid and toolCallId, so a result attaches to its own call
     // even when several calls run in parallel within one step.
     const callsByUuid = new Map();
@@ -228,6 +239,7 @@ export async function readKimiTranscript(sessionDir) {
             continue;
         }
         if (event.type === 'turn.prompt') {
+            promptsMarkTurns = true;
             lineModel = undefined;
             // Each round's user prompt opens the next turn; the matching
             // context.append_message below is deduped against this text.
@@ -254,6 +266,13 @@ export async function readKimiTranscript(sessionDir) {
                     // Duplicate of the prompt; skip.
                     continue;
                 }
+                // A wire that opens every round with turn.prompt: any other user
+                // message is kimi's own injection inside the round (a Skill's loaded
+                // instructions, a steer) — its loop events keep the same turnId. It
+                // opens no turn (the dsh round is still running: a turn here wrote
+                // steps into a turn the log never opened) and is not the human's.
+                if (promptsMarkTurns)
+                    continue;
                 turnSeen = true;
                 turn += 1;
                 lineModel = undefined;
@@ -309,7 +328,7 @@ export async function readKimiTranscript(sessionDir) {
             }
             else if (loop.type === 'tool.result') {
                 const result = loop;
-                const output = result.result?.output;
+                const output = toolOutputText(result.result?.output);
                 let target = typeof result.parentUuid === 'string'
                     ? callsByUuid.get(result.parentUuid)
                     : undefined;
@@ -346,6 +365,31 @@ export async function readKimiTranscript(sessionDir) {
     }
     return { sessionId, lines, usageRecords, closedSteps, ...model === undefined ? {} : { model }, ...modelTurn === undefined ? {} : { modelTurn } };
 }
+/**
+ * A wire tool result's output as display text. Most tools report a string;
+ * a media read (ReadMediaFile) reports content parts — text parts keep their
+ * text, an image part becomes a short marker (its bytes stay in kimi's blob
+ * store). Anything else reads as no output, never a parse failure: one
+ * unreadable result must not stop the whole transcript (and the round's
+ * usage) from folding.
+ * @param raw - the result's `output` field.
+ * @returns the text, or undefined when there is none.
+ */
+export function toolOutputText(raw) {
+    if (typeof raw === 'string')
+        return raw;
+    if (!Array.isArray(raw))
+        return undefined;
+    const parts = raw.map((part) => {
+        if (part === null || typeof part !== 'object')
+            return '';
+        const entry = part;
+        if (entry.type === 'text' && typeof entry.text === 'string')
+            return entry.text;
+        return typeof entry.type === 'string' && entry.type !== '' ? `[${entry.type}]` : '';
+    });
+    return parts.join('');
+}
 /**
  * Map a wire `usage.record` payload onto the shared usage contract. kimi
  * reports input (uncached), cache read, cache creation, and output; the

package/package.json

@@ -8,7 +8,7 @@
     "local-agent",
     "kimi"
   ],
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -69,7 +69,7 @@
     "dsh": ">=0.1.5-rc.1 <0.3.0-0"
   },
   "dependencies": {
-    "@khorsheed/dsh-local-agent": "^0.2.0"
+    "@khorsheed/dsh-local-agent": "^0.2.2"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",