@otto-code/server 0.5.0

package/dist/server/server/agent/agent-stream-coalescer.js

@@ -0,0 +1,166 @@
+export const AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS = 60;
+function isCoalescableTimelineEvent(event) {
+    return (event.type === "timeline" &&
+        (event.item.type === "assistant_message" ||
+            event.item.type === "reasoning" ||
+            event.item.type === "tool_call"));
+}
+function isTextTimelineItem(item) {
+    return item.type === "assistant_message" || item.type === "reasoning";
+}
+function isTerminalToolCall(item) {
+    return (item.type === "tool_call" &&
+        (item.status === "completed" || item.status === "failed" || item.status === "canceled"));
+}
+export class AgentStreamCoalescer {
+    constructor(options) {
+        this.buffers = new Map();
+        this.windowMs = options.windowMs ?? AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS;
+        this.timers = options.timers;
+        this.onFlush = options.onFlush;
+    }
+    handle(agentId, event) {
+        if (!isCoalescableTimelineEvent(event)) {
+            return false;
+        }
+        if (isTextTimelineItem(event.item) && event.item.text === "") {
+            return true;
+        }
+        const buffer = this.getOrCreateBuffer(agentId);
+        this.appendToBuffer(buffer, event);
+        if (isTerminalToolCall(event.item)) {
+            this.flushBuffer(agentId);
+            return true;
+        }
+        if (!buffer.timer) {
+            this.scheduleFlush(buffer);
+        }
+        return true;
+    }
+    flushFor(agentId) {
+        this.flushBuffer(agentId);
+    }
+    flushAll() {
+        for (const agentId of Array.from(this.buffers.keys())) {
+            this.flushBuffer(agentId);
+        }
+    }
+    flushAndDiscard(agentId) {
+        this.flushBuffer(agentId);
+        const buffer = this.buffers.get(agentId);
+        if (buffer) {
+            this.clearTimer(buffer);
+            this.buffers.delete(agentId);
+        }
+    }
+    getOrCreateBuffer(agentId) {
+        const existing = this.buffers.get(agentId);
+        if (existing) {
+            return existing;
+        }
+        const buffer = {
+            agentId,
+            entries: [],
+            toolCallEntryIndexes: new Map(),
+            timer: null,
+            flushing: false,
+        };
+        this.buffers.set(agentId, buffer);
+        return buffer;
+    }
+    appendToBuffer(buffer, event) {
+        if (isTextTimelineItem(event.item)) {
+            buffer.entries.push({
+                kind: "text",
+                item: event.item,
+                text: event.item.text,
+                provider: event.provider,
+                ...(event.turnId !== undefined ? { turnId: event.turnId } : {}),
+            });
+            return;
+        }
+        const existingIndex = buffer.toolCallEntryIndexes.get(event.item.callId);
+        const entry = {
+            kind: "tool_call",
+            item: event.item,
+            provider: event.provider,
+            ...(event.turnId !== undefined ? { turnId: event.turnId } : {}),
+        };
+        if (existingIndex !== undefined) {
+            buffer.entries[existingIndex] = entry;
+            return;
+        }
+        buffer.toolCallEntryIndexes.set(event.item.callId, buffer.entries.length);
+        buffer.entries.push(entry);
+    }
+    scheduleFlush(buffer) {
+        const timer = this.timers.setTimeout(() => {
+            this.flushBuffer(buffer.agentId, buffer);
+        }, this.windowMs);
+        timer.unref?.();
+        buffer.timer = timer;
+    }
+    clearTimer(buffer) {
+        if (!buffer.timer) {
+            return;
+        }
+        this.timers.clearTimeout(buffer.timer);
+        buffer.timer = null;
+    }
+    flushBuffer(agentId, expectedBuffer) {
+        const buffer = this.buffers.get(agentId);
+        if (!buffer) {
+            return;
+        }
+        if (expectedBuffer && buffer !== expectedBuffer) {
+            return;
+        }
+        if (buffer.flushing) {
+            return;
+        }
+        this.clearTimer(buffer);
+        if (buffer.entries.length === 0) {
+            return;
+        }
+        const entries = buffer.entries;
+        buffer.entries = [];
+        buffer.toolCallEntryIndexes.clear();
+        buffer.flushing = true;
+        try {
+            for (const entry of this.collapseEntries(entries)) {
+                this.onFlush({
+                    agentId,
+                    item: entry.kind === "text"
+                        ? {
+                            ...entry.item,
+                            text: entry.text,
+                        }
+                        : entry.item,
+                    provider: entry.provider,
+                    ...(entry.turnId !== undefined ? { turnId: entry.turnId } : {}),
+                });
+            }
+        }
+        finally {
+            buffer.flushing = false;
+        }
+    }
+    collapseEntries(entries) {
+        const collapsed = [];
+        for (const entry of entries) {
+            const previous = collapsed.at(-1);
+            if (previous &&
+                previous.kind === "text" &&
+                entry.kind === "text" &&
+                previous.item.type === entry.item.type &&
+                previous.provider === entry.provider &&
+                previous.turnId === entry.turnId) {
+                previous.text += entry.text;
+                continue;
+            }
+            collapsed.push({ ...entry });
+        }
+        return collapsed;
+    }
+}
+//# sourceMappingURL=agent-stream-coalescer.js.map

