@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/agent/providers/claude/transport/pty.js

@@ -0,0 +1,211 @@
+import { unlink } from "node:fs";
+import { createRequire } from "node:module";
+import { setTimeout as delay } from "node:timers/promises";
+import { redactChunk } from "./redact.js";
+const DEFAULT_COLS = 200;
+const DEFAULT_ROWS = 50;
+const DEFAULT_KILL_TIMEOUT_MS = 5000;
+const ECHO_WAIT_MS = 50;
+const BRACKETED_PASTE_START = "\x1b[200~";
+const BRACKETED_PASTE_END = "\x1b[201~";
+let nodePty = null;
+function getNodePty() {
+    if (nodePty)
+        return nodePty;
+    try {
+        const req = createRequire(import.meta.url);
+        nodePty = req("node-pty");
+    }
+    catch {
+        throw new Error("claude PTY transport unavailable: node-pty failed to load");
+    }
+    return nodePty;
+}
+// Test-only injection point. The lazy `require` above bypasses ESM module
+// mocks (e.g. vitest's `vi.mock`), so tests inject a stub here instead.
+export function __setNodePtyForTesting(stub) {
+    nodePty = stub;
+}
+export class PtyTransport {
+    constructor() {
+        this._pty = null;
+        this._cwd = "";
+        this._cols = DEFAULT_COLS;
+        this._rows = DEFAULT_ROWS;
+        this._killed = false;
+        this._exited = false;
+        this.injectChain = Promise.resolve();
+        this.hookHandlers = [];
+        this.hookBuffer = [];
+        this.bridgeClose = null;
+        this.systemPromptFilePath = null;
+    }
+    /**
+     * Bridge-side / test entry point — push a hook event into this transport's
+     * stream. If no `onHookEvent` handler is registered yet, the event is
+     * buffered and flushed on the first registration (or on `kill()`).
+     */
+    pushHookEvent(event) {
+        if (this.hookHandlers.length === 0) {
+            this.hookBuffer.push(event);
+            return;
+        }
+        this.deliverEvent(event);
+    }
+    /**
+     * Hook bridge cleanup. The daemon-side hook bridge calls this so PtyTransport
+     * can release the per-agent Unix socket handler during kill(). Idempotent.
+     */
+    setBridgeCloseHook(close) {
+        this.bridgeClose = close;
+    }
+    deliverEvent(event) {
+        for (const h of this.hookHandlers) {
+            try {
+                h(event);
+            }
+            catch {
+                // handler errors must not break siblings
+            }
+        }
+    }
+    drainBuffer() {
+        if (this.hookBuffer.length === 0)
+            return;
+        const events = this.hookBuffer.splice(0, this.hookBuffer.length);
+        for (const event of events)
+            this.deliverEvent(event);
+    }
+    async spawn(opts) {
+        const pty = getNodePty();
+        const cols = opts.dims?.cols ?? DEFAULT_COLS;
+        const rows = opts.dims?.rows ?? DEFAULT_ROWS;
+        this._cwd = opts.cwd;
+        this._cols = cols;
+        this._rows = rows;
+        this.systemPromptFilePath = opts.systemPromptFilePath ?? null;
+        this._pty = pty.spawn(opts.binary, opts.args, {
+            name: "xterm-256color",
+            cols,
+            rows,
+            cwd: opts.cwd,
+            env: opts.env,
+        });
+        this._pty.onExit(() => {
+            this._exited = true;
+        });
+    }
+    write(text) {
+        this.injectChain = this.injectChain.then(() => this.doWrite(text));
+        return this.injectChain;
+    }
+    /**
+     * Write raw bytes (no bracketed-paste framing) — for real keypresses like
+     * control chords (e.g. Claude Code's `ctrl+x ctrl+k` kill chord) that must
+     * reach the TUI as keystrokes, not pasted text. Serialized through the same
+     * inject chain as write() so it can't interleave mid-paste.
+     */
+    writeRaw(data) {
+        this.injectChain = this.injectChain.then(() => this.doWriteRaw(data));
+        return this.injectChain;
+    }
+    async doWriteRaw(data) {
+        if (!this._pty) {
+            throw new Error("PtyTransport.writeRaw called before spawn()");
+        }
+        this._pty.write(data);
+        await this.waitForEcho();
+    }
+    bracketedPaste(text) {
+        return `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`;
+    }
+    async doWrite(text) {
+        if (!this._pty) {
+            throw new Error("PtyTransport.write called before spawn()");
+        }
+        this._pty.write(this.bracketedPaste(text));
+        await this.waitForEcho();
+    }
+    // Timing-based echo wait. May be replaced with a marker-based approach in Phase 5 hardening.
+    async waitForEcho() {
+        await delay(ECHO_WAIT_MS);
+    }
+    async kill(timeoutMs = DEFAULT_KILL_TIMEOUT_MS) {
+        if (this._killed)
+            return;
+        this._killed = true;
+        // Flush any buffered hook events to registered handlers before teardown so
+        // late-arriving observations aren't dropped on swap/close.
+        this.drainBuffer();
+        // Drop the injectChain reference so any pending writes don't extend the
+        // chain past kill(). The current chain promise still settles on its own.
+        this.injectChain = Promise.resolve();
+        if (this.bridgeClose) {
+            try {
+                await this.bridgeClose();
+            }
+            catch {
+                // bridge close errors must not block teardown
+            }
+            this.bridgeClose = null;
+        }
+        if (!this._pty)
+            return;
+        try {
+            this._pty.kill("SIGTERM");
+        }
+        catch {
+            // already dead
+        }
+        await delay(timeoutMs);
+        if (!this._exited) {
+            try {
+                this._pty.kill("SIGKILL");
+            }
+            catch {
+                // already dead
+            }
+        }
+        if (this.systemPromptFilePath) {
+            const p = this.systemPromptFilePath;
+            this.systemPromptFilePath = null;
+            // Best-effort cleanup — never fail kill() if the file is already gone.
+            unlink(p, () => { });
+        }
+    }
+    onHookEvent(handler) {
+        this.hookHandlers.push(handler);
+        this.drainBuffer();
+        return () => {
+            this.hookHandlers = this.hookHandlers.filter((h) => h !== handler);
+        };
+    }
+    onData(handler) {
+        if (!this._pty) {
+            throw new Error("PtyTransport.onData called before spawn()");
+        }
+        const disposable = this._pty.onData((raw) => handler(redactChunk(raw)));
+        return () => disposable.dispose();
+    }
+    onExit(handler) {
+        if (!this._pty) {
+            throw new Error("PtyTransport.onExit called before spawn()");
+        }
+        const disposable = this._pty.onExit(({ exitCode, signal }) => {
+            handler(typeof exitCode === "number" ? exitCode : null, signal ?? null);
+        });
+        return () => disposable.dispose();
+    }
+    context() {
+        if (!this._pty) {
+            throw new Error("PtyTransport.context called before spawn()");
+        }
+        return {
+            transport: "pty",
+            pid: this._pty.pid,
+            cwd: this._cwd,
+            dims: { cols: this._cols, rows: this._rows },
+        };
+    }
+}
+//# sourceMappingURL=pty.js.map

