@deepseek-harness-tui/dsh-tui 0.12.0 → 0.14.0

package/lib/types/backends/claude/translate/attempts.js

@@ -0,0 +1,243 @@
+import { t } from '../../../i18n.js';
+import { arr, num, rec, str } from '../narrow.js';
+import { narrationOf, usageOf } from './content.js';
+/** Abort diagnostics the CLI appends to `result.errors` (never shown). */
+const EDE_DIAGNOSTIC = '[ede_diagnostic]';
+/** Settled API message ids remembered (a late block only ever trails the
+ *  response it belongs to by a few messages). */
+export const MAX_SETTLED_ATTEMPTS = 256;
+export function createAttemptTranslator(context) {
+    const { settledAttempts, now, nextSeq } = context;
+    const closeStep = (out) => {
+        if (!context.stepOpen)
+            return;
+        context.stepOpen = false;
+        out.push({ type: 'step.end', turn: context.turn, step: context.step });
+    };
+    const openTurn = (out, origin, userMessageId) => {
+        if (context.turnOpen)
+            return;
+        context.turnOpen = true;
+        context.turn += 1;
+        context.step = 0;
+        context.turnTime = now();
+        context.toolResults = 0;
+        context.narrated = undefined;
+        // An unprompted turn right after a task notification is the model
+        // reporting on it: a notice stands where a user bubble would be.
+        const notified = origin === 'system' && context.notificationTurnExpected;
+        context.notificationTurnExpected = false;
+        out.push({ type: 'turn.start', turn: context.turn, origin: notified ? 'notification' : origin, time: now(), ...(userMessageId === undefined ? {} : { userMessageId }) });
+        if (notified)
+            out.push({ type: 'notice', level: 'info', text: t('claude-notification-turn') });
+    };
+    /** Settle the open attempt as one canonical assistant message. */
+    const settleAttempt = (out) => {
+        const open = context.attempt;
+        if (open === undefined)
+            return;
+        context.attempt = undefined;
+        settledAttempts.add(open.id);
+        if (settledAttempts.size > MAX_SETTLED_ATTEMPTS)
+            settledAttempts.delete(settledAttempts.values().next().value);
+        // A reply that narrated keeps the working line narrating until the turn
+        // ends (the fold's freshness window is the turn itself). A streamed
+        // response never re-delivers its blocks; the settled message carries them.
+        const complete = narrationOf(open.streamText !== '' ? open.streamText : open.text);
+        if (complete !== undefined)
+            context.narrated = complete;
+        const blocks = [];
+        if (open.reasoning !== '' || open.blocks > 0)
+            blocks.push({ type: 'reasoning', text: open.reasoning });
+        if (open.text !== '')
+            blocks.push({ type: 'text', text: open.text });
+        const usage = open.usage === undefined && open.outputTokens === undefined
+            ? undefined
+            : { ...open.usage, ...(open.outputTokens === undefined ? {} : { output: open.outputTokens }) };
+        out.push({
+            type: 'assistant.message',
+            seq: nextSeq(),
+            anchor: open.id,
+            turn: context.turn,
+            step: open.step,
+            attemptId: open.id,
+            time: now(),
+            ...(open.model === undefined ? {} : { model: open.model }),
+            blocks,
+            ...(usage === undefined ? {} : { usage }),
+            ...(open.aborted ? { interrupted: true } : {}),
+            canonical: true,
+        });
+    };
+    /** Open an attempt for `id` (a new API response), closing the previous one. */
+    const ensureAttempt = (out, id, model, usage) => {
+        if (context.attempt?.id === id)
+            return context.attempt;
+        if (settledAttempts.has(id))
+            return undefined;
+        settleAttempt(out);
+        openTurn(out, 'system');
+        closeStep(out);
+        context.step += 1;
+        context.stepOpen = true;
+        out.push({ type: 'step.start', turn: context.turn, step: context.step });
+        out.push({ type: 'assistant.attempt.start', attemptId: id, turn: context.turn, step: context.step, ...(model === undefined ? {} : { model }) });
+        // `message_start.model` is the CLI's own confirmation of the model a
+        // request ran on: an in-place switch shows up here first.
+        if (model !== undefined && model !== '' && context.currentModel !== '' && model !== context.currentModel) {
+            context.currentModel = model;
+            out.push({ type: 'model.changed', model, source: 'settings' });
+        }
+        context.attempt = { id, step: context.step, model, reasoning: '', text: '', streamText: '', blocks: 0, aborted: false, usage, outputTokens: undefined, streamTools: new Map() };
+        return context.attempt;
+    };
+    const delta = (open, value, index) => ({ type: 'assistant.delta', attemptId: open.id, index, time: now(), delta: value });
+    const translateStream = (message) => {
+        const event = rec(message.event);
+        const type = str(event?.type);
+        if (event === undefined || type === undefined)
+            return [];
+        const out = [];
+        switch (type) {
+            case 'message_start': {
+                const body = rec(event.message);
+                const id = str(body?.id);
+                if (id !== undefined)
+                    ensureAttempt(out, id, str(body?.model), usageOf(body?.usage));
+                return out;
+            }
+            case 'content_block_start': {
+                const block = rec(event.content_block);
+                const index = num(event.index) ?? 0;
+                const open = context.attempt;
+                if (open === undefined || block?.type !== 'tool_use')
+                    return out;
+                const callId = str(block.id);
+                const name = str(block.name);
+                if (callId === undefined)
+                    return out;
+                open.streamTools.set(index, callId);
+                out.push(delta(open, { kind: 'tool-args', callId, partialJson: '', ...(name === undefined ? {} : { name }) }, index));
+                return out;
+            }
+            case 'content_block_delta': {
+                const open = context.attempt;
+                const body = rec(event.delta);
+                const index = num(event.index) ?? 0;
+                if (open === undefined || body === undefined)
+                    return out;
+                switch (str(body.type)) {
+                    case 'text_delta': {
+                        const text = str(body.text) ?? '';
+                        if (text !== '') {
+                            open.streamText += text;
+                            out.push(delta(open, { kind: 'text', text }, index));
+                        }
+                        return out;
+                    }
+                    case 'thinking_delta': {
+                        const text = str(body.thinking) ?? '';
+                        if (text !== '')
+                            out.push(delta(open, { kind: 'reasoning', text }, index));
+                        const estimated = num(body.estimated_tokens);
+                        if (text === '' && estimated !== undefined)
+                            out.push(delta(open, { kind: 'reasoning-tokens', estimated }, index));
+                        return out;
+                    }
+                    case 'input_json_delta': {
+                        const callId = open.streamTools.get(index);
+                        const partialJson = str(body.partial_json) ?? '';
+                        if (callId !== undefined && partialJson !== '')
+                            out.push(delta(open, { kind: 'tool-args', callId, partialJson }, index));
+                        return out;
+                    }
+                    default:
+                        // signature_delta / citations_delta: nothing to show.
+                        return out;
+                }
+            }
+            case 'message_delta': {
+                const open = context.attempt;
+                // `message_start` 的 usage 是占位零值；本请求的真实计数（含 input
+                // 与 cache split——上下文读数与 cache N 都靠它们）只在 message_delta
+                // 与 result 上到达，这里全量覆盖。
+                const deltaUsage = usageOf(event.usage);
+                const output = num(rec(event.usage)?.output_tokens);
+                if (open !== undefined) {
+                    if (deltaUsage !== undefined)
+                        open.usage = deltaUsage;
+                    if (output !== undefined)
+                        open.outputTokens = output;
+                }
+                return out;
+            }
+            case 'message_stop':
+                settleAttempt(out);
+                return out;
+            default:
+                return out;
+        }
+    };
+    /** `result`: the authoritative turn close. */
+    const translateResult = (message) => {
+        const out = [];
+        // `result.usage` 是本轮的权威计数（assistant 消息体上的 usage 是占位
+        // 零值，真值只随流式 message_delta 与 result 到达）——settle 前并进还
+        // 开着的 attempt，无细流的 CLI 也能让 lastUsage / cache 读数落位。
+        const authoritative = usageOf(message.usage);
+        if (authoritative !== undefined && context.attempt !== undefined)
+            context.attempt.usage = authoritative;
+        settleAttempt(out);
+        closeStep(out);
+        const subtype = str(message.subtype);
+        const terminal = str(message.terminal_reason);
+        const isError = message.is_error === true;
+        // A `now`-interrupted turn is `subtype:'success'` with
+        // `terminal_reason:'aborted_*'`: the terminal reason decides first.
+        let reason;
+        if (terminal === 'aborted_streaming' || terminal === 'aborted_tools')
+            reason = { kind: 'aborted' };
+        else if (subtype === 'error_max_turns' || subtype === 'error_max_budget_usd' || subtype === 'error_max_structured_output_retries')
+            reason = { kind: 'blocked', detail: subtype };
+        else if (subtype === 'success' && !isError)
+            reason = { kind: 'completed' };
+        else {
+            const errors = arr(message.errors).filter((line) => typeof line === 'string' && !line.startsWith(EDE_DIAGNOSTIC));
+            const text = str(message.result) ?? errors.join('\n');
+            reason = { kind: 'error', message: text === '' ? (subtype ?? 'error') : text };
+        }
+        const modelUsage = rec(message.modelUsage);
+        // The largest window any model of the turn reported (the main model's;
+        // a smaller subagent model never shrinks it).
+        const windows = Object.values(modelUsage ?? {}).map(value => num(rec(value)?.contextWindow) ?? 0);
+        const contextWindow = Math.max(0, ...windows);
+        if (contextWindow > 0)
+            out.push({ type: 'context.capacity', contextWindow });
+        const cost = num(message.total_cost_usd);
+        if (context.turnOpen) {
+            context.turnOpen = false;
+            out.push({
+                type: 'turn.end',
+                turn: context.turn,
+                reason,
+                time: now(),
+                ...(cost === undefined ? {} : { cost: { currency: 'USD', amount: cost, source: 'backend' } }),
+            });
+        }
+        context.compactRequested = false;
+        return out;
+    };
+    /** Close an open turn without a `result` (idle backstop, forced settle,
+     *  process death). */
+    function forceCloseTurn(reason) {
+        const out = [];
+        settleAttempt(out);
+        closeStep(out);
+        if (context.turnOpen) {
+            context.turnOpen = false;
+            out.push({ type: 'turn.end', turn: context.turn, reason, time: now() });
+        }
+        return out;
+    }
+    return { closeStep, openTurn, settleAttempt, ensureAttempt, delta, translateStream, translateResult, forceCloseTurn };
+}

