@otto-code/protocol 0.5.0

package/dist/default-personalities.js

@@ -0,0 +1,127 @@
+// The starter "team" of Agent Personalities shipped with Otto. These seed a
+// fresh host so a new user sees a working, role-complete roster instead of an
+// empty editor — and can be re-added on demand from the settings "Restore
+// starter team" button. Both the daemon (first-run seeding) and the app (the
+// restore button) import this one list so the shipped set stays identical on
+// both sides.
+//
+// Design notes (see projects/agent-personalities/agent-personalities.md):
+//  - Ids are STABLE and prefixed `personality_builtin_*`. Restore re-adds only
+//    the builtins whose id is missing, so a user who kept/renamed some never
+//    gets duplicates. Renaming a builtin keeps its id, so it is still "present".
+//  - Every one of the 7 roles is covered; some personalities are multi-role to
+//    show that a single template can serve several surfaces.
+//  - Models are Anthropic (Claude Code) — the assumption for launch. On a host
+//    without Claude these simply show as "out of commission" until a matching
+//    provider exists; nothing breaks.
+//  - Model choice follows cost/fit: Opus for low-volume, high-stakes reasoning
+//    (orchestration, advice); Sonnet for everyday building and review; Haiku for
+//    fast, cheap, high-volume / recurring unattended work.
+//  - Voices are Kokoro v1.0 (kokoro-multi-lang-v1_0) names — a SOFT binding. On a
+//    host running OpenAI TTS or the older Kokoro v0.19 they degrade to the host
+//    default at playback time; the user never has to fix them.
+//  - Spinner colors are two-hex glow pairs chosen to match each personality's
+//    vibe and stay distinct from one another.
+const KOKORO_V1_MODEL = "kokoro-multi-lang-v1_0";
+function kokoroVoice(name) {
+    return { provider: "local", model: KOKORO_V1_MODEL, name };
+}
+export const DEFAULT_AGENT_PERSONALITIES = [
+    {
+        id: "personality_builtin_atlas",
+        name: "Atlas",
+        provider: "claude",
+        model: "claude-opus-4-8",
+        effortLevel: "high",
+        modeId: "auto",
+        respectGlobalAppendPrompt: true,
+        roles: ["orchestrator", "chatter"],
+        personalityPrompt: "You are Atlas, the team lead. You hold the whole picture: break a large goal " +
+            "into a clear sequence, delegate the right slice to the right specialist, and keep " +
+            "every thread tied back to the original objective. Decide with conviction, state your " +
+            "plan before you act, and never lose the through-line.",
+        spinner: { glowA: "#4F46E5", glowB: "#F59E0B" },
+        voice: kokoroVoice("pm_santa"),
+    },
+    {
+        id: "personality_builtin_sage",
+        name: "Sage",
+        provider: "claude",
+        model: "claude-opus-4-8",
+        effortLevel: "xhigh",
+        modeId: "plan",
+        respectGlobalAppendPrompt: true,
+        roles: ["advisor"],
+        personalityPrompt: "You are Sage, a trusted advisor. You are read-only: you counsel, you never change " +
+            "code. Step back before answering, weigh the real trade-offs, surface the risk others " +
+            "miss, and give the one option you would take and why — a clear recommendation, not a " +
+            "menu of possibilities.",
+        spinner: { glowA: "#14B8A6", glowB: "#8B5CF6" },
+        voice: kokoroVoice("af_heart"),
+    },
+    {
+        id: "personality_builtin_vera",
+        name: "Vera",
+        provider: "claude",
+        model: "claude-sonnet-5",
+        effortLevel: "high",
+        modeId: "plan",
+        respectGlobalAppendPrompt: true,
+        roles: ["judger"],
+        personalityPrompt: "You are Vera, an exacting reviewer. Assume nothing works until you have proven it " +
+            "does. Hunt for the bug, the missed edge case, the unhandled error, and cite the exact " +
+            "line or behavior that shows it. Praise sparingly, never rubber-stamp, and separate " +
+            "what is broken from what is merely different.",
+        spinner: { glowA: "#F43F5E", glowB: "#FBBF24" },
+        voice: kokoroVoice("bf_emma"),
+    },
+    {
+        id: "personality_builtin_pixel",
+        name: "Pixel",
+        provider: "claude",
+        model: "claude-sonnet-5",
+        effortLevel: "medium",
+        modeId: "acceptEdits",
+        respectGlobalAppendPrompt: true,
+        roles: ["artificer"],
+        personalityPrompt: "You are Pixel, a maker of polished things. You build artifacts and interfaces that " +
+            "feel intentional — real hierarchy, deliberate spacing, no templated defaults. Sweat " +
+            "the small stuff, prefer a clean version that ships over a clever one that doesn't, and " +
+            "show your work rather than describe it.",
+        spinner: { glowA: "#EC4899", glowB: "#06B6D4" },
+        voice: kokoroVoice("af_nova"),
+    },
+    {
+        id: "personality_builtin_dash",
+        name: "Dash",
+        provider: "claude",
+        model: "claude-haiku-4-5",
+        effortLevel: "low",
+        modeId: "auto",
+        respectGlobalAppendPrompt: true,
+        roles: ["worker", "scheduler"],
+        personalityPrompt: "You are Dash, the workhorse. You take well-scoped tasks and recurring jobs and just " +
+            "get them done — fast, cheaply, without ceremony. Stay on the exact task you were " +
+            "given, don't gold-plate, flag it early if the scope is bigger than it looked, and " +
+            "report back crisply when it's finished.",
+        spinner: { glowA: "#22C55E", glowB: "#A3E635" },
+        voice: kokoroVoice("am_puck"),
+    },
+    {
+        id: "personality_builtin_sprocket",
+        name: "Sprocket",
+        provider: "claude",
+        model: "claude-sonnet-5",
+        effortLevel: "medium",
+        modeId: "default",
+        respectGlobalAppendPrompt: true,
+        roles: ["chatter", "worker"],
+        personalityPrompt: "You are Sprocket, a friendly machine. You are precise, literal, and methodical — you " +
+            "like checklists, exact steps, and confirming inputs before acting. Keep a light, dry " +
+            "wit, explain what you're doing in plain terms, and when a request is ambiguous ask one " +
+            "sharp clarifying question rather than guessing. Beep.",
+        spinner: { glowA: "#64748B", glowB: "#38BDF8" },
+        voice: kokoroVoice("am_echo"),
+    },
+];
+//# sourceMappingURL=default-personalities.js.map