package/dist/server/server/agent/providers/claude/transport/redact.d.ts

@@ -0,0 +1,2 @@
+export declare function redactChunk(chunk: string): string;
+//# sourceMappingURL=redact.d.ts.map

package/dist/server/server/agent/providers/claude/transport/redact.js

@@ -0,0 +1,5 @@
+const JWT_PATTERN = /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g;
+export function redactChunk(chunk) {
+    return chunk.replace(JWT_PATTERN, "[REDACTED-JWT]");
+}
+//# sourceMappingURL=redact.js.map

package/dist/server/server/agent/providers/claude/transport/sdk.d.ts

@@ -0,0 +1,63 @@
+import { query, type Options, type Query } from "@anthropic-ai/claude-agent-sdk";
+import type { Logger } from "pino";
+import type { HookEvent } from "@hyperdrive.bot/paseo-protocol/messages";
+import { type ProviderRuntimeSettings } from "../../../provider-launch-config.js";
+import type { AgentTransport, AgentTransportContext, AgentTransportSpawnOptions } from "./types.js";
+export type ClaudeOptions = Options;
+export type ClaudeQueryInput = Parameters<typeof query>[0] & {
+    options: ClaudeOptions;
+};
+export type ClaudeQueryFactory = (input: ClaudeQueryInput) => Query;
+export interface ClaudeQueryContext {
+    runtimeSettings?: ProviderRuntimeSettings;
+    launchEnv?: Record<string, string>;
+    queryFactory?: ClaudeQueryFactory;
+}
+/**
+ * Construct a raw SDK Query with the project-standard runtime-settings/env handling
+ * applied. Kept as a free function for tests that exercise the SDK call directly
+ * (see `sdk-behavior.test.ts`, `agent.integration.test.ts`).
+ */
+export declare function claudeQuery(input: ClaudeQueryInput, context?: ClaudeQueryContext): Query;
+export interface SdkTransportOptions {
+    runtimeSettings?: ProviderRuntimeSettings;
+    launchEnv?: Record<string, string>;
+    queryFactory?: ClaudeQueryFactory;
+    logger?: Logger;
+}
+/**
+ * SDK transport — wraps the @anthropic-ai/claude-agent-sdk `query()` call behind
+ * the shared `AgentTransport` interface so `ClaudeAgentSession` can dispatch
+ * between SDK and PTY transports uniformly in Story 3.2+.
+ *
+ * In Story 3.1 the pump still consumes the raw `Query` object directly; this
+ * class exists primarily for type-compatibility and to centralize SDK spawn
+ * configuration. `createQuery()` is the transitional helper agent.ts uses to
+ * fetch the underlying `Query` while preserving today's behavior.
+ */
+export declare class SdkTransport implements AgentTransport {
+    private readonly runtimeSettings?;
+    private readonly launchEnv?;
+    private readonly queryFactory?;
+    private _cwd;
+    private _query;
+    private _killed;
+    private _exited;
+    private exitHandlers;
+    constructor(opts?: SdkTransportOptions);
+    /**
+     * Transitional helper for Story 3.1 — agent.ts uses this in `ensureQuery()` to
+     * obtain the underlying `Query` while the pump continues to consume it
+     * directly. Story 3.2 will pivot the pump onto `onHookEvent` and remove this.
+     */
+    createQuery(input: ClaudeQueryInput): Query;
+    spawn(opts: AgentTransportSpawnOptions): Promise<void>;
+    write(text: string): Promise<void>;
+    kill(timeoutMs?: number): Promise<void>;
+    onHookEvent(_handler: (event: HookEvent) => void): () => void;
+    onData(_handler: (chunk: string) => void): () => void;
+    onExit(handler: (code: number | null, signal: NodeJS.Signals | null) => void): () => void;
+    private fireExit;
+    context(): AgentTransportContext;
+}
+//# sourceMappingURL=sdk.d.ts.map