package/dist/server/server/agent/agent-timeline-store-types.d.ts

@@ -0,0 +1,50 @@
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+export interface AgentTimelineRow {
+    seq: number;
+    timestamp: string;
+    item: AgentTimelineItem;
+}
+export interface AgentTimelineCursor {
+    epoch: string;
+    seq: number;
+}
+export type AgentTimelineFetchDirection = "tail" | "before" | "after";
+export interface AgentTimelineFetchOptions {
+    direction?: AgentTimelineFetchDirection;
+    cursor?: AgentTimelineCursor;
+    /**
+     * Number of canonical rows to return.
+     * - undefined: store default
+     * - 0: all rows in the selected window
+     */
+    limit?: number;
+}
+export interface AgentTimelineWindow {
+    minSeq: number;
+    maxSeq: number;
+    nextSeq: number;
+}
+export interface AgentTimelineFetchResult {
+    epoch: string;
+    direction: AgentTimelineFetchDirection;
+    reset: boolean;
+    staleCursor: boolean;
+    gap: boolean;
+    window: AgentTimelineWindow;
+    hasOlder: boolean;
+    hasNewer: boolean;
+    rows: AgentTimelineRow[];
+}
+export interface AgentTimelineStore {
+    appendCommitted(agentId: string, item: AgentTimelineItem, options?: {
+        timestamp?: string;
+    }): Promise<AgentTimelineRow>;
+    fetchCommitted(agentId: string, options?: AgentTimelineFetchOptions): Promise<AgentTimelineFetchResult>;
+    getLatestCommittedSeq(agentId: string): Promise<number>;
+    getCommittedRows(agentId: string): Promise<AgentTimelineRow[]>;
+    getLastItem(agentId: string): Promise<AgentTimelineItem | null>;
+    getLastAssistantMessage(agentId: string): Promise<string | null>;
+    deleteAgent(agentId: string): Promise<void>;
+    bulkInsert(agentId: string, rows: readonly AgentTimelineRow[]): Promise<void>;
+}
+//# sourceMappingURL=agent-timeline-store-types.d.ts.map

package/dist/server/server/agent/agent-timeline-store-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent-timeline-store-types.js.map

package/dist/server/server/agent/agent-timeline-store.d.ts

@@ -0,0 +1,27 @@
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+import type { AgentTimelineFetchOptions, AgentTimelineFetchResult, AgentTimelineRow } from "./agent-timeline-store-types.js";
+export interface SeedAgentTimelineOptions {
+    items?: readonly AgentTimelineItem[];
+    rows?: readonly AgentTimelineRow[];
+    epoch?: string;
+    nextSeq?: number;
+    timestamp?: string;
+}
+export declare class InMemoryAgentTimelineStore {
+    private readonly states;
+    has(agentId: string): boolean;
+    initialize(agentId: string, options?: SeedAgentTimelineOptions): void;
+    delete(agentId: string): void;
+    getItems(agentId: string): AgentTimelineItem[];
+    getRows(agentId: string): AgentTimelineRow[];
+    getEpoch(agentId: string): string;
+    fetch(agentId: string, options?: AgentTimelineFetchOptions): AgentTimelineFetchResult;
+    append(agentId: string, item: AgentTimelineItem, options?: {
+        timestamp?: string;
+    }): AgentTimelineRow;
+    getLastItem(agentId: string): AgentTimelineItem | null;
+    getLastAssistantMessage(agentId: string): string | null;
+    private requireState;
+    private buildRowsFromItems;
+}
+//# sourceMappingURL=agent-timeline-store.d.ts.map

package/dist/server/server/agent/agent-timeline-store.js

