@hyperdrive.bot/paseo-server 0.2.6

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

@@ -0,0 +1,292 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+const TASK_NOTIFICATION_MARKER = "<task-notification>";
+const TAG_NAME_PATTERN = /[.*+?^${}()|[\]\\]/g;
+const OptionalNonEmptyTrimmedStringSchema = z.preprocess((value) => (typeof value === "string" ? value.trim() : value), z.string().min(1).optional());
+const TaskNotificationEnvelopeSchema = z.object({
+    messageId: z.string().nullable(),
+    taskId: z.string().nullable(),
+    status: z.string().nullable(),
+    summary: z.string().nullable(),
+    outputFile: z.string().nullable(),
+    rawText: z.string().nullable(),
+});
+const TaskNotificationUserContentBlockSchema = z
+    .object({
+    text: z.string().optional(),
+    input: z.string().optional(),
+})
+    .passthrough();
+const TaskNotificationUserContentSchema = z.union([
+    z.string(),
+    z.array(TaskNotificationUserContentBlockSchema),
+]);
+const TaskNotificationHistoryRecordSchema = z
+    .object({
+    type: z.string().optional(),
+    subtype: z.string().optional(),
+    uuid: z.string().optional(),
+    message_id: z.string().optional(),
+    task_id: z.string().optional(),
+    status: z.string().optional(),
+    summary: z.string().optional(),
+    output_file: z.string().optional(),
+    content: z.string().optional(),
+})
+    .passthrough();
+const MapTaskNotificationUserContentToToolCallInputSchema = z.object({
+    content: z.unknown(),
+    messageId: z.string().optional().nullable(),
+});
+function toNonEmptyString(value) {
+    const parsed = OptionalNonEmptyTrimmedStringSchema.safeParse(value);
+    if (!parsed.success) {
+        return null;
+    }
+    return parsed.data ?? null;
+}
+function collectUserContentParts(content) {
+    if (typeof content === "string") {
+        const normalized = toNonEmptyString(content);
+        return normalized ? [normalized] : [];
+    }
+    const parts = [];
+    for (const block of content) {
+        const text = toNonEmptyString(block.text);
+        if (text) {
+            parts.push(text);
+        }
+        const input = toNonEmptyString(block.input);
+        if (input) {
+            parts.push(input);
+        }
+    }
+    return parts;
+}
+function extractUserContentText(content) {
+    const parsedContent = TaskNotificationUserContentSchema.safeParse(content);
+    if (!parsedContent.success) {
+        return null;
+    }
+    const parts = collectUserContentParts(parsedContent.data);
+    if (parts.length === 0) {
+        return null;
+    }
+    return parts.join("\n\n");
+}
+function readTaskNotificationTagValue(input) {
+    const escapedTagName = input.tagName.replace(TAG_NAME_PATTERN, "\\$&");
+    const pattern = new RegExp(`<${escapedTagName}>\\s*([\\s\\S]*?)\\s*</${escapedTagName}>`, "i");
+    const match = input.text.match(pattern);
+    if (!match) {
+        return null;
+    }
+    return toNonEmptyString(match[1]);
+}
+function parseTaskNotificationFromUserContent(input) {
+    const parsedInput = MapTaskNotificationUserContentToToolCallInputSchema.safeParse(input);
+    if (!parsedInput.success) {
+        return null;
+    }
+    const rawText = extractUserContentText(parsedInput.data.content);
+    if (!rawText || !rawText.includes(TASK_NOTIFICATION_MARKER)) {
+        return null;
+    }
+    return TaskNotificationEnvelopeSchema.parse({
+        messageId: toNonEmptyString(parsedInput.data.messageId),
+        taskId: readTaskNotificationTagValue({ text: rawText, tagName: "task-id" }),
+        status: readTaskNotificationTagValue({ text: rawText, tagName: "status" }),
+        summary: readTaskNotificationTagValue({ text: rawText, tagName: "summary" }),
+        outputFile: readTaskNotificationTagValue({ text: rawText, tagName: "output-file" }) ??
+            readTaskNotificationTagValue({ text: rawText, tagName: "output_file" }),
+        rawText,
+    });
+}
+function parseTaskNotificationFromSystemRecord(record) {
+    const parsedRecord = TaskNotificationHistoryRecordSchema.safeParse(record);
+    if (!parsedRecord.success) {
+        return null;
+    }
+    const systemRecord = parsedRecord.data;
+    const isSystemTaskNotification = systemRecord.type === "system" && systemRecord.subtype === "task_notification";
+    const isQueueOperation = systemRecord.type === "queue-operation";
+    if (!isSystemTaskNotification && !isQueueOperation) {
+        return null;
+    }
+    const rawText = toNonEmptyString(systemRecord.content);
+    return TaskNotificationEnvelopeSchema.parse({
+        messageId: toNonEmptyString(systemRecord.uuid) ?? toNonEmptyString(systemRecord.message_id),
+        taskId: toNonEmptyString(systemRecord.task_id) ??
+            (rawText ? readTaskNotificationTagValue({ text: rawText, tagName: "task-id" }) : null),
+        status: toNonEmptyString(systemRecord.status) ??
+            (rawText ? readTaskNotificationTagValue({ text: rawText, tagName: "status" }) : null),
+        summary: toNonEmptyString(systemRecord.summary) ??
+            (rawText ? readTaskNotificationTagValue({ text: rawText, tagName: "summary" }) : null),
+        outputFile: toNonEmptyString(systemRecord.output_file) ??
+            (rawText
+                ? (readTaskNotificationTagValue({ text: rawText, tagName: "output-file" }) ??
+                    readTaskNotificationTagValue({ text: rawText, tagName: "output_file" }))
+                : null),
+        rawText,
+    });
+}
+/**
+ * Project a system task_notification record down to its background-task
+ * lifecycle ({ taskId, status }) — used to expire a tracked background shell
+ * when its terminal notification arrives. Returns null when there's no task id.
+ */
+export function extractTaskNotificationLifecycleFromSystemRecord(record) {
+    const envelope = parseTaskNotificationFromSystemRecord(record);
+    if (!envelope?.taskId) {
+        return null;
+    }
+    return { taskId: envelope.taskId, status: envelope.status };
+}
+/** Same as above for a task_notification that arrives as user-message content. */
+export function extractTaskNotificationLifecycleFromUserContent(input) {
+    const envelope = parseTaskNotificationFromUserContent(input);
+    if (!envelope?.taskId) {
+        return null;
+    }
+    return { taskId: envelope.taskId, status: envelope.status };
+}
+function normalizeTaskNotificationCallIdSegment(segment) {
+    const normalized = segment.trim().replace(/[^a-zA-Z0-9._:-]+/g, "_");
+    return normalized.length > 0 ? normalized : null;
+}
+function buildTaskNotificationCallId(envelope) {
+    const messageSegment = envelope.messageId
+        ? normalizeTaskNotificationCallIdSegment(envelope.messageId)
+        : null;
+    if (messageSegment) {
+        return `task_notification_${messageSegment}`;
+    }
+    const taskSegment = envelope.taskId
+        ? normalizeTaskNotificationCallIdSegment(envelope.taskId)
+        : null;
+    if (taskSegment) {
+        return `task_notification_${taskSegment}`;
+    }
+    const seed = [envelope.status, envelope.summary, envelope.outputFile, envelope.rawText]
+        .filter((value) => typeof value === "string")
+        .join("|") || "task_notification";
+    const digest = createHash("sha1").update(seed).digest("hex").slice(0, 12);
+    return `task_notification_${digest}`;
+}
+function buildTaskNotificationLabel(envelope) {
+    if (envelope.summary) {
+        return envelope.summary;
+    }
+    if (envelope.status) {
+        return `Background task ${envelope.status.toLowerCase()}`;
+    }
+    return "Background task notification";
+}
+function buildTaskNotificationStatus(input) {
+    const normalizedStatus = input.status?.toLowerCase() ?? null;
+    if (normalizedStatus === "failed" || normalizedStatus === "error") {
+        return {
+            status: "failed",
+            error: { message: input.summary ?? "Background task failed" },
+        };
+    }
+    if (normalizedStatus === "canceled" || normalizedStatus === "cancelled") {
+        return { status: "canceled", error: null };
+    }
+    return { status: "completed", error: null };
+}
+function toTaskNotificationToolCall(envelope) {
+    const lifecycle = buildTaskNotificationStatus({
+        status: envelope.status,
+        summary: envelope.summary,
+    });
+    const label = buildTaskNotificationLabel(envelope);
+    const detailText = envelope.rawText ?? envelope.summary ?? undefined;
+    const metadata = {
+        synthetic: true,
+        source: "claude_task_notification",
+        ...(envelope.taskId ? { taskId: envelope.taskId } : {}),
+        ...(envelope.status ? { status: envelope.status } : {}),
+        ...(envelope.outputFile ? { outputFile: envelope.outputFile } : {}),
+    };
+    const base = {
+        type: "tool_call",
+        callId: buildTaskNotificationCallId(envelope),
+        name: "task_notification",
+        detail: {
+            type: "plain_text",
+            label,
+            icon: "wrench",
+            ...(detailText ? { text: detailText } : {}),
+        },
+        metadata,
+    };
+    if (lifecycle.status === "failed") {
+        return {
+            ...base,
+            status: "failed",
+            error: lifecycle.error,
+        };
+    }
+    if (lifecycle.status === "canceled") {
+        return {
+            ...base,
+            status: "canceled",
+            error: null,
+        };
+    }
+    return {
+        ...base,
+        status: "completed",
+        error: null,
+    };
+}
+export function isTaskNotificationUserContent(content) {
+    const rawText = extractUserContentText(content);
+    if (!rawText) {
+        return false;
+    }
+    return rawText.includes(TASK_NOTIFICATION_MARKER);
+}
+export function mapTaskNotificationUserContentToToolCall(input) {
+    const parsed = parseTaskNotificationFromUserContent(input);
+    if (!parsed) {
+        return null;
+    }
+    return toTaskNotificationToolCall(parsed);
+}
+export function mapTaskNotificationSystemRecordToToolCall(record) {
+    const parsed = parseTaskNotificationFromSystemRecord(record);
+    if (!parsed) {
+        return null;
+    }
+    return toTaskNotificationToolCall(parsed);
+}
+export function coerceTaskNotificationHistoryRecordToSystemMessage(record) {
+    const parsed = parseTaskNotificationFromSystemRecord(record);
+    if (!parsed) {
+        return null;
+    }
+    const normalizedStatus = parsed.status?.toLowerCase() ?? null;
+    let status;
+    if (normalizedStatus === "failed" || normalizedStatus === "error") {
+        status = "failed";
+    }
+    else if (normalizedStatus === "canceled" || normalizedStatus === "cancelled") {
+        status = "stopped";
+    }
+    else {
+        status = "completed";
+    }
+    return {
+        type: "system",
+        subtype: "task_notification",
+        ...(parsed.messageId ? { uuid: parsed.messageId } : {}),
+        ...(parsed.taskId ? { task_id: parsed.taskId } : {}),
+        status,
+        ...(parsed.summary ? { summary: parsed.summary } : {}),
+        ...(parsed.outputFile ? { output_file: parsed.outputFile } : {}),
+        ...(parsed.rawText ? { content: parsed.rawText } : {}),
+    };
+}
+//# sourceMappingURL=task-notification-tool-call.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 "@hyperdrive.bot/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/claude/transport/claude-paths.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared Claude transcript path helpers.
+ *
+ * The `claude` binary writes session transcripts to
+ *   `{CLAUDE_CONFIG_DIR | ~/.claude}/projects/{sanitized-cwd}/{sessionId}.jsonl`
+ *
+ * where sanitization replaces `\`, `/`, `.`, `_`, `:` with `-`.
+ *
+ * Extracted from agent.ts + continue-flag.ts so multiple call sites
+ * (history load, --continue probe, truncateSessionAt) share one rule.
+ */
+export declare function sanitizeClaudeProjectPath(cwd: string): string;
+export interface ResolveTranscriptPathArgs {
+    cwd: string;
+    sessionId: string;
+    configDir?: string;
+}
+export declare function resolveClaudeConfigDir(override?: string): string;
+export declare function resolveTranscriptPath(args: ResolveTranscriptPathArgs): string;
+export declare function resolveTranscriptDir(cwd: string, configDir?: string): string;
+/**
+ * Locate `<sessionId>.jsonl` under ANY project dir, not just the one derived
+ * from a given cwd. Claude scopes transcripts by cwd-slug, so a session created
+ * under one `$HOME` (e.g. `/Users/marcelo/...`) cannot be found via
+ * `resolveTranscriptPath` when resumed from a different cwd (`/Users/claudinho/...`)
+ * — the slug no longer matches and history loads empty (blank chat). This scans
+ * every project dir so cross-home / migrated sessions still hydrate. Synchronous
+ * (mirrors the sync `loadPersistedHistory` read path); returns null if not found.
+ */
+export declare function findTranscriptAcrossProjects(sessionId: string, configDir?: string): string | null;
+//# sourceMappingURL=claude-paths.d.ts.map