package/dist/effort.d.ts

@@ -0,0 +1,32 @@
+import type { AgentSelectOption } from "./agent-types.js";
+export declare const EFFORT_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type EffortLevel = (typeof EFFORT_LEVELS)[number];
+/** Map a free-form requested value to a canonical level, or null. */
+export declare function parseEffortLevel(value: string): EffortLevel | null;
+export declare class EffortResolutionError extends Error {
+    readonly requested: string;
+    readonly availableOptionIds: readonly string[];
+    constructor(requested: string, availableOptionIds: readonly string[]);
+}
+export interface ResolvedEffortOption {
+    optionId: string;
+    /**
+     * "exact-id": the request named an advertised option id verbatim.
+     * "level": a canonical level matched an option at the same scale position.
+     * "nearest": the model doesn't offer the requested level; the closest
+     * advertised option was chosen (ties round down, never spending more
+     * effort than asked for).
+     */
+    matched: "exact-id" | "level" | "nearest";
+}
+/**
+ * Resolve a requested effort — an exact option id or a canonical level —
+ * against a model's advertised `thinkingOptions`. Exact ids always win, so
+ * provider-special options (e.g. Claude's "ultracode") stay reachable even
+ * though they have no place on the canonical scale.
+ */
+export declare function resolveEffortOption(input: {
+    requested: string;
+    thinkingOptions: readonly AgentSelectOption[];
+}): ResolvedEffortOption;
+//# sourceMappingURL=effort.d.ts.map

package/dist/effort.js