@@ -0,0 +1,230 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_TIMELINE_FETCH_LIMIT = 200;
+function cloneRow(row) {
+    return { ...row };
+}
+function fetchTail(ctx) {
+    const { state, direction, limit, selectAll, minSeq, window } = ctx;
+    const selected = selectAll || limit >= state.rows.length
+        ? state.rows
+        : state.rows.slice(state.rows.length - limit);
+    return {
+        epoch: state.epoch,
+        direction,
+        reset: false,
+        staleCursor: false,
+        gap: false,
+        window,
+        hasOlder: selected.length > 0 && selected[0].seq > minSeq,
+        hasNewer: false,
+        rows: selected.map(cloneRow),
+    };
+}
+function fetchAfter(ctx) {
+    const { state, direction, limit, selectAll, cursor, minSeq, maxSeq, window } = ctx;
+    const baseSeq = cursor?.seq ?? 0;
+    const startIdx = state.rows.findIndex((row) => row.seq > baseSeq);
+    if (startIdx < 0) {
+        return {
+            epoch: state.epoch,
+            direction,
+            reset: false,
+            staleCursor: false,
+            gap: false,
+            window,
+            hasOlder: baseSeq >= minSeq,
+            hasNewer: false,
+            rows: [],
+        };
+    }
+    const selected = selectAll
+        ? state.rows.slice(startIdx)
+        : state.rows.slice(startIdx, startIdx + limit);
+    const lastSelected = selected[selected.length - 1];
+    return {
+        epoch: state.epoch,
+        direction,
+        reset: false,
+        staleCursor: false,
+        gap: false,
+        window,
+        hasOlder: selected[0].seq > minSeq,
+        hasNewer: lastSelected !== null && lastSelected !== undefined && lastSelected.seq < maxSeq,
+        rows: selected.map(cloneRow),
+    };
+}
+function fetchBefore(ctx) {
+    const { state, direction, limit, selectAll, cursor, minSeq, window } = ctx;
+    const beforeSeq = cursor?.seq ?? state.nextSeq;
+    const endExclusive = state.rows.findIndex((row) => row.seq >= beforeSeq);
+    const boundedRows = endExclusive < 0 ? state.rows : state.rows.slice(0, endExclusive);
+    const selected = selectAll || limit >= boundedRows.length
+        ? boundedRows
+        : boundedRows.slice(boundedRows.length - limit);
+    return {
+        epoch: state.epoch,
+        direction,
+        reset: false,
+        staleCursor: false,
+        gap: false,
+        window,
+        hasOlder: selected.length > 0 && selected[0].seq > minSeq,
+        hasNewer: endExclusive >= 0,
+        rows: selected.map(cloneRow),
+    };
+}
+function fetchReset(ctx, flags) {
+    const { state, direction, limit, selectAll, minSeq, window } = ctx;
+    const rows = selectAll || limit >= state.rows.length
+        ? state.rows.map(cloneRow)
+        : state.rows.slice(state.rows.length - limit).map(cloneRow);
+    return {
+        epoch: state.epoch,
+        direction,
+        reset: true,
+        staleCursor: flags.staleCursor,
+        gap: flags.gap,
+        window,
+        hasOlder: rows.length > 0 && rows[0].seq > minSeq,
+        hasNewer: false,
+        rows,
+    };
+}
+export class InMemoryAgentTimelineStore {
+    constructor() {
+        this.states = new Map();
+    }
+    has(agentId) {
+        return this.states.has(agentId);
+    }
+    initialize(agentId, options) {
+        const timestamp = options?.timestamp ?? new Date().toISOString();
+        const rows = options?.rows?.length
+            ? options.rows.map(cloneRow)
+            : this.buildRowsFromItems(options?.items ?? [], options?.nextSeq ?? 1, timestamp);
+        const nextSeq = options?.nextSeq ?? (rows.length ? rows[rows.length - 1].seq + 1 : 1);
+        this.states.set(agentId, {
+            epoch: options?.epoch ?? randomUUID(),
+            rows,
+            nextSeq,
+        });
+    }
+    delete(agentId) {
+        this.states.delete(agentId);
+    }
+    getItems(agentId) {
+        return this.requireState(agentId).rows.map((row) => row.item);
+    }
+    getRows(agentId) {
+        return this.requireState(agentId).rows.map(cloneRow);
+    }
+    getEpoch(agentId) {
+        return this.requireState(agentId).epoch;
+    }
+    fetch(agentId, options) {
+        const state = this.requireState(agentId);
+        const direction = options?.direction ?? "tail";
+        const requestedLimit = options?.limit;
+        const limit = requestedLimit === undefined
+            ? DEFAULT_TIMELINE_FETCH_LIMIT
+            : Math.max(0, Math.floor(requestedLimit));
+        const cursor = options?.cursor;
+        const minSeq = state.rows.length ? state.rows[0].seq : 0;
+        const maxSeq = state.rows.length ? state.rows[state.rows.length - 1].seq : 0;
+        const selectAll = limit === 0;
+        const window = {
+            minSeq,
+            maxSeq,
+            nextSeq: state.nextSeq,
+        };
+        const ctx = {
+            state,
+            direction,
+            limit,
+            selectAll,
+            cursor,
+            minSeq,
+            maxSeq,
+            window,
+        };
+        if (cursor && typeof cursor.epoch === "string" && cursor.epoch !== state.epoch) {
+            return fetchReset(ctx, { staleCursor: true, gap: false });
+        }
+        if (direction === "after" && cursor && state.rows.length > 0 && cursor.seq < minSeq - 1) {
+            return fetchReset(ctx, { staleCursor: false, gap: true });
+        }
+        if (state.rows.length === 0) {
+            return {
+                epoch: state.epoch,
+                direction,
+                reset: false,
+                staleCursor: false,
+                gap: false,
+                window,
+                hasOlder: false,
+                hasNewer: false,
+                rows: [],
+            };
+        }
+        if (direction === "tail") {
+            return fetchTail(ctx);
+        }
+        if (direction === "after") {
+            return fetchAfter(ctx);
+        }
+        return fetchBefore(ctx);
+    }
+    append(agentId, item, options) {
+        const state = this.requireState(agentId);
+        const row = {
+            seq: state.nextSeq,
+            timestamp: options?.timestamp ?? new Date().toISOString(),
+            item,
+        };
+        state.nextSeq += 1;
+        state.rows.push(row);
+        return cloneRow(row);
+    }
+    getLastItem(agentId) {
+        const state = this.requireState(agentId);
+        return state.rows[state.rows.length - 1]?.item ?? null;
+    }
+    getLastAssistantMessage(agentId) {
+        const rows = this.requireState(agentId).rows;
+        const chunks = [];
+        for (let i = rows.length - 1; i >= 0; i -= 1) {
+            const item = rows[i].item;
+            if (item.type !== "assistant_message") {
+                if (chunks.length > 0) {
+                    break;
+                }
+                continue;
+            }
+            chunks.push(item.text);
+        }
+        if (chunks.length === 0) {
+            return null;
+        }
+        return chunks.toReversed().join("");
+    }
+    requireState(agentId) {
+        const state = this.states.get(agentId);
+        if (!state) {
+            throw new Error(`Unknown agent '${agentId}'`);
+        }
+        return state;
+    }
+    buildRowsFromItems(items, startSeq, timestamp) {
+        let nextSeq = startSeq;
+        return items.map((item) => {
+            const row = {
+                seq: nextSeq,
+                timestamp,
+                item,
+            };
+            nextSeq += 1;
+            return row;
+        });
+    }
+}
+//# sourceMappingURL=agent-timeline-store.js.map