package/lib/types/backends/claude/translate/content.d.ts

@@ -0,0 +1,33 @@
+/** Decode SDK content, usage and user-text sentinels. */
+import type { UsageDelta } from '../../../agent/events.js';
+/** User texts the CLI injects that are not human bubbles. */
+export declare const INTERRUPT_ECHO = "[Request interrupted by user";
+export declare const LOCAL_COMMAND_TAG: RegExp;
+export declare const COMMAND_TAG: RegExp;
+/** Command output sent as a prompt (`!!` / the CLI's bash mode). */
+export declare const BASH_OUTPUT: RegExp;
+/** Usage of one API response, in the domain's shape. */
+export declare function usageOf(value: unknown): UsageDelta | undefined;
+/** Joined text of a tool_result `content` (string or block array). */
+export declare function toolResultText(content: unknown): string;
+/**
+ * The leading ⏵ self-narration line of a streaming reply, when there is
+ * one (the narrate contract puts exactly one at the very top; only a complete
+ * first line counts, so a narration still streaming shows nothing yet). The
+ * line is flattened and capped — it is model output destined for a status
+ * line, never for re-parsing.
+ */
+export declare function narrationOf(text: string | undefined): string | undefined;
+/** First text of a user `message.content` (string or block array). */
+export declare function userText(content: unknown): string | undefined;
+/**
+ * The result text of an answered `AskUserQuestion`, in the shape the shared
+ * projector folds into the answered-questionnaire record (the `{answers:
+ * [{selected}]}` JSON the DSH `ask_user_question` tool persists, matched to
+ * the questions by order). The answers come from the structured result
+ * (`answers: {question: text}`) or, failing that, the CLI's
+ * `"question"="answer"` sentence; anything unreadable keeps the raw text (a
+ * title-only record).
+ */
+export declare function questionRecordText(input: unknown, structured: unknown, raw: string): string;
+//# sourceMappingURL=content.d.ts.map

