@otto-code/server 0.5.0

package/dist/server/server/agent/providers/mock-slow-provider.d.ts

@@ -0,0 +1,14 @@
+import type { AgentCapabilityFlags, AgentClient, AgentLaunchContext, AgentPersistenceHandle, AgentProvider, AgentSession, AgentSessionConfig, FetchCatalogOptions, ProviderCatalog } from "../agent-sdk-types.js";
+export declare const MOCK_SLOW_PROVIDER_ID = "mock-slow";
+export declare class MockSlowProviderClient implements AgentClient {
+    readonly provider: AgentProvider;
+    readonly capabilities: AgentCapabilityFlags;
+    isAvailable(): Promise<boolean>;
+    fetchCatalog(_options: FetchCatalogOptions): Promise<ProviderCatalog>;
+    getDiagnostic(): Promise<{
+        diagnostic: string;
+    }>;
+    createSession(_config: AgentSessionConfig, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
+    resumeSession(_handle: AgentPersistenceHandle, _overrides?: Partial<AgentSessionConfig>, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
+}
+//# sourceMappingURL=mock-slow-provider.d.ts.map

package/dist/server/server/agent/providers/mock-slow-provider.js

@@ -0,0 +1,39 @@
+export const MOCK_SLOW_PROVIDER_ID = "mock-slow";
+const CAPABILITIES = {
+    supportsStreaming: false,
+    supportsSessionPersistence: false,
+    supportsDynamicModes: false,
+    supportsMcpServers: false,
+    supportsReasoningStream: false,
+    supportsToolInvocations: false,
+    supportsRewindConversation: false,
+    supportsRewindFiles: false,
+    supportsRewindBoth: false,
+};
+function neverResolves() {
+    return new Promise(() => { });
+}
+export class MockSlowProviderClient {
+    constructor() {
+        this.provider = MOCK_SLOW_PROVIDER_ID;
+        this.capabilities = CAPABILITIES;
+    }
+    async isAvailable() {
+        return process.env.OTTO_ENABLE_MOCK_SLOW === "true";
+    }
+    async fetchCatalog(_options) {
+        return neverResolves();
+    }
+    async getDiagnostic() {
+        return {
+            diagnostic: "Mock slow provider: dev-only. fetchCatalog() never resolves so the snapshot manager will time out.",
+        };
+    }
+    createSession(_config, _launchContext) {
+        throw new Error("Mock slow provider is dev-only; sessions are not supported.");
+    }
+    resumeSession(_handle, _overrides, _launchContext) {
+        throw new Error("Mock slow provider is dev-only; sessions are not supported.");
+    }
+}
+//# sourceMappingURL=mock-slow-provider.js.map

package/dist/server/server/agent/providers/openai-compat-agent.d.ts

@@ -0,0 +1,422 @@
+import type { Logger } from "pino";
+import type { AgentCapabilityFlags, AgentClient, AgentContextUsage, AgentFeature, AgentLaunchContext, AgentMode, AgentPersistenceHandle, AgentPermissionRequest, AgentPermissionResponse, AgentPermissionResult, AgentPersonalityUpdate, AgentPromptInput, AgentProvider, AgentRunOptions, AgentRunResult, AgentRuntimeInfo, AgentSession, AgentSessionConfig, AgentSlashCommand, AgentStreamEvent, FetchCatalogOptions, ProviderCatalog } from "../agent-sdk-types.js";
+import type { OttoToolCatalog } from "../tools/types.js";
+import { type OttoToolGroup } from "@otto-code/protocol/provider-config";
+import type { McpServerConfig } from "../agent-sdk-types.js";
+import type { ManagedProcessRegistry } from "../../managed-processes/managed-processes.js";
+import type { McpToolPermissionMode, ProviderCompactionConfig } from "@otto-code/protocol/provider-config";
+/**
+ * Native provider for OpenAI-compatible HTTP endpoints (LM Studio, Ollama,
+ * vLLM, llama.cpp server, gateways). The daemon talks to the endpoint
+ * directly — model discovery via GET {base}/models, streaming chat via
+ * POST {base}/chat/completions. No external agent binary is involved, so
+ * availability means "the server is reachable", not "a CLI is installed".
+ *
+ * Tool support: the daemon is the tool runtime. Function-calling models get a
+ * built-in coding toolset (read/list/grep/write/edit/shell) executed in the
+ * agent's cwd, with permission gating per mode.
+ */
+export declare const OPENAI_COMPAT_EXTENDS = "openai-compatible";
+/**
+ * True when a tool result carries no signal worth keeping in context — empty
+ * output, zero-match searches, or a bare timeout/no-op acknowledgement. These
+ * are elided wholesale during pruning. Kept conservative on purpose: anything
+ * ambiguous is left intact for the summarizer to judge.
+ */
+export declare function isUneventfulToolResult(content: string): boolean;
+export declare const OPENAI_COMPAT_MODES: AgentMode[];
+interface ToolCallPayload {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+type ChatMessage = 
+/**
+ * messageId is provider-internal bookkeeping for user messages: it ties the
+ * persisted conversation to the durable timeline's user_message items so
+ * revertConversation can find its truncation point. Stripped from the wire
+ * payload before requests — strict servers reject unknown message fields.
+ */
+{
+    role: "system" | "user";
+    content: string;
+    messageId?: string;
+    isCompactionSummary?: boolean;
+} | {
+    role: "assistant";
+    content: string;
+    tool_calls?: ToolCallPayload[];
+    reasoning?: string;
+} | {
+    role: "tool";
+    content: string;
+    tool_call_id: string;
+};
+export interface OpenAICompatAgentClientOptions {
+    logger?: Logger;
+    providerId: string;
+    label: string;
+    env?: Record<string, string>;
+    /** Otto tool groups to inject; undefined = all groups, [] = none. */
+    ottoToolGroups?: readonly OttoToolGroup[] | null;
+    /** Provider-level MCP servers; merged with per-agent config (per-agent wins). */
+    mcpServers?: Record<string, McpServerConfig> | null;
+    /** MCP permission strictness in acceptEdits mode; defaults to "always-ask". */
+    mcpToolPermissions?: McpToolPermissionMode | null;
+    /** Provider-level compaction defaults; per-agent feature values win. */
+    compaction?: ProviderCompactionConfig | null;
+    managedProcesses?: ManagedProcessRegistry | null;
+}
+export declare function normalizeOpenAICompatBaseUrl(value: string): string;
+export declare class OpenAICompatAgentClient implements AgentClient {
+    readonly provider: AgentProvider;
+    readonly capabilities: AgentCapabilityFlags;
+    private readonly logger?;
+    private readonly label;
+    private readonly env?;
+    private readonly ottoToolGroups?;
+    private readonly mcpServers;
+    private readonly mcpToolPermissions;
+    private readonly compaction;
+    private readonly managedProcesses;
+    constructor(options: OpenAICompatAgentClientOptions);
+    isAvailable(): Promise<boolean>;
+    fetchCatalog(options: FetchCatalogOptions): Promise<ProviderCatalog>;
+    getDiagnostic(): Promise<{
+        diagnostic: string;
+    }>;
+    listFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
+    createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext): Promise<AgentSession>;
+    resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
+}
+export declare class OpenAICompatAgentSession implements AgentSession {
+    readonly provider: AgentProvider;
+    readonly capabilities: AgentCapabilityFlags;
+    readonly id: string;
+    private readonly label;
+    private readonly env?;
+    private readonly logger?;
+    private readonly cwd;
+    private readonly listeners;
+    private readonly eventHistory;
+    private readonly messages;
+    private readonly pendingPermissions;
+    /** Otto's tool catalog, injected natively since this provider can't host an MCP client. */
+    private readonly ottoTools;
+    /** Which Otto tool groups to expose; null/undefined = all groups. */
+    private readonly ottoToolGroups?;
+    /** Daemon-hosted MCP client for the configured servers; null when none are configured. */
+    private readonly mcpManager;
+    private readonly mcpToolPermissions;
+    /** Connection failures already surfaced as timeline warnings. */
+    private mcpFailuresAnnounced;
+    private modelId;
+    private modeId;
+    private reasoningEffort;
+    /** Provider-level default for the auto_compact feature select. */
+    private autoCompactDefault;
+    /**
+     * Provider config hides the per-agent auto_compact select: the feature is
+     * omitted from `features` and persisted per-agent values are ignored, so
+     * the provider default always applies.
+     */
+    private autoCompactHidden;
+    /** Effective auto-compact setting: "off" or the trigger percentage. */
+    private autoCompact;
+    /**
+     * Loop protection: set when an auto-compaction failed or couldn't bring
+     * usage back under the threshold, so the next round doesn't immediately
+     * retry. Cleared once measured usage drops below the threshold again
+     * (rewind, manual /compact, model switch to a larger window).
+     */
+    private autoCompactDisarmed;
+    /** Recent-conversation budget kept verbatim through compaction. */
+    private keepRecentTokens;
+    private activeTurn;
+    /** Resolved context window for the active model; null until (or unless) discovered. */
+    private contextWindowMaxTokens;
+    /** Model the cached context window was resolved for; re-probe after a model switch. */
+    private contextWindowProbedModel;
+    /** Exact context size (prompt + completion tokens) measured by the server on the last round. */
+    private lastContextTokens;
+    /** Session config stored so the system prompt can be rebuilt after compaction. */
+    private readonly config;
+    constructor(options: {
+        providerId: string;
+        label: string;
+        env?: Record<string, string>;
+        config: AgentSessionConfig;
+        sessionId: string;
+        messages: ChatMessage[];
+        logger?: Logger;
+        ottoTools?: OttoToolCatalog | null;
+        ottoToolGroups?: readonly OttoToolGroup[] | null;
+        mcpServers?: Record<string, McpServerConfig> | null;
+        mcpToolPermissions?: McpToolPermissionMode;
+        compaction?: ProviderCompactionConfig | null;
+        managedProcesses?: ManagedProcessRegistry | null;
+    });
+    /**
+     * Rebuild replayable history from the current conversation so a resumed or
+     * rewound session still backfills its transcript, tool calls included.
+     * There is no separate durable store for tool traffic — `this.messages` is
+     * the only record that survives a resume, so tool_call items are
+     * reconstructed from each assistant message's `tool_calls` plus the
+     * matching "tool" result message. User messages keep their persisted
+     * messageId so the durable timeline and the provider conversation agree on
+     * rewind targets.
+     */
+    private rebuildEventHistory;
+    get features(): AgentFeature[];
+    setThinkingOption(thinkingOptionId: string | null): Promise<void>;
+    applyPersonality(update: AgentPersonalityUpdate): Promise<void>;
+    setFeature(featureId: string, value: unknown): Promise<void>;
+    /**
+     * Live re-apply of provider-level compaction config so settings edits reach
+     * running chats without a restart. Sessions still sitting on the old default
+     * follow the new default; an explicit per-agent pick is kept unless the
+     * selector is hidden, which always forces the default.
+     */
+    applyCompactionConfig(compaction: ProviderCompactionConfig | null): boolean;
+    private buildSystemPrompt;
+    /**
+     * Workflow doctrine for the preview/browser tool families. Tool descriptions
+     * alone don't reliably steer local models, so when both families are exposed
+     * the system prompt spells out the split: preview_start owns dev servers and
+     * their designated tab; browser_new_tab is for everything else.
+     */
+    private buildPreviewWorkflowPrompt;
+    private availableToolSpecs;
+    private toolNeedsApproval;
+    /**
+     * Otto's injected catalog (browser_*, preview_*, agent management, …) rendered
+     * as OpenAI function specs so the local model can call them. Excluded in
+     * read-only "plan" mode since they can take actions; builtin coding tools win
+     * on name collisions. Empty when no catalog was injected (e.g. tools disabled).
+     */
+    /** Whether an Otto tool's group is enabled for this provider (null groups = all). */
+    private isOttoToolGroupEnabled;
+    /**
+     * Connect the configured MCP servers before the first model round. A server
+     * that fails to connect is skipped — surfaced once as a timeline warning,
+     * never fatal to the session.
+     */
+    private ensureMcpReady;
+    /** Built-in slash commands plus MCP prompts from connected servers. */
+    listCommands(): Promise<AgentSlashCommand[]>;
+    /**
+     * Handle `/compact [instruction]` by summarizing the older conversation
+     * history while keeping the most recent slice verbatim, then splicing the
+     * summary in ahead of the retained tail. Runs entirely in-process — no
+     * external compaction service. Returns the turn's usage so the caller can
+     * attach it to turn_completed.
+     *
+     * Pipeline (adapted from oh-my-pi's compaction design):
+     *   1. Prune tool outputs (zero-LLM): elide uneventful results, truncate
+     *      oversized older ones, protect the newest.
+     *   2. Split at the keep-recent boundary: [system] + [older → summarize] +
+     *      [recent → keep verbatim].
+     *   3. Summarize the older region. If a prior compaction summary is present,
+     *      merge into it (incremental update) instead of re-summarizing a summary.
+     *   4. Rebuild: [system, summary, ...recent].
+     */
+    private handleCompact;
+    /**
+     * Auto-compaction check, run at turn start (before the new user message
+     * joins the conversation, so it always survives verbatim) and before every
+     * subsequent model round. Uses the freshest server-measured context size —
+     * the active turn's last round, falling back to the previous turn's final
+     * figure. Endpoints that report no context length never auto-compact:
+     * without a denominator there is no percentage (manual /compact still
+     * works).
+     *
+     * Loop protection: a compaction that fails or can't bring usage back under
+     * the threshold disarms the trigger. Without that, a conversation whose
+     * retained tail alone exceeds the threshold would re-summarize on every
+     * round, burning a model call each time for no reclaimed space. The trigger
+     * re-arms once measured usage drops below the threshold by other means
+     * (rewind, manual /compact, a model switch to a larger window) or when the
+     * user changes the auto-compact setting.
+     *
+     * Auto-compaction failures never fail the user's turn — the turn proceeds
+     * with the uncompacted conversation (interrupts still propagate).
+     */
+    private maybeAutoCompact;
+    /**
+     * Pre-summarization pruning (zero-LLM). Mutates the message array in place:
+     * elides uneventful tool results everywhere, then truncates oversized tool
+     * results older than the protected-recent window to head + tail. Structure is
+     * never changed (only tool `content`), so tool_call ordering stays valid.
+     */
+    private pruneToolOutputs;
+    /**
+     * Index of the first message (after the system prompt at 0) to keep verbatim
+     * through compaction: walk newest → oldest accumulating token estimates until
+     * the keep-recent budget is exceeded, then advance past any leading tool
+     * results so the retained tail never starts with a tool message orphaned from
+     * its assistant tool_calls. Returns messages.length when the whole
+     * conversation is older than the budget (summarize everything, keep none).
+     */
+    private computeCompactionKeepFromIndex;
+    /**
+     * POST a non-streaming chat completion for compaction and return the assistant
+     * text plus raw usage. Throws on transport failure or an empty response.
+     */
+    private runCompactionCompletion;
+    /**
+     * Local estimate of the full next-request context: conversation messages
+     * (including the system prompt) plus the tool schemas that are re-sent with
+     * every request. Char-based, so it's approximate — the next real turn's
+     * server-measured usage replaces it.
+     */
+    private estimateFullContextTokens;
+    /**
+     * Serialize the given conversation messages into a text blob suitable for a
+     * compaction prompt. Tool calls are summarized rather than included verbatim
+     * to keep the payload manageable.
+     */
+    private serializeConversationForCompaction;
+    /**
+     * System prompt for a fresh compaction summary. The older conversation is
+     * summarized while recent messages are kept verbatim, so this summary becomes
+     * the model's memory of the distant past — it must preserve exact references,
+     * not paraphrase them away. Modeled on oh-my-pi's structured handoff format.
+     */
+    private buildCompactionSystemPrompt;
+    /**
+     * System prompt for an incremental compaction: merge newer messages into an
+     * existing summary rather than re-summarizing a summary (which degrades fast
+     * across repeated compacts). The prior summary arrives in <previous-summary>
+     * tags and the newer messages in <new-messages> tags.
+     */
+    private buildCompactionUpdateSystemPrompt;
+    /**
+     * When the typed prompt is `/mcp_{server}_{prompt} args`, resolve it via
+     * prompts/get and feed the resolved text to the model. The remainder of the
+     * line maps to the prompt's first declared argument (multi-argument prompts
+     * receive only that one). Any resolution failure falls back to sending the
+     * raw text as a plain prompt, matching the opencode provider.
+     */
+    private resolveMcpPromptText;
+    /**
+     * MCP tools rendered as OpenAI function specs under namespaced
+     * mcp_{server}_{tool} names. Hard-excluded in read-only "plan" mode — MCP
+     * tools are opaque and may take actions regardless of what they claim.
+     */
+    private buildMcpToolPayload;
+    private buildOttoToolPayload;
+    run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
+    startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{
+        turnId: string;
+    }>;
+    private executeTurn;
+    private runToolLoop;
+    private parseToolCallArgs;
+    private executeToolCall;
+    /**
+     * MCP tools are opaque — the daemon cannot know whether one is destructive.
+     * default mode always asks; acceptEdits asks unless the provider opted into
+     * "trust-read-only" AND the server self-declares readOnlyHint (that
+     * annotation is untrusted, so it never skips prompts in default mode);
+     * bypassPermissions auto-approves like everything else. Plan mode never
+     * reaches here — MCP tools are excluded from the payload entirely.
+     */
+    private mcpToolNeedsApproval;
+    private executeMcpToolCall;
+    /**
+     * Otto tools skip prompts only when classified read-only; "interact" tools
+     * are auto-approved in acceptEdits like file edits, and "execute" tools
+     * always prompt outside bypassPermissions. CLI providers get this gating
+     * from their own permission system in front of the MCP client — here the
+     * daemon is the runtime, so it prompts itself.
+     * See openai-compat-otto-tool-permissions.ts.
+     */
+    private ottoToolNeedsApproval;
+    private executeOttoToolCall;
+    private emitToolItem;
+    private requestPermission;
+    private streamCompletion;
+    private applyStreamPayload;
+    /**
+     * Emit a usage_updated event so the agent manager updates agent.lastUsage
+     * and pushes the context usage to the client immediately, rather than
+     * waiting for turn_completed at the end of the entire tool loop.
+     *
+     * resolveContextWindowMaxTokens() is async (it may probe the endpoint) and
+     * this runs on the hot streaming path, so only the already-cached value is
+     * included. The event is always emitted regardless — the client and agent
+     * manager handle partial usage snapshots correctly.
+     */
+    private emitStreamUsageUpdated;
+    /**
+     * A turn can end (interrupt or failure) between an assistant message's
+     * tool_calls and their tool results — e.g. the user interrupts during call
+     * #1 of 3. Strict OpenAI-compatible servers reject the next request over
+     * such a conversation with a 400, so append synthetic results for the
+     * unanswered calls. Resume gets the equivalent repair from
+     * sanitizeRestoredMessages; this covers the live conversation.
+     */
+    private repairDanglingToolCalls;
+    private settleTurnFailure;
+    private failPendingPermissions;
+    private resolveModel;
+    /**
+     * Best-effort context window discovery, cached per model. Checks the
+     * standard /v1/models listing for extended context-length fields first,
+     * then LM Studio's native /api/v0/models listing (same host, /v1 stripped),
+     * which reports the loaded instance's actual window. Servers that expose
+     * neither leave the meter without a max — never an error.
+     */
+    private resolveContextWindowMaxTokens;
+    /**
+     * Promote the raw per-request token counts into AgentUsage. The final
+     * round's prompt already contains the full conversation, so prompt +
+     * completion tokens is the context content size as the server measured it.
+     */
+    private buildTurnUsage;
+    /**
+     * Context makeup for the client's popup. The daemon owns this provider's
+     * entire prompt (system message, tool schemas, conversation), so the split
+     * is computed locally: char-based estimates per category, scaled so the
+     * counted total matches the server-measured context size when one exists.
+     */
+    getContextUsage(): Promise<AgentContextUsage | null>;
+    subscribe(callback: (event: AgentStreamEvent) => void): () => void;
+    streamHistory(): AsyncGenerator<AgentStreamEvent>;
+    getRuntimeInfo(): Promise<AgentRuntimeInfo>;
+    getAvailableModes(): Promise<AgentMode[]>;
+    getCurrentMode(): Promise<string | null>;
+    setMode(modeId: string): Promise<void>;
+    getPendingPermissions(): AgentPermissionRequest[];
+    respondToPermission(requestId: string, response: AgentPermissionResponse): Promise<AgentPermissionResult | void>;
+    describePersistence(): AgentPersistenceHandle | null;
+    setModel(modelId: string | null): Promise<void>;
+    /**
+     * Rewind the daemon-owned conversation to just before the given user
+     * message. The full conversation persists (no message cap), so any
+     * previous user message is a valid rewind target — the not-found error
+     * below only fires for a truly unknown messageId.
+     */
+    revertConversation(input: {
+        messageId: string;
+    }): Promise<void>;
+    interrupt(): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Retain what streamHistory replays: user messages, assistant messages
+     * (coalesced per messageId so streamed deltas don't accumulate one event
+     * each), reasoning (coalesced per contiguous block), and tool calls
+     * (coalesced per callId so a call's running → completed/failed/canceled
+     * transitions collapse to its latest status instead of replaying every
+     * intermediate state). Usage and permission events aren't part of the
+     * displayed transcript and are dropped. Copies are stored so coalescing
+     * never mutates an event a listener already received.
+     */
+    private retainForHistory;
+    private emit;
+}
+export {};
+//# sourceMappingURL=openai-compat-agent.d.ts.map