package/dist/server/server/agent/providers/claude/transport/sdk.js

@@ -0,0 +1,207 @@
+import { query, } from "@anthropic-ai/claude-agent-sdk";
+import { createProviderEnv, createProviderEnvSpec, } from "../../../provider-launch-config.js";
+import { buildSelfNodeCommand } from "../../../../paseo-env.js";
+import { spawnProcess } from "../../../../../utils/spawn.js";
+function isChildProcessWithStreams(child) {
+    return child.stdin !== null && child.stdout !== null && child.stderr !== null;
+}
+function resolveClaudeSpawnCommand(spawnOptions, runtimeSettings) {
+    const commandConfig = runtimeSettings?.command;
+    if (!commandConfig || commandConfig.mode === "default") {
+        return {
+            command: spawnOptions.command,
+            args: [...spawnOptions.args],
+        };
+    }
+    if (commandConfig.mode === "append") {
+        return {
+            command: spawnOptions.command,
+            args: [...spawnOptions.args, ...(commandConfig.args ?? [])],
+        };
+    }
+    return {
+        command: commandConfig.argv[0],
+        args: [...commandConfig.argv.slice(1), ...spawnOptions.args],
+    };
+}
+function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv) {
+    return {
+        ...options,
+        spawnClaudeCodeProcess: (spawnOptions) => {
+            const resolved = resolveClaudeSpawnCommand(spawnOptions, runtimeSettings);
+            const isDefaultRuntime = resolved.command === "node" || resolved.command === "bun";
+            const providerEnvSpec = createProviderEnvSpec({
+                baseEnv: spawnOptions.env,
+                runtimeSettings,
+                overlays: [launchEnv],
+            });
+            const providerEnv = createProviderEnv({
+                baseEnv: spawnOptions.env,
+                runtimeSettings,
+                overlays: [launchEnv],
+            });
+            const selfNodeCommand = isDefaultRuntime
+                ? buildSelfNodeCommand(resolved.args, providerEnv)
+                : null;
+            const command = selfNodeCommand?.command ?? resolved.command;
+            const args = selfNodeCommand?.args ?? resolved.args;
+            const child = spawnProcess(command, args, {
+                cwd: spawnOptions.cwd,
+                ...(selfNodeCommand
+                    ? { env: selfNodeCommand.env, envMode: "internal" }
+                    : providerEnvSpec),
+                signal: spawnOptions.signal,
+                stdio: ["pipe", "pipe", "pipe"],
+                shell: false,
+            });
+            if (typeof options.stderr === "function") {
+                child.stderr?.on("data", (chunk) => {
+                    options.stderr?.(chunk.toString());
+                });
+            }
+            if (!isChildProcessWithStreams(child)) {
+                throw new Error("Claude process was spawned without stdio streams");
+            }
+            return child;
+        },
+    };
+}
+/**
+ * Construct a raw SDK Query with the project-standard runtime-settings/env handling
+ * applied. Kept as a free function for tests that exercise the SDK call directly
+ * (see `sdk-behavior.test.ts`, `agent.integration.test.ts`).
+ */
+export function claudeQuery(input, context = {}) {
+    const launchQuery = context.queryFactory ?? query;
+    return launchQuery({
+        ...input,
+        options: applyRuntimeSettingsToClaudeOptions(input.options, context.runtimeSettings, context.launchEnv),
+    });
+}
+/**
+ * SDK transport — wraps the @anthropic-ai/claude-agent-sdk `query()` call behind
+ * the shared `AgentTransport` interface so `ClaudeAgentSession` can dispatch
+ * between SDK and PTY transports uniformly in Story 3.2+.
+ *
+ * In Story 3.1 the pump still consumes the raw `Query` object directly; this
+ * class exists primarily for type-compatibility and to centralize SDK spawn
+ * configuration. `createQuery()` is the transitional helper agent.ts uses to
+ * fetch the underlying `Query` while preserving today's behavior.
+ */
+export class SdkTransport {
+    constructor(opts = {}) {
+        this._cwd = "";
+        this._query = null;
+        this._killed = false;
+        this._exited = false;
+        this.exitHandlers = [];
+        this.runtimeSettings = opts.runtimeSettings;
+        this.launchEnv = opts.launchEnv;
+        this.queryFactory = opts.queryFactory;
+    }
+    /**
+     * Transitional helper for Story 3.1 — agent.ts uses this in `ensureQuery()` to
+     * obtain the underlying `Query` while the pump continues to consume it
+     * directly. Story 3.2 will pivot the pump onto `onHookEvent` and remove this.
+     */
+    createQuery(input) {
+        const q = claudeQuery(input, {
+            runtimeSettings: this.runtimeSettings,
+            launchEnv: this.launchEnv,
+            queryFactory: this.queryFactory,
+        });
+        this._query = q;
+        return q;
+    }
+    async spawn(opts) {
+        // The SDK path is not driven by binary/args/dims like the PTY path is. The
+        // caller is expected to use `createQuery(input)` with a fully-assembled
+        // ClaudeQueryInput. We only record the cwd for context() reporting.
+        this._cwd = opts.cwd;
+    }
+    async write(text) {
+        if (!this._query) {
+            throw new Error("SdkTransport.write called before createQuery()/spawn()");
+        }
+        const message = {
+            type: "user",
+            message: { role: "user", content: text },
+            parent_tool_use_id: null,
+            session_id: "",
+        };
+        // The SDK Query exposes `input.send` via the input channel set up by the
+        // caller's `createAsyncMessageInput`. In Story 3.1 this method is dormant
+        // (the pump still uses the original input directly); Story 3.2 wires it up.
+        const queryWithInput = this._query;
+        await queryWithInput.input?.send(message);
+    }
+    async kill(timeoutMs = 5000) {
+        if (this._killed)
+            return;
+        this._killed = true;
+        if (!this._query)
+            return;
+        const q = this._query;
+        try {
+            q.close?.();
+        }
+        catch {
+            // already closed
+        }
+        const returnPromise = (async () => {
+            try {
+                await q.return?.();
+            }
+            catch {
+                // already returned
+            }
+        })();
+        let timer = null;
+        const timeoutPromise = new Promise((resolve) => {
+            timer = setTimeout(resolve, timeoutMs);
+        });
+        await Promise.race([returnPromise, timeoutPromise]);
+        if (timer)
+            clearTimeout(timer);
+        this._exited = true;
+        this.fireExit(0, null);
+    }
+    onHookEvent(_handler) {
+        // In Story 3.1 the SDK pump in agent.ts consumes the raw Query iterator
+        // directly. Hook-event translation lives in agent.ts:2593-2820. This
+        // method exists for AgentTransport interface compatibility and will be
+        // populated with the SDK-message → HookEvent mapper in Story 3.2.
+        return () => { };
+    }
+    onData(_handler) {
+        // SDK transport has no raw PTY data stream.
+        return () => { };
+    }
+    onExit(handler) {
+        this.exitHandlers.push(handler);
+        if (this._exited) {
+            handler(0, null);
+        }
+        return () => {
+            this.exitHandlers = this.exitHandlers.filter((h) => h !== handler);
+        };
+    }
+    fireExit(code, signal) {
+        for (const h of this.exitHandlers) {
+            try {
+                h(code, signal);
+            }
+            catch {
+                // handler errors must not break siblings
+            }
+        }
+    }
+    context() {
+        return {
+            transport: "sdk",
+            pid: null,
+            cwd: this._cwd,
+        };
+    }
+}
+//# sourceMappingURL=sdk.js.map