package/lib/types/backends/claude/translate/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/translate/content.ts"],"names":[],"mappings":"AAAA,yDAAyD;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAG1D,6DAA6D;AAC7D,eAAO,MAAM,cAAc,iCAAiC,CAAA;AAC5D,eAAO,MAAM,iBAAiB,QAA6C,CAAA;AAC3E,eAAO,MAAM,WAAW,QAAoC,CAAA;AAC5D,oEAAoE;AACpE,eAAO,MAAM,WAAW,QAAmD,CAAA;AAE3E,wDAAwD;AACxD,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAS9D;AAED,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAMvD;AAKD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAQxE;AAED,sEAAsE;AACtE,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAO7D;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAiB3F"}

package/lib/types/backends/claude/translate/content.js

@@ -0,0 +1,91 @@
+import { arr, num, rec, str } from '../narrow.js';
+/** User texts the CLI injects that are not human bubbles. */
+export const INTERRUPT_ECHO = '[Request interrupted by user';
+export const LOCAL_COMMAND_TAG = /^<local-command-(stdout|stderr|caveat)>/u;
+export const COMMAND_TAG = /^<command-(name|message|args)>/u;
+/** Command output sent as a prompt (`!!` / the CLI's bash mode). */
+export const BASH_OUTPUT = /^<bash-stdout>\n?([\s\S]*?)\n?<\/bash-stdout>/u;
+/** Usage of one API response, in the domain's shape. */
+export function usageOf(value) {
+    const usage = rec(value);
+    if (usage === undefined)
+        return undefined;
+    const input = num(usage.input_tokens);
+    const output = num(usage.output_tokens);
+    const cacheRead = num(usage.cache_read_input_tokens);
+    const cacheWrite = num(usage.cache_creation_input_tokens);
+    if (input === undefined && output === undefined && cacheRead === undefined && cacheWrite === undefined)
+        return undefined;
+    return { input, output, cacheRead, cacheWrite };
+}
+/** Joined text of a tool_result `content` (string or block array). */
+export function toolResultText(content) {
+    if (typeof content === 'string')
+        return content;
+    return arr(content).map(block => {
+        const value = rec(block);
+        return value?.type === 'text' ? str(value.text) ?? '' : '';
+    }).join('');
+}
+/** The longest working-line narration kept (the ⏵ self-narration line). */
+const NARRATION_CHARS = 120;
+/**
+ * The leading ⏵ self-narration line of a streaming reply, when there is
+ * one (the narrate contract puts exactly one at the very top; only a complete
+ * first line counts, so a narration still streaming shows nothing yet). The
+ * line is flattened and capped — it is model output destined for a status
+ * line, never for re-parsing.
+ */
+export function narrationOf(text) {
+    if (text === undefined || text === '')
+        return undefined;
+    const newline = text.indexOf('\n');
+    if (newline === -1)
+        return undefined;
+    const first = text.slice(0, newline).trimStart();
+    if (!first.startsWith('⏵'))
+        return undefined;
+    const flat = first.replace(/[\u0000-\u001f\u007f]/gu, '');
+    return flat.length <= NARRATION_CHARS ? flat : flat.slice(0, NARRATION_CHARS) + '…';
+}
+/** First text of a user `message.content` (string or block array). */
+export function userText(content) {
+    if (typeof content === 'string')
+        return content;
+    for (const block of arr(content)) {
+        const value = rec(block);
+        if (value?.type === 'text')
+            return str(value.text);
+    }
+    return undefined;
+}
+/**
+ * The result text of an answered `AskUserQuestion`, in the shape the shared
+ * projector folds into the answered-questionnaire record (the `{answers:
+ * [{selected}]}` JSON the DSH `ask_user_question` tool persists, matched to
+ * the questions by order). The answers come from the structured result
+ * (`answers: {question: text}`) or, failing that, the CLI's
+ * `"question"="answer"` sentence; anything unreadable keeps the raw text (a
+ * title-only record).
+ */
+export function questionRecordText(input, structured, raw) {
+    const questions = arr(rec(input)?.questions).map(item => str(rec(item)?.question) ?? '');
+    if (questions.length === 0)
+        return raw;
+    let answers = rec(rec(structured)?.answers);
+    if (answers === undefined) {
+        const parsed = {};
+        for (const match of raw.matchAll(/"([^"]*)"="([^"]*)"/gu))
+            parsed[match[1]] = match[2];
+        answers = parsed;
+    }
+    const found = answers;
+    if (Object.keys(found).length === 0)
+        return raw;
+    return JSON.stringify({
+        answers: questions.map(question => {
+            const value = str(found[question]);
+            return { selected: value === undefined ? [] : [value] };
+        }),
+    });
+}

