@otto-code/server 0.5.0

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

@@ -0,0 +1,25 @@
+export type NormalizedToolCallStatus = "running" | "completed" | "failed" | "canceled";
+export declare function normalizeToolCallStatus(rawStatus: string | undefined | null, error: unknown, output: unknown): NormalizedToolCallStatus;
+interface ReadChunkLike {
+    text?: string;
+    content?: string;
+    output?: string;
+}
+export declare function nonEmptyString(value: unknown): string | undefined;
+export declare function extractCodexShellOutput(value: string | undefined): string | undefined;
+export declare function extractCodexTerminalSessionId(value: string | undefined): string | undefined;
+export declare function flattenReadContent<Chunk extends ReadChunkLike>(value: string | Chunk | Chunk[] | undefined): string | undefined;
+export interface StrippedReadContent {
+    content: string;
+    startLine?: number;
+}
+export declare function stripReadLineNumberGutter(content: string | undefined): StrippedReadContent | undefined;
+export declare function truncateDiffText(text: string | undefined, maxChars?: number): string | undefined;
+export declare function coerceToolCallId(params: {
+    providerPrefix: string;
+    rawCallId: string | null | undefined;
+    toolName: string;
+    input: unknown;
+}): string;
+export {};
+//# sourceMappingURL=tool-call-mapper-utils.d.ts.map

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