package/dist/server/server/agent/providers/claude/transport/transcript-sdk-reader.d.ts

@@ -0,0 +1,27 @@
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+export interface TranscriptSdkReaderOptions {
+    transcriptPath: string;
+    onMessage: (message: SDKMessage) => void;
+}
+export declare class TranscriptSdkReader {
+    private readonly transcriptPath;
+    private readonly onMessage;
+    private timer;
+    private readOffset;
+    private buffer;
+    constructor(opts: TranscriptSdkReaderOptions);
+    /**
+     * Begin streaming NEW appends. Starts at the current EOF so a `--resume`'d session
+     * (whose transcript already holds the prior conversation) only surfaces new turns.
+     * Poll-based (not fs.watch) so a not-yet-created transcript is handled cleanly — the
+     * file is created by claude only once the first turn begins.
+     */
+    start(): void;
+    stop(): void;
+    /** Drain immediately (used by tests and on final teardown to flush trailing lines). */
+    drainNow(): void;
+    private drain;
+    private handleLine;
+    private toSdkMessage;
+}
+//# sourceMappingURL=transcript-sdk-reader.d.ts.map

package/dist/server/server/agent/providers/claude/transport/transcript-sdk-reader.js

@@ -0,0 +1,162 @@
+import * as fs from "node:fs";
+/**
+ * Tails a Claude Code session-transcript JSONL (`~/.claude/projects/<slug>/<sid>.jsonl`)
+ * and reconstructs the `SDKMessage` stream the query pump consumes — so the PTY transport
+ * gets the same structured output the SDK transport yields, without the SDK.
+ *
+ * Emits only what the pump renders (see agent.ts `translateMessageToEvents`):
+ *   - `assistant` lines  → SDKAssistantMessage (text / thinking / tool_use blocks)
+ *   - `user` lines that carry a tool_result → SDKUserMessage (so tool results render)
+ * Everything else is skipped:
+ *   - plain user-prompt echoes (paseo emits the submitted user message itself via
+ *     emitSubmittedUserMessage, so re-yielding would double-render)
+ *   - `isSidechain` lines (subagent messages live in `<sid>/subagents/*.jsonl`, tracked
+ *     separately by ClaudeSidechainTracker)
+ *   - `system` lines (PtyQuery synthesizes the init message from buildOptions instead)
+ *   - `result` (transcript has none — PtyQuery synthesizes it on the Stop hook)
+ *   - bookkeeping: attachment / queue-operation / last-prompt / file-history-snapshot
+ *
+ * Field convention bridge: the transcript uses camelCase (`sessionId`, `parentUuid`);
+ * SDK messages use snake_case (`session_id`, `parent_tool_use_id`). The nested `message`
+ * object is already the exact BetaMessage/MessageParam the SDK produced — passed through.
+ */
+const POLL_INTERVAL_MS = 200;
+export class TranscriptSdkReader {
+    constructor(opts) {
+        this.timer = null;
+        this.readOffset = 0;
+        this.buffer = "";
+        this.transcriptPath = opts.transcriptPath;
+        this.onMessage = opts.onMessage;
+    }
+    /**
+     * Begin streaming NEW appends. Starts at the current EOF so a `--resume`'d session
+     * (whose transcript already holds the prior conversation) only surfaces new turns.
+     * Poll-based (not fs.watch) so a not-yet-created transcript is handled cleanly — the
+     * file is created by claude only once the first turn begins.
+     */
+    start() {
+        if (this.timer)
+            return;
+        try {
+            this.readOffset = fs.existsSync(this.transcriptPath)
+                ? fs.statSync(this.transcriptPath).size
+                : 0;
+        }
+        catch {
+            this.readOffset = 0;
+        }
+        this.timer = setInterval(() => this.drain(), POLL_INTERVAL_MS);
+        if (typeof this.timer.unref === "function")
+            this.timer.unref();
+    }
+    stop() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = null;
+    }
+    /** Drain immediately (used by tests and on final teardown to flush trailing lines). */
+    drainNow() {
+        this.drain();
+    }
+    drain() {
+        let fd = null;
+        try {
+            if (!fs.existsSync(this.transcriptPath))
+                return;
+            fd = fs.openSync(this.transcriptPath, "r");
+            const { size } = fs.fstatSync(fd);
+            if (size <= this.readOffset)
+                return;
+            const length = size - this.readOffset;
+            const buf = Buffer.alloc(length);
+            fs.readSync(fd, buf, 0, length, this.readOffset);
+            this.readOffset = size;
+            this.buffer += buf.toString("utf8");
+            const lines = this.buffer.split("\n");
+            this.buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed)
+                    this.handleLine(trimmed);
+            }
+        }
+        catch {
+            // file rotated / removed between exists-check and read; ignore
+        }
+        finally {
+            if (fd !== null) {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    handleLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!parsed || typeof parsed !== "object")
+            return;
+        if (parsed.isSidechain)
+            return;
+        const message = this.toSdkMessage(parsed);
+        if (message)
+            this.onMessage(message);
+    }
+    toSdkMessage(line) {
+        const session_id = line.sessionId ?? "";
+        const uuid = line.uuid ?? "";
+        switch (line.type) {
+            case "assistant": {
+                if (!line.message)
+                    return null;
+                const message = {
+                    type: "assistant",
+                    message: line.message,
+                    parent_tool_use_id: null,
+                    uuid: uuid,
+                    session_id,
+                };
+                return message;
+            }
+            case "user": {
+                if (line.isMeta)
+                    return null;
+                if (!userLineHasToolResult(line))
+                    return null;
+                const message = {
+                    type: "user",
+                    message: line.message,
+                    parent_tool_use_id: null,
+                    uuid: uuid,
+                    session_id,
+                };
+                return message;
+            }
+            default:
+                // system → PtyQuery synthesizes init; result → synthesized on Stop; the rest is
+                // paseo/CC bookkeeping the pump never reads.
+                return null;
+        }
+    }
+}
+/** A user transcript line carries a tool_result either at top level or in message.content. */
+function userLineHasToolResult(line) {
+    if (line.toolUseResult !== undefined)
+        return true;
+    const content = line.message?.content;
+    if (Array.isArray(content)) {
+        return content.some((block) => block && typeof block === "object" && block.type === "tool_result");
+    }
+    return false;
+}
+//# sourceMappingURL=transcript-sdk-reader.js.map