package/dist/server/server/agent/audio-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function inferAudioExtension(format: string | undefined): string;
+export declare function sanitizeForFilename(segment: string | undefined, fallback: string): string;
+//# sourceMappingURL=audio-utils.d.ts.map

package/dist/server/server/agent/audio-utils.js

@@ -0,0 +1,19 @@
+const AUDIO_EXTENSIONS = [
+    { match: (format) => format.includes("webm"), ext: "webm" },
+    { match: (format) => format.includes("ogg"), ext: "ogg" },
+    { match: (format) => format.includes("mp3"), ext: "mp3" },
+    { match: (format) => format.includes("wav"), ext: "wav" },
+    { match: (format) => format.includes("m4a") || format.includes("aac"), ext: "m4a" },
+    { match: (format) => format.includes("mp4"), ext: "mp4" },
+    { match: (format) => format.includes("flac"), ext: "flac" },
+];
+export function inferAudioExtension(format) {
+    const normalized = (format || "webm").toLowerCase();
+    const candidate = AUDIO_EXTENSIONS.find((entry) => entry.match(normalized));
+    return candidate?.ext ?? "webm";
+}
+export function sanitizeForFilename(segment, fallback) {
+    const value = segment && segment.length > 0 ? segment : fallback;
+    return value.replace(/[^a-zA-Z0-9-_]/g, "_").slice(0, 64);
+}
+//# sourceMappingURL=audio-utils.js.map

