@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/providers/claude/task-state.js

@@ -0,0 +1,185 @@
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function string(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function taskStatus(value) {
+    if (value === "completed" || value === "deleted" || value === "in_progress")
+        return value;
+    return "pending";
+}
+function retainedTaskStatus(task) {
+    if (task.status)
+        return task.status;
+    return task.completed ? "completed" : "pending";
+}
+function toTaskItem(value) {
+    const task = record(value);
+    if (!task)
+        return null;
+    const text = string(task.subject) ?? string(task.content) ?? string(task.text);
+    if (!text)
+        return null;
+    const status = taskStatus(task.status);
+    if (status === "deleted")
+        return null;
+    const id = string(task.id) ?? string(task.taskId);
+    const activeForm = string(task.activeForm) ?? string(task.active_form);
+    return {
+        ...(id ? { id } : {}),
+        text,
+        status,
+        completed: status === "completed",
+        ...(activeForm ? { activeForm } : {}),
+    };
+}
+function toolUses(message) {
+    const content = record(message.message)?.content;
+    return Array.isArray(content)
+        ? content.flatMap((block) => {
+            const candidate = record(block);
+            return candidate?.type === "tool_use" ? [candidate] : [];
+        })
+        : [];
+}
+function toolResultId(message) {
+    const content = record(message.message)?.content;
+    if (!Array.isArray(content))
+        return undefined;
+    for (const block of content) {
+        const candidate = record(block);
+        if (candidate?.type === "tool_result")
+            return string(candidate.tool_use_id);
+    }
+    return undefined;
+}
+function structuredResult(message) {
+    return record(message.toolUseResult) ?? record(message.tool_use_result);
+}
+/** Accumulates Claude's snapshot and ID-based task tools into canonical todo snapshots. */
+export class ClaudeTaskState {
+    constructor() {
+        this.tasks = new Map();
+        this.calls = new Map();
+        this.appliedResults = new Set();
+    }
+    observe(value) {
+        const message = record(value);
+        if (!message)
+            return null;
+        let snapshot = null;
+        for (const block of toolUses(message)) {
+            const id = string(block.id);
+            const name = string(block.name);
+            if (!id || !isTaskToolName(name))
+                continue;
+            const input = record(block.input) ?? {};
+            this.calls.set(id, { name, input });
+            if (name === "TodoWrite")
+                snapshot = this.replaceLegacyTodos(input.todos);
+        }
+        const resultId = toolResultId(message);
+        if (!resultId || this.appliedResults.has(resultId))
+            return snapshot;
+        const call = this.calls.get(resultId);
+        if (!call)
+            return snapshot;
+        this.appliedResults.add(resultId);
+        this.calls.delete(resultId);
+        return this.applyResult(call, structuredResult(message)) ?? snapshot;
+    }
+    reset() {
+        this.tasks.clear();
+        this.calls.clear();
+        this.appliedResults.clear();
+    }
+    replaceLegacyTodos(value) {
+        this.tasks.clear();
+        if (Array.isArray(value)) {
+            for (const [index, taskValue] of value.entries()) {
+                const item = toTaskItem(taskValue);
+                if (!item)
+                    continue;
+                const id = item.id ?? `legacy:${index}`;
+                this.tasks.set(id, { ...item, id });
+            }
+        }
+        return this.snapshot();
+    }
+    applyResult(call, result) {
+        if (result?.success === false)
+            return null;
+        if (call.name === "TaskCreate")
+            return this.applyCreate(call.input, result);
+        if (call.name === "TaskUpdate")
+            return this.applyUpdate(call.input, result);
+        if (call.name === "TaskList")
+            return this.applyList(result);
+        return null;
+    }
+    applyCreate(input, result) {
+        const resultTask = record(result?.task);
+        const id = string(resultTask?.id) ?? string(result?.taskId);
+        const text = string(resultTask?.subject) ?? string(input.subject);
+        if (!id || !text)
+            return null;
+        const activeForm = string(input.activeForm);
+        this.tasks.set(id, {
+            id,
+            text,
+            status: "pending",
+            completed: false,
+            ...(activeForm ? { activeForm } : {}),
+        });
+        return this.snapshot();
+    }
+    applyUpdate(input, result) {
+        const id = string(input.taskId) ?? string(result?.taskId);
+        if (!id)
+            return null;
+        const current = this.tasks.get(id);
+        if (!current)
+            return null;
+        const statusValue = input.status ?? record(result?.statusChange)?.to;
+        const status = statusValue === undefined ? retainedTaskStatus(current) : taskStatus(statusValue);
+        if (status === "deleted") {
+            this.tasks.delete(id);
+            return this.snapshot();
+        }
+        const text = string(input.subject);
+        const activeForm = string(input.activeForm);
+        this.tasks.set(id, {
+            ...current,
+            ...(text ? { text } : {}),
+            ...(activeForm ? { activeForm } : {}),
+            status,
+            completed: status === "completed",
+        });
+        return this.snapshot();
+    }
+    applyList(result) {
+        const tasks = result?.tasks;
+        if (!Array.isArray(tasks))
+            return null;
+        this.tasks.clear();
+        for (const taskValue of tasks) {
+            const item = toTaskItem(taskValue);
+            if (item?.id)
+                this.tasks.set(item.id, item);
+        }
+        return this.snapshot();
+    }
+    snapshot() {
+        return { type: "todo", items: [...this.tasks.values()] };
+    }
+}
+function isTaskToolName(value) {
+    return (value === "TodoWrite" ||
+        value === "TaskCreate" ||
+        value === "TaskUpdate" ||
+        value === "TaskList");
+}
+//# sourceMappingURL=task-state.js.map

package/dist/server/server/agent/providers/claude/test-rewind-claude-sdk.d.ts

@@ -0,0 +1,24 @@
+import type { ClaudeRewindSdk } from "./rewind.js";
+export declare class FakeClaudeSdk implements ClaudeRewindSdk {
+    readonly recordedForks: Array<{
+        upToMessageId: string;
+    }>;
+    readonly recordedFileRewinds: Array<{
+        userMessageId: string;
+    }>;
+    private nextSessionId;
+    setNextSessionId(sessionId: string): void;
+    forkSession(_sessionId: string, options: {
+        upToMessageId: string;
+    }): Promise<{
+        sessionId: string;
+    }>;
+    createQuery(): {
+        rewindFiles: (userMessageId: string, options?: {
+            dryRun?: boolean;
+        }) => Promise<{
+            canRewind: boolean;
+        }>;
+    };
+}
+//# sourceMappingURL=test-rewind-claude-sdk.d.ts.map

package/dist/server/server/agent/providers/claude/test-rewind-claude-sdk.js

@@ -0,0 +1,23 @@
+export class FakeClaudeSdk {
+    constructor() {
+        this.recordedForks = [];
+        this.recordedFileRewinds = [];
+        this.nextSessionId = "forked-session-1";
+    }
+    setNextSessionId(sessionId) {
+        this.nextSessionId = sessionId;
+    }
+    async forkSession(_sessionId, options) {
+        this.recordedForks.push({ upToMessageId: options.upToMessageId });
+        return { sessionId: this.nextSessionId };
+    }
+    createQuery() {
+        return {
+            rewindFiles: async (userMessageId) => {
+                this.recordedFileRewinds.push({ userMessageId });
+                return { canRewind: true };
+            },
+        };
+    }
+}
+//# sourceMappingURL=test-rewind-claude-sdk.js.map

package/dist/server/server/agent/providers/claude/tool-call-detail-parser.d.ts

@@ -0,0 +1,3 @@
+import type { ToolCallDetail } from "../../agent-sdk-types.js";
+export declare function deriveClaudeToolDetail(name: string, input: unknown, output: unknown): ToolCallDetail;
+//# sourceMappingURL=tool-call-detail-parser.d.ts.map

package/dist/server/server/agent/providers/claude/tool-call-detail-parser.js

@@ -0,0 +1,130 @@
+import { z } from "zod";
+import { ToolEditInputSchema, ToolEditOutputSchema, ToolReadInputSchema, ToolReadOutputSchema, ToolSearchInputSchema, ToolGrepOutputSchema, ToolGlobOutputSchema, ToolShellInputSchema, ToolShellOutputSchema, ToolWebFetchInputSchema, ToolWebFetchOutputSchema, ToolWebSearchOutputSchema, ToolWriteInputSchema, ToolWriteOutputSchema, toEditToolDetail, toFetchToolDetail, toReadToolDetail, toSearchToolDetail, toShellToolDetail, toWriteToolDetail, toolDetailBranchByName, } from "../tool-call-detail-primitives.js";
+const ClaudeGrepOutputSchema = z
+    .union([
+    ToolGrepOutputSchema,
+    z
+        .object({ output: z.string() })
+        .passthrough()
+        .transform(({ output }) => ({ numFiles: 0, filenames: [], content: output })),
+])
+    .nullable();
+const ClaudeToolEnvelopeSchema = z
+    .object({
+    name: z.string().min(1),
+    input: z.unknown().nullable(),
+    output: z.unknown().nullable(),
+})
+    .passthrough();
+const ClaudeSpeakToolDetailSchema = z
+    .object({
+    name: z.literal("speak"),
+    input: z
+        .union([
+        z.string().transform((text) => ({ text })),
+        z.object({ text: z.string() }).passthrough(),
+    ])
+        .nullable(),
+    output: z.unknown().nullable(),
+})
+    .transform(({ input }) => {
+    const text = input?.text?.trim() ?? "";
+    if (!text) {
+        return undefined;
+    }
+    return {
+        type: "unknown",
+        input: text,
+        output: null,
+    };
+});
+const ClaudeToolDetailPass2Schema = z.union([
+    toolDetailBranchByName("Bash", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
+    toolDetailBranchByName("bash", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
+    toolDetailBranchByName("shell", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
+    toolDetailBranchByName("exec_command", ToolShellInputSchema, ToolShellOutputSchema, toShellToolDetail),
+    toolDetailBranchByName("Read", ToolReadInputSchema, z.unknown(), (input, output) => {
+        const parsedOutput = ToolReadOutputSchema.safeParse(output);
+        return toReadToolDetail(input, parsedOutput.success ? parsedOutput.data : null);
+    }),
+    toolDetailBranchByName("read", ToolReadInputSchema, z.unknown(), (input, output) => {
+        const parsedOutput = ToolReadOutputSchema.safeParse(output);
+        return toReadToolDetail(input, parsedOutput.success ? parsedOutput.data : null);
+    }),
+    toolDetailBranchByName("read_file", ToolReadInputSchema, z.unknown(), (input, output) => {
+        const parsedOutput = ToolReadOutputSchema.safeParse(output);
+        return toReadToolDetail(input, parsedOutput.success ? parsedOutput.data : null);
+    }),
+    toolDetailBranchByName("view_file", ToolReadInputSchema, z.unknown(), (input, output) => {
+        const parsedOutput = ToolReadOutputSchema.safeParse(output);
+        return toReadToolDetail(input, parsedOutput.success ? parsedOutput.data : null);
+    }),
+    toolDetailBranchByName("Write", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
+    toolDetailBranchByName("write", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
+    toolDetailBranchByName("write_file", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
+    toolDetailBranchByName("create_file", ToolWriteInputSchema, ToolWriteOutputSchema, toWriteToolDetail),
+    toolDetailBranchByName("Edit", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("MultiEdit", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("multi_edit", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("edit", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("apply_patch", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("apply_diff", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("str_replace_editor", ToolEditInputSchema, ToolEditOutputSchema, toEditToolDetail),
+    toolDetailBranchByName("WebSearch", ToolSearchInputSchema, ToolWebSearchOutputSchema.nullable(), (input, output) => toSearchToolDetail({ input, output, toolName: "web_search" })),
+    toolDetailBranchByName("web_search", ToolSearchInputSchema, ToolWebSearchOutputSchema.nullable(), (input, output) => toSearchToolDetail({ input, output, toolName: "web_search" })),
+    toolDetailBranchByName("search", ToolSearchInputSchema, z.unknown(), (input) => toSearchToolDetail({ input, toolName: "search" })),
+    toolDetailBranchByName("Grep", ToolSearchInputSchema, ClaudeGrepOutputSchema, (input, output) => toSearchToolDetail({ input, output, toolName: "grep" })),
+    toolDetailBranchByName("grep", ToolSearchInputSchema, ClaudeGrepOutputSchema, (input, output) => toSearchToolDetail({ input, output, toolName: "grep" })),
+    toolDetailBranchByName("Glob", ToolSearchInputSchema, ToolGlobOutputSchema.nullable(), (input, output) => toSearchToolDetail({ input, output, toolName: "glob" })),
+    toolDetailBranchByName("glob", ToolSearchInputSchema, ToolGlobOutputSchema.nullable(), (input, output) => toSearchToolDetail({ input, output, toolName: "glob" })),
+    toolDetailBranchByName("WebFetch", ToolWebFetchInputSchema, ToolWebFetchOutputSchema, toFetchToolDetail),
+    toolDetailBranchByName("web_fetch", ToolWebFetchInputSchema, ToolWebFetchOutputSchema, toFetchToolDetail),
+    toolDetailBranchByName("WebFetchTool", ToolWebFetchInputSchema, ToolWebFetchOutputSchema, toFetchToolDetail),
+    toolDetailBranchByName("web_fetch_tool", ToolWebFetchInputSchema, ToolWebFetchOutputSchema, toFetchToolDetail),
+    toolDetailBranchByName("webfetch", ToolWebFetchInputSchema, ToolWebFetchOutputSchema, toFetchToolDetail),
+    toolDetailBranchByName("Skill", z.object({ skill: z.string() }).passthrough(), z
+        .union([
+        z
+            .object({ output: z.string() })
+            .passthrough()
+            .transform((value) => value.output),
+        z.string(),
+    ])
+        .nullable(), (input, output) => {
+        const skillName = input?.skill;
+        if (!skillName) {
+            return undefined;
+        }
+        return {
+            type: "plain_text",
+            label: skillName,
+            icon: "sparkles",
+            ...(output ? { text: output } : {}),
+        };
+    }),
+    ClaudeSpeakToolDetailSchema,
+]);
+export function deriveClaudeToolDetail(name, input, output) {
+    const pass1 = ClaudeToolEnvelopeSchema.safeParse({
+        name,
+        input: input ?? null,
+        output: output ?? null,
+    });
+    if (!pass1.success) {
+        return {
+            type: "unknown",
+            input: input ?? null,
+            output: output ?? null,
+        };
+    }
+    const pass2 = ClaudeToolDetailPass2Schema.safeParse(pass1.data);
+    if (pass2.success && pass2.data) {
+        return pass2.data;
+    }
+    return {
+        type: "unknown",
+        input: pass1.data.input,
+        output: pass1.data.output,
+    };
+}
+//# sourceMappingURL=tool-call-detail-parser.js.map

package/dist/server/server/agent/providers/claude/tool-call-mapper.d.ts

@@ -0,0 +1,16 @@
+import type { ToolCallTimelineItem } from "../../agent-sdk-types.js";
+interface MapperParams {
+    callId?: string | null;
+    name: string;
+    input?: unknown;
+    output?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export declare function mapClaudeRunningToolCall(params: MapperParams): ToolCallTimelineItem | null;
+export declare function mapClaudeCompletedToolCall(params: MapperParams): ToolCallTimelineItem | null;
+export declare function mapClaudeFailedToolCall(params: MapperParams & {
+    error: unknown;
+}): ToolCallTimelineItem | null;
+export declare function mapClaudeCanceledToolCall(params: MapperParams): ToolCallTimelineItem | null;
+export {};
+//# sourceMappingURL=tool-call-mapper.d.ts.map

package/dist/server/server/agent/providers/claude/tool-call-mapper.js

@@ -0,0 +1,129 @@
+import { z } from "zod";
+import { isSpeakToolName } from "@camerontaylor/paseo-protocol/tool-name-normalization";
+import { deriveClaudeToolDetail } from "./tool-call-detail-parser.js";
+const ClaudeToolCallStatusSchema = z.enum(["running", "completed", "failed", "canceled"]);
+const ClaudeRawToolCallSchema = z
+    .object({
+    callId: z.string().optional().nullable(),
+    name: z.string().min(1),
+    input: z.unknown().optional(),
+    output: z.unknown().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    error: z.unknown().nullable().optional(),
+    status: ClaudeToolCallStatusSchema,
+})
+    .passthrough();
+const SHELL_NAMES = new Set(["Bash", "bash", "shell", "exec_command"]);
+const READ_NAMES = new Set(["Read", "read", "read_file", "view_file"]);
+const WRITE_NAMES = new Set(["Write", "write", "write_file", "create_file"]);
+const EDIT_NAMES = new Set([
+    "Edit",
+    "MultiEdit",
+    "multi_edit",
+    "edit",
+    "apply_patch",
+    "apply_diff",
+    "str_replace_editor",
+]);
+const SEARCH_NAMES = new Set([
+    "WebSearch",
+    "web_search",
+    "search",
+    "Grep",
+    "grep",
+    "Glob",
+    "glob",
+]);
+const FETCH_NAMES = new Set([
+    "WebFetch",
+    "web_fetch",
+    "WebFetchTool",
+    "web_fetch_tool",
+    "webfetch",
+]);
+function resolveClaudeToolKind(name) {
+    if (SHELL_NAMES.has(name))
+        return "shell";
+    if (READ_NAMES.has(name))
+        return "read";
+    if (WRITE_NAMES.has(name))
+        return "write";
+    if (EDIT_NAMES.has(name))
+        return "edit";
+    if (SEARCH_NAMES.has(name))
+        return "search";
+    if (FETCH_NAMES.has(name))
+        return "fetch";
+    if (isSpeakToolName(name))
+        return "speak";
+    return "unknown";
+}
+function resolveDetailName(toolKind, name) {
+    switch (toolKind) {
+        case "shell":
+            return "shell";
+        case "read":
+            return "read_file";
+        case "write":
+            return "write_file";
+        case "edit":
+            return "apply_patch";
+        case "search":
+        case "fetch":
+            return name;
+        case "speak":
+            return "speak";
+        default:
+            return name;
+    }
+}
+function mapClaudeToolCall(params, status, error) {
+    const parsed = ClaudeRawToolCallSchema.safeParse({ ...params, status, error });
+    if (!parsed.success) {
+        return null;
+    }
+    const raw = parsed.data;
+    const callId = typeof raw.callId === "string" && raw.callId.trim().length > 0 ? raw.callId : null;
+    if (callId === null) {
+        return null;
+    }
+    const trimmedName = raw.name.trim();
+    const toolKind = resolveClaudeToolKind(trimmedName);
+    const name = toolKind === "speak" ? "speak" : trimmedName;
+    const input = raw.input ?? null;
+    const output = raw.output ?? null;
+    const detail = deriveClaudeToolDetail(resolveDetailName(toolKind, name), input, output);
+    if (raw.status === "failed") {
+        return {
+            type: "tool_call",
+            callId,
+            name,
+            detail,
+            status: "failed",
+            error: raw.error ?? { message: "Tool call failed" },
+            ...(raw.metadata ? { metadata: raw.metadata } : {}),
+        };
+    }
+    return {
+        type: "tool_call",
+        callId,
+        name,
+        detail,
+        status: raw.status,
+        error: null,
+        ...(raw.metadata ? { metadata: raw.metadata } : {}),
+    };
+}
+export function mapClaudeRunningToolCall(params) {
+    return mapClaudeToolCall(params, "running", null);
+}
+export function mapClaudeCompletedToolCall(params) {
+    return mapClaudeToolCall(params, "completed", null);
+}
+export function mapClaudeFailedToolCall(params) {
+    return mapClaudeToolCall(params, "failed", params.error);
+}
+export function mapClaudeCanceledToolCall(params) {
+    return mapClaudeToolCall(params, "canceled", null);
+}
+//# sourceMappingURL=tool-call-mapper.js.map

package/dist/server/server/agent/providers/codex/app-server-transport.d.ts

@@ -0,0 +1,101 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import type { Logger } from "pino";
+import { z } from "zod";
+export declare class CodexAppServerRpcError extends Error {
+    readonly code: string | number | undefined;
+    readonly data: unknown;
+    constructor(message: string, code: string | number | undefined, data: unknown);
+}
+type RequestHandler = (params: unknown, requestId: number) => unknown;
+type NotificationHandler = (method: string, params: unknown) => void;
+type UnexpectedTerminationHandler = (error: Error) => void;
+export interface CodexThreadForkParams {
+    threadId: string;
+    beforeTurnId?: string | null;
+    path?: string | null;
+    model?: string | null;
+    modelProvider?: string | null;
+    serviceTier?: string | null;
+    cwd?: string | null;
+    runtimeWorkspaceRoots?: string[] | null;
+    approvalPolicy?: unknown;
+    approvalsReviewer?: unknown;
+    sandbox?: unknown;
+    permissions?: string | null;
+    config?: Record<string, unknown> | null;
+    baseInstructions?: string | null;
+    developerInstructions?: string | null;
+    ephemeral?: boolean;
+    threadSource?: unknown;
+    excludeTurns?: boolean;
+    persistExtendedHistory?: boolean;
+}
+declare const CodexThreadForkResponseSchema: z.ZodObject<{
+    thread: z.ZodObject<{
+        id: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$loose>;
+    model: z.ZodString;
+    modelProvider: z.ZodString;
+    serviceTier: z.ZodNullable<z.ZodString>;
+    cwd: z.ZodString;
+    runtimeWorkspaceRoots: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    instructionSources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    approvalPolicy: z.ZodUnknown;
+    approvalsReviewer: z.ZodUnknown;
+    sandbox: z.ZodUnknown;
+    activePermissionProfile: z.ZodOptional<z.ZodUnknown>;
+    reasoningEffort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export type CodexThreadForkResponse = z.infer<typeof CodexThreadForkResponseSchema>;
+export declare function parseCodexThreadForkResponse(response: unknown): CodexThreadForkResponse;
+export interface CodexThreadRollbackParams {
+    threadId: string;
+    numTurns: number;
+}
+declare const CodexThreadRollbackResponseSchema: z.ZodObject<{
+    thread: z.ZodObject<{
+        id: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+        forkedFromId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        turns: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type CodexThreadRollbackResponse = z.infer<typeof CodexThreadRollbackResponseSchema>;
+export declare function parseCodexThreadRollbackResponse(response: unknown): CodexThreadRollbackResponse;
+export interface CodexAppServerTraceContext {
+    agentId?: string;
+    sessionId?: string;
+    turnId?: string;
+}
+export declare class CodexAppServerClient {
+    private readonly child;
+    private readonly logger;
+    private readonly getTraceContext;
+    private readonly rl;
+    private readonly pending;
+    private readonly requestHandlers;
+    private notificationHandler;
+    private unexpectedTerminationHandler;
+    private nextId;
+    private disposed;
+    private stderrBuffer;
+    constructor(child: ChildProcessWithoutNullStreams, logger: Logger, getTraceContext?: () => CodexAppServerTraceContext);
+    setUnexpectedTerminationHandler(handler: UnexpectedTerminationHandler): void;
+    setNotificationHandler(handler: NotificationHandler): void;
+    setRequestHandler(method: string, handler: RequestHandler): void;
+    request(method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
+    forkThread(params: CodexThreadForkParams): Promise<CodexThreadForkResponse>;
+    rollbackThread(params: CodexThreadRollbackParams): Promise<CodexThreadRollbackResponse>;
+    notify(method: string, params?: unknown): void;
+    dispose(): Promise<void>;
+    private handleUnexpectedTermination;
+    private rejectPending;
+    private writeJsonRpcResponse;
+    private handleLine;
+    private traceRawEvent;
+}
+export {};
+//# sourceMappingURL=app-server-transport.d.ts.map