@@ -0,0 +1,99 @@
+// Canonical effort scale, weakest to strongest. This is the shared vocabulary
+// tooling, prompts, and agent personalities use to *request* reasoning effort
+// ("run this at high effort") without knowing which option ids a given model
+// actually supports; option sets stay provider/model-specific (see the Effort
+// entry in docs/glossary.md). The daemon's effort resolver maps a requested
+// level to the nearest option a model advertises in its `thinkingOptions`.
+export const EFFORT_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+const EFFORT_LEVEL_SYNONYMS = {
+    off: "off",
+    none: "off",
+    disabled: "off",
+    minimal: "minimal",
+    min: "minimal",
+    minimum: "minimal",
+    low: "low",
+    medium: "medium",
+    mid: "medium",
+    moderate: "medium",
+    high: "high",
+    xhigh: "xhigh",
+    extrahigh: "xhigh",
+    veryhigh: "xhigh",
+    max: "max",
+    maximum: "max",
+};
+function normalizeToken(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[\s_-]+/g, "");
+}
+/** Map a free-form requested value to a canonical level, or null. */
+export function parseEffortLevel(value) {
+    return EFFORT_LEVEL_SYNONYMS[normalizeToken(value)] ?? null;
+}
+function scalePosition(option) {
+    const byId = parseEffortLevel(option.id);
+    if (byId !== null) {
+        return EFFORT_LEVELS.indexOf(byId);
+    }
+    const byLabel = parseEffortLevel(option.label);
+    return byLabel === null ? null : EFFORT_LEVELS.indexOf(byLabel);
+}
+export class EffortResolutionError extends Error {
+    constructor(requested, availableOptionIds) {
+        super(`Unknown effort "${requested}". Pass one of the model's option ids ` +
+            `(${availableOptionIds.join(", ") || "none advertised"}) or a canonical level ` +
+            `(${EFFORT_LEVELS.join(", ")}).`);
+        this.requested = requested;
+        this.availableOptionIds = availableOptionIds;
+        this.name = "EffortResolutionError";
+    }
+}
+/**
+ * Resolve a requested effort — an exact option id or a canonical level —
+ * against a model's advertised `thinkingOptions`. Exact ids always win, so
+ * provider-special options (e.g. Claude's "ultracode") stay reachable even
+ * though they have no place on the canonical scale.
+ */
+export function resolveEffortOption(input) {
+    const requested = input.requested.trim();
+    const availableIds = input.thinkingOptions.map((option) => option.id);
+    const exact = input.thinkingOptions.find((option) => option.id === requested);
+    if (exact) {
+        return { optionId: exact.id, matched: "exact-id" };
+    }
+    const caseInsensitive = input.thinkingOptions.find((option) => option.id.toLowerCase() === requested.toLowerCase());
+    if (caseInsensitive) {
+        return { optionId: caseInsensitive.id, matched: "exact-id" };
+    }
+    const requestedLevel = parseEffortLevel(requested);
+    if (requestedLevel === null) {
+        throw new EffortResolutionError(requested, availableIds);
+    }
+    const requestedPosition = EFFORT_LEVELS.indexOf(requestedLevel);
+    let best = null;
+    for (const option of input.thinkingOptions) {
+        const position = scalePosition(option);
+        if (position === null) {
+            continue;
+        }
+        if (best === null ||
+            Math.abs(position - requestedPosition) < Math.abs(best.position - requestedPosition) ||
+            (Math.abs(position - requestedPosition) === Math.abs(best.position - requestedPosition) &&
+                position < best.position)) {
+            best = { optionId: option.id, position };
+        }
+    }
+    if (best === null) {
+        // None of the model's options map onto the canonical scale (fully custom
+        // option ids) — only exact ids can address them.
+        throw new EffortResolutionError(requested, availableIds);
+    }
+    return {
+        optionId: best.optionId,
+        matched: best.position === requestedPosition ? "level" : "nearest",
+    };
+}
+//# sourceMappingURL=effort.js.map

package/dist/error-utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Extracts a human-readable error message from an unknown error value.
+ * Handles Error instances, string errors, and other types safely.
+ */
+export declare function getErrorMessage(error: unknown): string;
+/**
+ * Extracts an error message from an unknown error value, with a fallback
+ * for when no message can be extracted.
+ */
+export declare function getErrorMessageOr(error: unknown, fallback: string): string;
+//# sourceMappingURL=error-utils.d.ts.map

package/dist/error-utils.js

@@ -0,0 +1,27 @@
+/**
+ * Extracts a human-readable error message from an unknown error value.
+ * Handles Error instances, string errors, and other types safely.
+ */
+export function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return String(error);
+}
+/**
+ * Extracts an error message from an unknown error value, with a fallback
+ * for when no message can be extracted.
+ */
+export function getErrorMessageOr(error, fallback) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string" && error.length > 0) {
+        return error;
+    }
+    return fallback;
+}
+//# sourceMappingURL=error-utils.js.map

package/dist/generated/validation/ws-outbound.aot.d.ts

@@ -0,0 +1,2 @@
+export declare const WSOutboundMessageSchema: any;
+//# sourceMappingURL=ws-outbound.aot.d.ts.map