@otto-code/server 0.5.0

package/dist/server/server/agent/providers/claude/sidechain-tracker.js

@@ -0,0 +1,232 @@
+import { mapClaudeRunningToolCall } from "./tool-call-mapper.js";
+import { buildToolCallDisplayModel } from "@otto-code/protocol/tool-call-display";
+const MAX_SUB_AGENT_LOG_ENTRIES = 200;
+const MAX_SUB_AGENT_SUMMARY_CHARS = 160;
+function readTrimmedString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function isClaudeContentChunk(value) {
+    return Boolean(value && typeof value === "object" && typeof value.type === "string");
+}
+export class ClaudeSidechainTracker {
+    constructor(input) {
+        this.activeSidechains = new Map();
+        this.getToolInput = input.getToolInput;
+    }
+    handleMessage(message, parentToolUseId) {
+        const state = this.activeSidechains.get(parentToolUseId) ??
+            {
+                actions: [],
+                actionKeys: [],
+                nextActionIndex: 1,
+                actionIndexByKey: new Map(),
+            };
+        this.activeSidechains.set(parentToolUseId, state);
+        const contextUpdated = this.updateSubAgentContextFromTaskInput(state, parentToolUseId);
+        const actionCandidates = this.extractSubAgentActionCandidates(message);
+        let actionUpdated = false;
+        for (const action of actionCandidates) {
+            if (this.appendSubAgentAction(state, action)) {
+                actionUpdated = true;
+            }
+        }
+        if (!contextUpdated && !actionUpdated) {
+            return [];
+        }
+        const toolCall = mapClaudeRunningToolCall({
+            name: "Task",
+            callId: parentToolUseId,
+            input: null,
+            output: null,
+        });
+        if (!toolCall) {
+            return [];
+        }
+        const detail = {
+            type: "sub_agent",
+            ...(state.subAgentType ? { subAgentType: state.subAgentType } : {}),
+            ...(state.description ? { description: state.description } : {}),
+            log: state.actions
+                .map((action) => action.summary ? `[${action.toolName}] ${action.summary}` : `[${action.toolName}]`)
+                .join("\n"),
+            actions: [],
+        };
+        return [
+            {
+                type: "timeline",
+                item: {
+                    ...toolCall,
+                    detail,
+                },
+                provider: "claude",
+            },
+        ];
+    }
+    delete(toolUseId) {
+        this.activeSidechains.delete(toolUseId);
+    }
+    clear() {
+        this.activeSidechains.clear();
+    }
+    updateSubAgentContextFromTaskInput(state, parentToolUseId) {
+        const taskInput = this.getToolInput(parentToolUseId);
+        const nextSubAgentType = this.normalizeSubAgentText(taskInput?.subagent_type);
+        const nextDescription = this.normalizeSubAgentText(taskInput?.description);
+        let changed = false;
+        if (nextSubAgentType && nextSubAgentType !== state.subAgentType) {
+            state.subAgentType = nextSubAgentType;
+            changed = true;
+        }
+        if (nextDescription && nextDescription !== state.description) {
+            state.description = nextDescription;
+            changed = true;
+        }
+        return changed;
+    }
+    normalizeSubAgentText(value) {
+        const normalized = readTrimmedString(value)?.replace(/\s+/g, " ");
+        if (!normalized) {
+            return undefined;
+        }
+        if (normalized.length <= MAX_SUB_AGENT_SUMMARY_CHARS) {
+            return normalized;
+        }
+        return `${normalized.slice(0, MAX_SUB_AGENT_SUMMARY_CHARS)}...`;
+    }
+    extractAssistantMessageActions(message) {
+        const content = message.message?.content;
+        if (!Array.isArray(content)) {
+            return [];
+        }
+        const actions = [];
+        for (const block of content) {
+            if (!isClaudeContentChunk(block) ||
+                !(block.type === "tool_use" ||
+                    block.type === "mcp_tool_use" ||
+                    block.type === "server_tool_use") ||
+                typeof block.name !== "string") {
+                continue;
+            }
+            const key = readTrimmedString(block.id) ?? `assistant:${block.name}:${actions.length}`;
+            actions.push({
+                key,
+                toolName: block.name,
+                input: block.input ?? null,
+            });
+        }
+        return actions;
+    }
+    extractStreamEventActions(message) {
+        const event = message.event;
+        if (event.type !== "content_block_start") {
+            return [];
+        }
+        const block = isClaudeContentChunk(event.content_block) ? event.content_block : null;
+        if (!block ||
+            !(block.type === "tool_use" ||
+                block.type === "mcp_tool_use" ||
+                block.type === "server_tool_use") ||
+            typeof block.name !== "string") {
+            return [];
+        }
+        const key = readTrimmedString(block.id) ??
+            `stream:${block.name}:${typeof event.index === "number" ? event.index : 0}`;
+        return [
+            {
+                key,
+                toolName: block.name,
+                input: block.input ?? null,
+            },
+        ];
+    }
+    extractSubAgentActionCandidates(message) {
+        if (message.type === "assistant") {
+            return this.extractAssistantMessageActions(message);
+        }
+        if (message.type === "stream_event") {
+            return this.extractStreamEventActions(message);
+        }
+        if (message.type === "tool_progress") {
+            const toolName = readTrimmedString(message.tool_name);
+            if (!toolName) {
+                return [];
+            }
+            const key = readTrimmedString(message.tool_use_id) ?? `progress:${toolName}`;
+            return [{ key, toolName, input: null }];
+        }
+        return [];
+    }
+    appendSubAgentAction(state, candidate) {
+        const normalizedToolName = readTrimmedString(candidate.toolName);
+        if (!normalizedToolName) {
+            return false;
+        }
+        const summary = this.deriveSubAgentActionSummary(normalizedToolName, candidate.input);
+        const existingIndex = state.actionIndexByKey.get(candidate.key);
+        if (existingIndex !== undefined) {
+            const existing = state.actions[existingIndex];
+            if (!existing) {
+                return false;
+            }
+            const nextSummary = existing.summary ?? summary;
+            if (existing.toolName === normalizedToolName && existing.summary === nextSummary) {
+                return false;
+            }
+            state.actions[existingIndex] = {
+                ...existing,
+                toolName: normalizedToolName,
+                ...(nextSummary ? { summary: nextSummary } : {}),
+            };
+            return true;
+        }
+        state.actions.push({
+            index: state.nextActionIndex,
+            toolName: normalizedToolName,
+            ...(summary ? { summary } : {}),
+        });
+        state.nextActionIndex += 1;
+        state.actionKeys.push(candidate.key);
+        this.trimSubAgentTail(state);
+        this.rebuildSubAgentActionIndex(state);
+        return true;
+    }
+    trimSubAgentTail(state) {
+        while (state.actions.length > MAX_SUB_AGENT_LOG_ENTRIES) {
+            state.actions.shift();
+            state.actionKeys.shift();
+        }
+    }
+    rebuildSubAgentActionIndex(state) {
+        state.actionIndexByKey.clear();
+        for (let index = 0; index < state.actionKeys.length; index += 1) {
+            const key = state.actionKeys[index];
+            if (key) {
+                state.actionIndexByKey.set(key, index);
+            }
+        }
+    }
+    deriveSubAgentActionSummary(toolName, input) {
+        const runningToolCall = mapClaudeRunningToolCall({
+            name: toolName,
+            callId: `sub-agent-summary-${toolName}`,
+            input,
+            output: null,
+        });
+        if (!runningToolCall) {
+            return undefined;
+        }
+        const display = buildToolCallDisplayModel({
+            name: runningToolCall.name,
+            status: runningToolCall.status,
+            error: runningToolCall.error,
+            detail: runningToolCall.detail,
+            metadata: runningToolCall.metadata,
+        });
+        return this.normalizeSubAgentText(display.summary);
+    }
+}
+//# sourceMappingURL=sidechain-tracker.js.map

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

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import type { AgentTimelineItem } from "../../agent-sdk-types.js";
+declare const TaskNotificationEnvelopeSchema: z.ZodObject<{
+    messageId: z.ZodNullable<z.ZodString>;
+    taskId: z.ZodNullable<z.ZodString>;
+    status: z.ZodNullable<z.ZodString>;
+    summary: z.ZodNullable<z.ZodString>;
+    outputFile: z.ZodNullable<z.ZodString>;
+    rawText: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const MapTaskNotificationUserContentToToolCallInputSchema: z.ZodObject<{
+    content: z.ZodUnknown;
+    messageId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export type TaskNotificationEnvelope = z.infer<typeof TaskNotificationEnvelopeSchema>;
+export type MapTaskNotificationUserContentToToolCallInput = z.infer<typeof MapTaskNotificationUserContentToToolCallInputSchema>;
+export interface TaskNotificationSystemMessageLike {
+    type: "system";
+    subtype: "task_notification";
+    uuid?: string;
+    task_id?: string;
+    status?: "completed" | "failed" | "stopped";
+    summary?: string;
+    output_file?: string;
+    content?: string;
+}
+type TaskNotificationToolCallItem = Extract<AgentTimelineItem, {
+    type: "tool_call";
+}>;
+export declare function isTaskNotificationUserContent(content: unknown): boolean;
+export declare function mapTaskNotificationUserContentToToolCall(input: MapTaskNotificationUserContentToToolCallInput): TaskNotificationToolCallItem | null;
+export declare function mapTaskNotificationSystemRecordToToolCall(record: unknown): TaskNotificationToolCallItem | null;
+export declare function coerceTaskNotificationHistoryRecordToSystemMessage(record: unknown): TaskNotificationSystemMessageLike | null;
+export {};
+//# sourceMappingURL=task-notification-tool-call.d.ts.map

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

@@ -0,0 +1,272 @@
+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,
+    });
+}
+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