@@ -0,0 +1,208 @@
+const FAILED_STATUS_VOCAB = new Set([
+    "failed",
+    "failure",
+    "error",
+    "errored",
+    "rejected",
+    "denied",
+]);
+const CANCELED_STATUS_VOCAB = new Set(["canceled", "cancelled", "interrupted", "aborted"]);
+const COMPLETED_STATUS_VOCAB = new Set(["completed", "complete", "done", "success", "succeeded"]);
+export function normalizeToolCallStatus(rawStatus, error, output) {
+    if (error !== undefined && error !== null) {
+        return "failed";
+    }
+    if (typeof rawStatus === "string") {
+        const normalized = rawStatus.trim().toLowerCase();
+        if (normalized.length > 0) {
+            if (FAILED_STATUS_VOCAB.has(normalized)) {
+                return "failed";
+            }
+            if (CANCELED_STATUS_VOCAB.has(normalized)) {
+                return "canceled";
+            }
+            if (COMPLETED_STATUS_VOCAB.has(normalized)) {
+                return "completed";
+            }
+            return "running";
+        }
+    }
+    return output !== null && output !== undefined ? "completed" : "running";
+}
+export function nonEmptyString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+const CODEX_SHELL_ENVELOPE_HEADER_LINES = new Set([
+    "chunk id:",
+    "wall time:",
+    "process exited with code",
+    "original token count:",
+]);
+function isCodexShellEnvelopeHeaderLine(line) {
+    const normalized = line.trim().toLowerCase();
+    for (const prefix of CODEX_SHELL_ENVELOPE_HEADER_LINES) {
+        if (normalized.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return false;
+}
+function looksLikeCodexShellEnvelope(lines) {
+    if (lines.length === 0) {
+        return false;
+    }
+    const first = lines[0]?.trim().toLowerCase() ?? "";
+    if (!first.startsWith("chunk id:")) {
+        return false;
+    }
+    const headerWindow = lines.slice(0, 8).map((line) => line.trim().toLowerCase());
+    const hasWallTime = headerWindow.some((line) => line.startsWith("wall time:"));
+    const hasExitCode = headerWindow.some((line) => line.startsWith("process exited with code"));
+    return hasWallTime && hasExitCode;
+}
+export function extractCodexShellOutput(value) {
+    const text = nonEmptyString(value);
+    if (!text) {
+        return undefined;
+    }
+    const normalized = text.replace(/\r\n/g, "\n");
+    const lines = normalized.split("\n");
+    if (!looksLikeCodexShellEnvelope(lines)) {
+        return text;
+    }
+    const outputLineIndex = lines.findIndex((line) => line.trim() === "Output:");
+    if (outputLineIndex >= 0) {
+        return nonEmptyString(lines.slice(outputLineIndex + 1).join("\n"));
+    }
+    let firstBodyLineIndex = -1;
+    for (let index = 1; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        if (!isCodexShellEnvelopeHeaderLine(line)) {
+            firstBodyLineIndex = index;
+            break;
+        }
+    }
+    if (firstBodyLineIndex === -1) {
+        return undefined;
+    }
+    return nonEmptyString(lines.slice(firstBodyLineIndex).join("\n"));
+}
+export function extractCodexTerminalSessionId(value) {
+    const text = nonEmptyString(value);
+    if (!text) {
+        return undefined;
+    }
+    const match = text.match(/process running with session id\s+([A-Za-z0-9._:-]+)/i);
+    return nonEmptyString(match?.[1]);
+}
+export function flattenReadContent(value) {
+    if (typeof value === "string") {
+        return nonEmptyString(value);
+    }
+    if (!value) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((chunk) => nonEmptyString(chunk.text) ??
+            nonEmptyString(chunk.content) ??
+            nonEmptyString(chunk.output))
+            .filter((part) => typeof part === "string");
+        return parts.length > 0 ? parts.join("\n") : undefined;
+    }
+    return (nonEmptyString(value.text) ?? nonEmptyString(value.content) ?? nonEmptyString(value.output));
+}
+// Claude's Read tool returns `cat -n`-style content: each line prefixed with a
+// right-aligned line number and a tab (`␣␣␣1\timport ...`). Other providers
+// return raw source. We strip the gutter here so `read.content` is uniformly
+// raw source across providers, and surface the first line number as `offset`
+// so the client can rebuild the gutter itself. Guarded tightly (first line must
+// match, near-total match ratio, strictly sequential numbering) so real source
+// is never mistaken for a gutter.
+const READ_GUTTER_LINE = /^\s*(\d+)\t(.*)$/;
+export function stripReadLineNumberGutter(content) {
+    const text = nonEmptyString(content);
+    if (!text) {
+        return undefined;
+    }
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const stripped = [];
+    let nonEmpty = 0;
+    let matched = 0;
+    let startLine;
+    let prevNumber;
+    let sequential = true;
+    let firstNonEmptyMatched = false;
+    let sawNonEmpty = false;
+    for (const line of lines) {
+        if (line.length === 0) {
+            stripped.push(line);
+            continue;
+        }
+        nonEmpty += 1;
+        const match = line.match(READ_GUTTER_LINE);
+        if (!match) {
+            if (!sawNonEmpty) {
+                return undefined;
+            }
+            stripped.push(line);
+            sawNonEmpty = true;
+            continue;
+        }
+        if (!sawNonEmpty) {
+            firstNonEmptyMatched = true;
+        }
+        sawNonEmpty = true;
+        matched += 1;
+        const lineNumber = Number.parseInt(match[1], 10);
+        if (startLine === undefined) {
+            startLine = lineNumber;
+        }
+        if (prevNumber !== undefined && lineNumber !== prevNumber + 1) {
+            sequential = false;
+        }
+        prevNumber = lineNumber;
+        stripped.push(match[2]);
+    }
+    if (!firstNonEmptyMatched || !sequential || nonEmpty === 0) {
+        return undefined;
+    }
+    // Sequential numbering from the first line is already a strong signal; the
+    // ratio only rejects source that has a couple of coincidental matches.
+    if (matched / nonEmpty < 0.5) {
+        return undefined;
+    }
+    return { content: stripped.join("\n"), startLine };
+}
+export function truncateDiffText(text, maxChars = 12000) {
+    if (typeof text !== "string") {
+        return undefined;
+    }
+    if (text.length <= maxChars) {
+        return text;
+    }
+    const truncatedCount = text.length - maxChars;
+    return `${text.slice(0, maxChars)}\n...[truncated ${truncatedCount} chars]`;
+}
+function hashText(value) {
+    let hash = 0;
+    for (let i = 0; i < value.length; i += 1) {
+        hash = (hash << 5) - hash + value.charCodeAt(i);
+        hash |= 0;
+    }
+    return Math.abs(hash).toString(36);
+}
+export function coerceToolCallId(params) {
+    if (typeof params.rawCallId === "string" && params.rawCallId.trim().length > 0) {
+        return params.rawCallId;
+    }
+    let serialized = "";
+    try {
+        serialized = JSON.stringify(params.input) ?? "";
+    }
+    catch {
+        serialized = String(params.input);
+    }
+    return `${params.providerPrefix}-${hashText(`${params.toolName}:${serialized}`)}`;
+}
+//# sourceMappingURL=tool-call-mapper-utils.js.map

package/dist/server/server/agent/providers/trae-acp-agent.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from "pino";
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+interface TraeACPAgentClientOptions {
+    logger: Logger;
+    command: [string, ...string[]];
+    env?: Record<string, string>;
+    providerId?: string;
+    label?: string;
+    providerParams?: unknown;
+}
+export declare class TraeACPAgentClient extends GenericACPAgentClient {
+    constructor(options: TraeACPAgentClientOptions);
+}
+export {};
+//# sourceMappingURL=trae-acp-agent.d.ts.map

package/dist/server/server/agent/providers/trae-acp-agent.js

@@ -0,0 +1,18 @@
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+const TRAE_INITIAL_COMMANDS_WAIT_TIMEOUT_MS = 10000;
+export class TraeACPAgentClient extends GenericACPAgentClient {
+    constructor(options) {
+        super({
+            logger: options.logger,
+            command: options.command,
+            env: options.env,
+            providerId: options.providerId,
+            label: options.label,
+            providerParams: options.providerParams,
+            // traecli publishes slash commands and skills asynchronously via available_commands_update.
+            waitForInitialCommands: true,
+            initialCommandsWaitTimeoutMs: TRAE_INITIAL_COMMANDS_WAIT_TIMEOUT_MS,
+        });
+    }
+}
+//# sourceMappingURL=trae-acp-agent.js.map

package/dist/server/server/agent/recordings-debug.d.ts

@@ -0,0 +1,3 @@
+export declare function isOttoDictationDebugEnabled(): boolean;
+export declare function resolveRecordingsDebugDir(explicitEnvVarName: string): string | null;
+//# sourceMappingURL=recordings-debug.d.ts.map

package/dist/server/server/agent/recordings-debug.js

@@ -0,0 +1,19 @@
+import { resolve } from "path";
+function isTruthyEnv(value) {
+    const normalized = (value ?? "").trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+export function isOttoDictationDebugEnabled() {
+    return isTruthyEnv(process.env.OTTO_DICTATION_DEBUG);
+}
+export function resolveRecordingsDebugDir(explicitEnvVarName) {
+    const explicit = process.env[explicitEnvVarName];
+    if (explicit && explicit.trim()) {
+        return resolve(explicit.trim());
+    }
+    if (!isOttoDictationDebugEnabled()) {
+        return null;
+    }
+    return resolve(process.cwd(), ".debug/recordings");
+}
+//# sourceMappingURL=recordings-debug.js.map

package/dist/server/server/agent/rewind/rewind.d.ts

@@ -0,0 +1,10 @@
+import type { AgentSession } from "../agent-sdk-types.js";
+export type RewindMode = "conversation" | "files" | "both";
+export declare class RewindCapabilityError extends Error {
+    constructor(mode: RewindMode);
+}
+export declare function invokeRewindCapability(session: AgentSession, input: {
+    messageId: string;
+    mode: RewindMode;
+}): Promise<void>;
+//# sourceMappingURL=rewind.d.ts.map

package/dist/server/server/agent/rewind/rewind.js

@@ -0,0 +1,29 @@
+export class RewindCapabilityError extends Error {
+    constructor(mode) {
+        super(`Provider does not support rewinding ${mode}`);
+        this.name = "RewindCapabilityError";
+    }
+}
+export async function invokeRewindCapability(session, input) {
+    switch (input.mode) {
+        case "conversation":
+            if (!session.capabilities.supportsRewindConversation || !session.revertConversation) {
+                throw new RewindCapabilityError(input.mode);
+            }
+            await session.revertConversation({ messageId: input.messageId });
+            return;
+        case "files":
+            if (!session.capabilities.supportsRewindFiles || !session.revertFiles) {
+                throw new RewindCapabilityError(input.mode);
+            }
+            await session.revertFiles({ messageId: input.messageId });
+            return;
+        case "both":
+            if (!session.capabilities.supportsRewindBoth || !session.revertBoth) {
+                throw new RewindCapabilityError(input.mode);
+            }
+            await session.revertBoth({ messageId: input.messageId });
+            return;
+    }
+}
+//# sourceMappingURL=rewind.js.map

package/dist/server/server/agent/rewind/test-rewind-session.d.ts

@@ -0,0 +1,48 @@
+import type { AgentCapabilityFlags, AgentPermissionRequest, AgentPermissionResponse, AgentPersistenceHandle, AgentProvider, AgentRunResult, AgentSession, AgentStreamEvent, AgentTimelineItem } from "../agent-sdk-types.js";
+export declare const REWIND_TEST_CAPABILITIES: AgentCapabilityFlags;
+export interface RecordedRewind {
+    mode: "conversation" | "files" | "both";
+    messageId: string;
+}
+export declare class FakeRewindSession implements AgentSession {
+    private readonly waitBeforeHistory?;
+    readonly provider: AgentProvider;
+    readonly id = "fake-rewind-session";
+    readonly capabilities: AgentCapabilityFlags;
+    readonly recordedRewinds: RecordedRewind[];
+    aborted: boolean;
+    historyReadCount: number;
+    history: AgentTimelineItem[];
+    private subscribers;
+    private activeTurnId;
+    constructor(waitBeforeHistory?: (() => Promise<void>) | undefined);
+    run(): Promise<AgentRunResult>;
+    startTurn(): Promise<{
+        turnId: string;
+    }>;
+    subscribe(callback: (event: AgentStreamEvent) => void): () => void;
+    streamHistory(): AsyncGenerator<AgentStreamEvent>;
+    getRuntimeInfo(): Promise<{
+        provider: string;
+        sessionId: string;
+    }>;
+    getAvailableModes(): Promise<never[]>;
+    getCurrentMode(): Promise<null>;
+    setMode(): Promise<void>;
+    getPendingPermissions(): AgentPermissionRequest[];
+    respondToPermission(_requestId: string, _response: AgentPermissionResponse): Promise<void>;
+    describePersistence(): AgentPersistenceHandle;
+    interrupt(): Promise<void>;
+    close(): Promise<void>;
+    revertConversation(input: {
+        messageId: string;
+    }): Promise<void>;
+    revertFiles(input: {
+        messageId: string;
+    }): Promise<void>;
+    revertBoth(input: {
+        messageId: string;
+    }): Promise<void>;
+    private emit;
+}
+//# sourceMappingURL=test-rewind-session.d.ts.map

package/dist/server/server/agent/rewind/test-rewind-session.js

@@ -0,0 +1,88 @@
+export const REWIND_TEST_CAPABILITIES = {
+    supportsStreaming: true,
+    supportsSessionPersistence: true,
+    supportsDynamicModes: false,
+    supportsMcpServers: false,
+    supportsReasoningStream: false,
+    supportsToolInvocations: false,
+    supportsRewindConversation: true,
+    supportsRewindFiles: true,
+    supportsRewindBoth: true,
+};
+export class FakeRewindSession {
+    constructor(waitBeforeHistory) {
+        this.waitBeforeHistory = waitBeforeHistory;
+        this.provider = "claude";
+        this.id = "fake-rewind-session";
+        this.capabilities = REWIND_TEST_CAPABILITIES;
+        this.recordedRewinds = [];
+        this.aborted = false;
+        this.historyReadCount = 0;
+        this.history = [{ type: "user_message", text: "before", messageId: "message-1" }];
+        this.subscribers = new Set();
+        this.activeTurnId = null;
+    }
+    async run() {
+        return { sessionId: this.id, finalText: "", timeline: [] };
+    }
+    async startTurn() {
+        this.aborted = false;
+        this.activeTurnId = "turn-1";
+        queueMicrotask(() => {
+            this.emit({ type: "turn_started", provider: this.provider, turnId: "turn-1" });
+        });
+        return { turnId: "turn-1" };
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => this.subscribers.delete(callback);
+    }
+    async *streamHistory() {
+        this.historyReadCount += 1;
+        await this.waitBeforeHistory?.();
+        for (const item of this.history) {
+            yield { type: "timeline", provider: this.provider, item };
+        }
+    }
+    async getRuntimeInfo() {
+        return { provider: this.provider, sessionId: this.id };
+    }
+    async getAvailableModes() {
+        return [];
+    }
+    async getCurrentMode() {
+        return null;
+    }
+    async setMode() { }
+    getPendingPermissions() {
+        return [];
+    }
+    async respondToPermission(_requestId, _response) { }
+    describePersistence() {
+        return { provider: this.provider, sessionId: this.id };
+    }
+    async interrupt() {
+        this.aborted = true;
+        if (this.activeTurnId) {
+            const turnId = this.activeTurnId;
+            this.activeTurnId = null;
+            this.emit({ type: "turn_canceled", provider: this.provider, reason: "interrupted", turnId });
+        }
+    }
+    async close() { }
+    async revertConversation(input) {
+        this.recordedRewinds.push({ mode: "conversation", messageId: input.messageId });
+    }
+    async revertFiles(input) {
+        this.recordedRewinds.push({ mode: "files", messageId: input.messageId });
+    }
+    async revertBoth(input) {
+        this.recordedRewinds.push({ mode: "both", messageId: input.messageId });
+    }
+    emit(event) {
+        for (const subscriber of this.subscribers) {
+            subscriber(event);
+        }
+    }
+}
+//# sourceMappingURL=test-rewind-session.js.map

package/dist/server/server/agent/runtime-mcp-config.d.ts

@@ -0,0 +1,14 @@
+import type { AgentSessionConfig } from "./agent-sdk-types.js";
+export declare function stripInternalOttoMcpServer(config: AgentSessionConfig): AgentSessionConfig;
+export declare function withRuntimeOttoMcpServer(params: {
+    config: AgentSessionConfig;
+    agentId: string;
+    mcpBaseUrl: string | null;
+    /**
+     * Capability token authenticating the injected connection to the daemon's
+     * Agent MCP endpoint. The daemon password is gated off this route, so without
+     * this header the agent's MCP requests are rejected when a password is set.
+     */
+    mcpAuthToken: string | null;
+}): AgentSessionConfig;
+//# sourceMappingURL=runtime-mcp-config.d.ts.map

package/dist/server/server/agent/runtime-mcp-config.js

@@ -0,0 +1,53 @@
+const OTTO_MCP_SERVER_NAME = "otto";
+const OTTO_MCP_PATHNAME = "/mcp/agents";
+export function stripInternalOttoMcpServer(config) {
+    const mcpServers = config.mcpServers;
+    if (!mcpServers) {
+        return config;
+    }
+    const ottoServer = mcpServers[OTTO_MCP_SERVER_NAME];
+    if (!ottoServer || !isInternalOttoMcpServer(ottoServer)) {
+        return config;
+    }
+    const nextMcpServers = { ...mcpServers };
+    delete nextMcpServers[OTTO_MCP_SERVER_NAME];
+    const next = { ...config };
+    if (Object.keys(nextMcpServers).length > 0) {
+        next.mcpServers = nextMcpServers;
+    }
+    else {
+        delete next.mcpServers;
+    }
+    return next;
+}
+export function withRuntimeOttoMcpServer(params) {
+    const storedConfig = stripInternalOttoMcpServer(params.config);
+    if (!params.mcpBaseUrl || storedConfig.mcpServers?.[OTTO_MCP_SERVER_NAME]) {
+        return storedConfig;
+    }
+    return {
+        ...storedConfig,
+        mcpServers: {
+            [OTTO_MCP_SERVER_NAME]: {
+                type: "http",
+                url: `${params.mcpBaseUrl}?callerAgentId=${params.agentId}`,
+                ...(params.mcpAuthToken
+                    ? { headers: { Authorization: `Bearer ${params.mcpAuthToken}` } }
+                    : {}),
+            },
+            ...storedConfig.mcpServers,
+        },
+    };
+}
+function isInternalOttoMcpServer(config) {
+    if (config.type !== "http" && config.type !== "sse") {
+        return false;
+    }
+    try {
+        return new URL(config.url).pathname === OTTO_MCP_PATHNAME;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=runtime-mcp-config.js.map

package/dist/server/server/agent/structured-generation-providers.d.ts

@@ -0,0 +1,29 @@
+import type { AgentProvider } from "./agent-sdk-types.js";
+import type { StructuredGenerationProvider } from "./agent-response-loop.js";
+import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
+export interface StructuredGenerationDaemonConfig {
+    metadataGeneration?: {
+        providers?: Array<{
+            provider: string;
+            model?: string;
+            thinkingOptionId?: string;
+        }>;
+    };
+}
+export interface StructuredGenerationProviderIdentifier {
+    modelSubstring: string;
+    thinkingOptionId?: string;
+}
+export declare const DEFAULT_STRUCTURED_GENERATION_PROVIDERS: readonly StructuredGenerationProviderIdentifier[];
+export interface ResolveStructuredGenerationProvidersOptions {
+    cwd: string;
+    providerSnapshotManager: Pick<ProviderSnapshotManager, "listProviders">;
+    daemonConfig?: StructuredGenerationDaemonConfig | null;
+    currentSelection?: {
+        provider?: AgentProvider | null;
+        model?: string | null;
+        thinkingOptionId?: string | null;
+    };
+}
+export declare function resolveStructuredGenerationProviders(options: ResolveStructuredGenerationProvidersOptions): Promise<StructuredGenerationProvider[]>;
+//# sourceMappingURL=structured-generation-providers.d.ts.map