package/lib/types/backends/claude/translate/core.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Claude Agent SDK → Agent Domain translator: one pure state machine per
+ * session that turns the SDK message stream (including the frames the SDK
+ * types do not declare — `command_lifecycle`, `session_state_changed`,
+ * `thinking_tokens` estimates) into `AgentEvent`s for the
+ * shared projector. No I/O: the session feeds it messages and the inputs it
+ * pushed; fixtures feed it recorded JSON.
+ *
+ * State: the open turn and its step counter, the open attempt (keyed by the
+ * API `message.id`; the CLI sends one `assistant` message per content block,
+ * all sharing that id), the open tool calls (their presenters need the
+ * input), the inputs this session pushed (their text becomes the user row
+ * when the CLI confirms them) and the last `system/init` (re-sent every turn;
+ * only changes are emitted).
+ *
+ * Every field is narrowed from `unknown`; an unknown message type or subtype
+ * is ignored (debug-logged), never fatal.
+ */
+import type { AgentEvent, ImageRef } from '../../../agent/events.js';
+import type { ClaudeActivityState, ClaudeTranslatorOptions, ClaudeUserRows, RegisteredInput } from './types.js';
+/** Create one translator; it serves exactly one session's stream. */
+export declare function createClaudeTranslator(options: ClaudeTranslatorOptions): {
+    translate: (raw: unknown) => readonly AgentEvent[];
+    forceCloseTurn: (reason: import("../../../agent/events.js").TurnEndReason) => AgentEvent[];
+    /** A pushed input: its text becomes the user row once the CLI confirms
+     *  it; a queued placement is a pending preview until then. */
+    registerInput(uuid: string, text: string, placement: RegisteredInput["placement"], images?: readonly ImageRef[]): void;
+    /** Forget an input the session failed to push. */
+    unregisterInput(uuid: string): void;
+    /** Pushed inputs the CLI has not started yet, in push order (a
+     *  reconnect re-delivers them to the new CLI). */
+    unstartedInputs(): readonly string[];
+    /** Queued-input previews the channel still shows (pending uuids, push
+     *  order): what an interrupt covered but has not confirmed deleted —
+     *  an answerless or failed interrupt reports them as still queued. */
+    pendingInputs(): readonly string[];
+    /** Give up on inputs that can no longer be delivered: their previews
+     *  are retired as discarded. */
+    dropInputs(uuids: readonly string[]): AgentEvent[];
+    /** Switch the user-row source once the CLI's capabilities are known. */
+    setUserRows(mode: ClaudeUserRows): void;
+    clearInterruptedCalls(): void;
+    /** The model as last confirmed ('' before the first init). */
+    readonly model: string;
+    /** The permission mode as last confirmed. */
+    readonly mode: string | undefined;
+    /** A model the session switched to by control request: tracked, and
+     *  reported once (a later identical init/message_start stays quiet). */
+    noteModel(model: string): AgentEvent[];
+    /** A permission mode the session set by control request (or started in). */
+    noteMode(mode: string): AgentEvent[];
+    readonly turnOpen: boolean;
+    /** The task id a subagent / job id names: a task id itself, or the
+     *  delegating call of a subagent `task_started` already named. */
+    taskIdOf(id: string): string | undefined;
+    /** The output file the CLI reported for a task. */
+    outputFileOf(taskId: string): string | undefined;
+    /** The working-activity fold's inputs (see ClaudeActivityState): the
+     *  translator's own view of the stream, nothing re-parsed. */
+    activityState(): ClaudeActivityState;
+    /** The last turn number used (a resumed session continues after it). */
+    readonly turnNumber: number;
+    /** The last event sequence number used. */
+    readonly seqNumber: number;
+    /** The tracked tasks as serializable resume seeds (replay.ts hands these
+     *  to the live translator of the resumed session). */
+    taskSeeds: () => readonly import("./types.js").ClaudeTaskSeed[];
+    /**
+     * Open the CLI's own turn that follows a task notification (replay: the
+     * transcript records it as a `task-notification` prompt; live, the
+     * `task_notification` frame arms the same turn). Closes nothing.
+     */
+    openNotificationTurn(): AgentEvent[];
+};
+export type ClaudeTranslator = ReturnType<typeof createClaudeTranslator>;
+//# sourceMappingURL=core.d.ts.map