package/dist/server/server/agent/create-agent/create.d.ts

@@ -0,0 +1,91 @@
+import type { Logger } from "pino";
+import type { TerminalManager } from "../../../terminal/terminal-manager.js";
+import type { AgentWorktreeSetupContinuation, CreateOttoWorktreeWorkflowFn } from "../../worktree-session.js";
+import type { AgentAttachment, FirstAgentContext, GitSetupOptions } from "../../messages.js";
+import type { AgentManager, ManagedAgent } from "../agent-manager.js";
+import type { AgentSessionConfig } from "../agent-sdk-types.js";
+import type { AgentStorage } from "../agent-storage.js";
+import type { ProviderSnapshotManager } from "../provider-snapshot-manager.js";
+export interface CreateAgentSessionWorktreeResult {
+    sessionConfig: AgentSessionConfig;
+    setupContinuation?: AgentWorktreeSetupContinuation;
+    createdWorkspaceId?: string;
+}
+export interface CreateAgentCommandDependencies {
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    logger: Logger;
+    ottoHome?: string;
+    worktreesRoot?: string;
+    terminalManager?: TerminalManager | null;
+    providerSnapshotManager: ProviderSnapshotManager;
+    createOttoWorktree?: CreateOttoWorktreeWorkflowFn;
+    ensureWorkspaceForCreate?: EnsureWorkspaceForCreate;
+}
+export type EnsureWorkspaceForCreate = (cwd: string, firstAgentContext?: FirstAgentContext) => Promise<string>;
+export interface CreateAgentFromSessionInput {
+    kind: "session";
+    config: AgentSessionConfig;
+    workspaceId: string;
+    worktreeName?: string;
+    initialPrompt?: string;
+    clientMessageId?: string;
+    outputSchema?: Record<string, unknown>;
+    images?: Array<{
+        data: string;
+        mimeType: string;
+    }>;
+    attachments?: AgentAttachment[];
+    git?: GitSetupOptions;
+    labels: Record<string, string>;
+    env?: Record<string, string>;
+    provisionalTitle: string | null;
+    firstAgentContext: FirstAgentContext;
+    buildSessionConfig: (config: AgentSessionConfig, gitOptions?: GitSetupOptions, legacyWorktreeName?: string, firstAgentContext?: FirstAgentContext) => Promise<CreateAgentSessionWorktreeResult>;
+}
+export interface CreateAgentFromMcpInput {
+    kind: "mcp";
+    provider: string;
+    title: string;
+    initialPrompt?: string;
+    config?: Partial<AgentSessionConfig>;
+    cwd?: string;
+    workspaceId?: string;
+    thinking?: string;
+    features?: Record<string, unknown>;
+    labels?: Record<string, string>;
+    mode?: string;
+    unattended?: boolean;
+    promptFailure?: CreateAgentPromptFailureMode;
+    background: boolean;
+    notifyOnFinish: boolean;
+    internal?: boolean;
+    detached?: boolean;
+    callerAgentId?: string;
+    callerContext?: {
+        lockedCwd?: string;
+        allowCustomCwd?: boolean;
+        childAgentDefaultLabels?: Record<string, string>;
+    } | null;
+    worktree?: {
+        worktreeName?: string;
+        branchName?: string;
+        baseBranch?: string;
+        refName?: string;
+        action?: "branch-off" | "checkout";
+        githubPrNumber?: number;
+    };
+}
+export type CreateAgentCommandInput = CreateAgentFromSessionInput | CreateAgentFromMcpInput;
+export type CreateAgentPromptFailureMode = "throw" | "log" | "return-error";
+export interface CreateAgentCommandResult {
+    snapshot: ManagedAgent;
+    liveSnapshot: ManagedAgent;
+    background: boolean;
+    initialPromptStarted: boolean;
+    initialPromptError: unknown | null;
+}
+export type BoundCreateAgentCommand = (input: CreateAgentCommandInput) => Promise<CreateAgentCommandResult>;
+export declare function formatProviderModel(provider: string, model: string | null | undefined): string;
+export declare function createAgentCommand(dependencies: CreateAgentCommandDependencies, input: CreateAgentCommandInput): Promise<CreateAgentCommandResult>;
+//# sourceMappingURL=create.d.ts.map