package/lib/types/backends/claude/translate/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/translate/core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAgB,QAAQ,EAAe,MAAM,0BAA0B,CAAA;AAS/F,OAAO,KAAK,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,cAAc,EAAe,eAAe,EAAe,MAAM,YAAY,CAAA;AAEzI,qEAAqE;AACrE,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,uBAAuB;qBAgQ7C,OAAO,KAAG,SAAS,UAAU,EAAE;;IAyDrD;kEAC8D;wBAC1C,MAAM,QAAQ,MAAM,aAAa,eAAe,CAAC,WAAW,CAAC,WAAW,SAAS,QAAQ,EAAE,GAAG,IAAI;IAKtH,kDAAkD;0BAC5B,MAAM,GAAG,IAAI;IAKnC;sDACkD;uBAC/B,SAAS,MAAM,EAAE;IAGpC;;0EAEsE;qBACrD,SAAS,MAAM,EAAE;IAGlC;oCACgC;sBACd,SAAS,MAAM,EAAE,GAAG,UAAU,EAAE;IASlD,wEAAwE;sBACtD,cAAc,GAAG,IAAI;6BAGd,IAAI;IAC7B,8DAA8D;oBACjD,MAAM;IACnB,6CAA6C;mBACjC,MAAM,GAAG,SAAS;IAC9B;4EACwE;qBACvD,MAAM,GAAG,UAAU,EAAE;IAKtC,4EAA4E;mBAC7D,MAAM,GAAG,UAAU,EAAE;uBAKpB,OAAO;IACvB;sEACkE;iBACrD,MAAM,GAAG,MAAM,GAAG,SAAS;IAIxC,mDAAmD;yBAC9B,MAAM,GAAG,MAAM,GAAG,SAAS;IAGhD;kEAC8D;qBAC7C,mBAAmB;IAqBpC,wEAAwE;yBACtD,MAAM;IACxB,2CAA2C;wBAC1B,MAAM;IACvB;0DACsD;;IAEtD;;;;OAIG;4BACqB,UAAU,EAAE;EAOvC;AAED,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAA"}