@otto-code/protocol 0.8.10 → 0.8.12

package/dist/orchestration.js

@@ -630,4 +630,236 @@ function validateGraphNodeLoop(node) {
     }
     return [];
 }
+// ── Orchestration runs (agent-orchestration) ────────────────────────────────
+// Daemon-owned multi-agent Run projection + control. Gated by
+// server_info.features.agentOrchestration. See projects/agent-orchestration.
+export const RunsGetSnapshotRequestSchema = z.object({
+    type: z.literal("runs.get_snapshot.request"),
+    requestId: z.string(),
+});
+export const RunsGetSnapshotResponseSchema = z.object({
+    type: z.literal("runs.get_snapshot.response"),
+    payload: z.object({
+        runs: z.array(RunSchema),
+        requestId: z.string(),
+    }),
+});
+// Single-run push, broadcast on every phase/status change. Clients merge by id.
+export const RunsUpdatedNotificationSchema = z.object({
+    type: z.literal("runs.updated.notification"),
+    payload: z.object({
+        run: RunSchema,
+    }),
+});
+// Answer an attended run's `gate` phase (approve or reject, with an optional
+// note). `accepted` is false when the run wasn't awaiting a gate.
+export const RunsGateRespondRequestSchema = z.object({
+    type: z.literal("runs.gate_respond.request"),
+    runId: z.string(),
+    phaseId: z.string(),
+    approved: z.boolean(),
+    note: z.string().optional(),
+    requestId: z.string(),
+});
+export const RunsGateRespondResponseSchema = z.object({
+    type: z.literal("runs.gate_respond.response"),
+    payload: z.object({
+        runId: z.string(),
+        accepted: z.boolean(),
+        requestId: z.string(),
+    }),
+});
+export const RunsCancelRequestSchema = z.object({
+    type: z.literal("runs.cancel.request"),
+    runId: z.string(),
+    requestId: z.string(),
+});
+export const RunsCancelResponseSchema = z.object({
+    type: z.literal("runs.cancel.response"),
+    payload: z.object({
+        runId: z.string(),
+        canceled: z.boolean(),
+        requestId: z.string(),
+    }),
+});
+// Delete every finished (done/failed/canceled) run from disk and memory.
+// Active/paused runs are left untouched. Gated by
+// server_info.features.runsClear.
+export const RunsClearRequestSchema = z.object({
+    type: z.literal("runs.clear.request"),
+    requestId: z.string(),
+});
+export const RunsClearResponseSchema = z.object({
+    type: z.literal("runs.clear.response"),
+    payload: z.object({
+        runIds: z.array(z.string()),
+        requestId: z.string(),
+    }),
+});
+// Delete one run by id. Terminal (done/failed/canceled) and draft runs only -
+// deleting an active run is refused so a cleanup click can't silently orphan
+// running agents; cancel it first. Gated by server_info.features.runsDelete.
+export const RunsDeleteRequestSchema = z.object({
+    type: z.literal("runs.delete.request"),
+    requestId: z.string(),
+    runId: z.string(),
+});
+export const RunsDeleteResponseSchema = z.object({
+    type: z.literal("runs.delete.response"),
+    payload: z.object({
+        // The deleted id, or absent when nothing was deleted (unknown or still
+        // active) - `error` then carries why.
+        runId: z.string().optional(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
+// Broadcast to every connected client (including the requester) so all
+// caches drop the same runs, mirroring runs.updated.notification's upsert.
+// Serves both runs.clear (many ids) and runs.delete (one).
+export const RunsClearedNotificationSchema = z.object({
+    type: z.literal("runs.cleared.notification"),
+    payload: z.object({
+        runIds: z.array(z.string()),
+    }),
+});
+// ── Orchestration graphs (user orchestrations) ──────────────────────────────
+// Host-level reusable graph templates + user-initiated orchestration start.
+// Gated by server_info.features.orchestrationGraphs. UI says "Orchestration"
+// and "Graph"; the wire keeps the short `runs.` namespace (see docs/glossary.md).
+// See projects/orchestration-graphs.
+export const RunsGraphsListRequestSchema = z.object({
+    type: z.literal("runs.graphs.list.request"),
+    requestId: z.string(),
+});
+export const RunsGraphsListResponseSchema = z.object({
+    type: z.literal("runs.graphs.list.response"),
+    payload: z.object({
+        graphs: z.array(OrchestrationGraphSchema),
+        requestId: z.string(),
+    }),
+});
+// Upsert a graph template (create when the id is new). Built-in graphs are
+// copy-on-edit daemon-side: saving over a builtIn id persists a user copy.
+export const RunsGraphsSaveRequestSchema = z.object({
+    type: z.literal("runs.graphs.save.request"),
+    graph: OrchestrationGraphSchema,
+    requestId: z.string(),
+});
+export const RunsGraphsSaveResponseSchema = z.object({
+    type: z.literal("runs.graphs.save.response"),
+    payload: z.object({
+        graph: OrchestrationGraphSchema.optional(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
+export const RunsGraphsDeleteRequestSchema = z.object({
+    type: z.literal("runs.graphs.delete.request"),
+    graphId: z.string(),
+    requestId: z.string(),
+});
+export const RunsGraphsDeleteResponseSchema = z.object({
+    type: z.literal("runs.graphs.delete.response"),
+    payload: z.object({
+        deleted: z.boolean(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
+// Broadcast after any save/delete so every client's graph cache converges,
+// mirroring runs.updated.notification's role for runs.
+export const RunsGraphsChangedNotificationSchema = z.object({
+    type: z.literal("runs.graphs.changed.notification"),
+    payload: z.object({
+        graphs: z.array(OrchestrationGraphSchema),
+    }),
+});
+// ── Prompt templates ────────────────────────────────────────────────────────
+// Host-level reusable prompts and snippets a graph node can bind to. Same shape
+// as the graph trio above, for the same reason: one store, list/save/delete,
+// plus a full-list push so every client converges.
+export const RunsTemplatesListRequestSchema = z.object({
+    type: z.literal("runs.templates.list.request"),
+    requestId: z.string(),
+});
+export const RunsTemplatesListResponseSchema = z.object({
+    type: z.literal("runs.templates.list.response"),
+    payload: z.object({
+        templates: z.array(PromptTemplateSchema),
+        requestId: z.string(),
+    }),
+});
+export const RunsTemplatesSaveRequestSchema = z.object({
+    type: z.literal("runs.templates.save.request"),
+    template: PromptTemplateSchema,
+    requestId: z.string(),
+});
+export const RunsTemplatesSaveResponseSchema = z.object({
+    type: z.literal("runs.templates.save.response"),
+    payload: z.object({
+        template: PromptTemplateSchema.optional(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
+export const RunsTemplatesDeleteRequestSchema = z.object({
+    type: z.literal("runs.templates.delete.request"),
+    templateId: z.string(),
+    requestId: z.string(),
+});
+export const RunsTemplatesDeleteResponseSchema = z.object({
+    type: z.literal("runs.templates.delete.response"),
+    payload: z.object({
+        deleted: z.boolean(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
+export const RunsTemplatesChangedNotificationSchema = z.object({
+    type: z.literal("runs.templates.changed.notification"),
+    payload: z.object({
+        templates: z.array(PromptTemplateSchema),
+    }),
+});
+// Start (or draft) a user-initiated orchestration from the New Orchestration
+// dialog. `flavor` is an open vocabulary: "ai" (prompt-and-go - the daemon
+// spawns an orchestrator agent that declares its own plan via start_run) or
+// "graph" (deterministic - the daemon executes `graphId` with `graphInputs`).
+// `draft: true` creates the record without executing (the designer flow);
+// `runId` executes an existing draft in place - or, with `draft: true`, re-saves
+// that draft in place (Edit Orchestration).
+export const RunsStartRequestSchema = z.object({
+    type: z.literal("runs.start.request"),
+    flavor: z.string(),
+    cwd: z.string(),
+    workspaceId: z.string().optional(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    // Orchestrator seat when the active team doesn't fill it: a personality, or
+    // a bare provider/model pair.
+    orchestratorPersonalityId: z.string().optional(),
+    orchestratorProvider: z.string().optional(),
+    orchestratorModel: z.string().optional(),
+    orchestratorThinkingOptionId: z.string().optional(),
+    prompt: z.string().optional(),
+    graphId: z.string().optional(),
+    graphInputs: z.record(z.string(), z.string()).optional(),
+    draft: z.boolean().optional(),
+    runId: z.string().optional(),
+    requestId: z.string(),
+});
+export const RunsStartResponseSchema = z.object({
+    type: z.literal("runs.start.response"),
+    payload: z.object({
+        runId: z.string().optional(),
+        // The root/orchestrator agent whose chat the client navigates to, and the
+        // workspace the daemon resolved it into (the dialog only knows a project
+        // target's cwd).
+        agentId: z.string().optional(),
+        workspaceId: z.string().optional(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
 //# sourceMappingURL=orchestration.js.map

package/dist/personality-schemas.d.ts

@@ -0,0 +1,221 @@
+import { z } from "zod";
+/**
+ * Otto agent-personality wire schemas. Kept out of agent-personalities.ts because that module imports from messages.ts, and out of messages.ts because personalities are a fork-only capability.
+ */
+export declare const PERSONALITY_ROLES: readonly ["chatter", "artificer", "scheduler", "researcher", "planner", "judger", "advisor", "coder", "designer", "writer", "orchestrator"];
+export type PersonalityRole = (typeof PERSONALITY_ROLES)[number];
+export declare const PersonalityMemoryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+    scope: z.ZodString;
+    projectRoot: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    source: z.ZodString;
+    reinforcedCount: z.ZodOptional<z.ZodNumber>;
+    transferredFrom: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const PersonalityMemoryListRequestMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"personality.memory.list.request">;
+    requestId: z.ZodString;
+    personalityId: z.ZodString;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    projectRoot: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PersonalityMemoryListResponseMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"personality.memory.list.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        personalityId: z.ZodString;
+        personalityName: z.ZodString;
+        enabled: z.ZodBoolean;
+        entries: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+            scope: z.ZodString;
+            projectRoot: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            source: z.ZodString;
+            reinforcedCount: z.ZodOptional<z.ZodNumber>;
+            transferredFrom: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        brief: z.ZodString;
+        briefTokens: z.ZodNumber;
+        briefOmittedCount: z.ZodOptional<z.ZodNumber>;
+        projectRoot: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const PersonalityMemoryUpdateRequestMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"personality.memory.update.request">;
+    requestId: z.ZodString;
+    personalityId: z.ZodString;
+    entryId: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    projectRoot: z.ZodOptional<z.ZodString>;
+    drop: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const PersonalityMemoryUpdateResponseMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"personality.memory.update.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        ok: z.ZodBoolean;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const PersonalityMemoryTransferRequestMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"personality.memory.transfer.request">;
+    requestId: z.ZodString;
+    fromPersonalityId: z.ZodString;
+    toPersonalityId: z.ZodOptional<z.ZodString>;
+    mode: z.ZodString;
+}, z.core.$strip>;
+export declare const PersonalityMemoryTransferResponseMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"personality.memory.transfer.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        ok: z.ZodBoolean;
+        transferred: z.ZodOptional<z.ZodNumber>;
+        merged: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const PersonalityMemoryStatsRequestMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"personality.memory.stats.request">;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const PersonalityMemoryStatsResponseMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"personality.memory.stats.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PersonalityMemoryEntryPayload = z.infer<typeof PersonalityMemoryEntrySchema>;
+export type PersonalityMemoryListResponseMessage = z.infer<typeof PersonalityMemoryListResponseMessageSchema>;
+export type PersonalityMemoryUpdateResponseMessage = z.infer<typeof PersonalityMemoryUpdateResponseMessageSchema>;
+export type PersonalityMemoryTransferResponseMessage = z.infer<typeof PersonalityMemoryTransferResponseMessageSchema>;
+export type PersonalityMemoryStatsResponseMessage = z.infer<typeof PersonalityMemoryStatsResponseMessageSchema>;
+export declare const AgentTeamAvatarSchema: z.ZodObject<{
+    color: z.ZodOptional<z.ZodString>;
+    imageId: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const AgentTeamSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodOptional<z.ZodObject<{
+        color: z.ZodOptional<z.ZodString>;
+        imageId: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    teamPrompt: z.ZodOptional<z.ZodString>;
+    memberIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export type AgentTeam = z.infer<typeof AgentTeamSchema>;
+export type AgentTeamAvatar = z.infer<typeof AgentTeamAvatarSchema>;
+export declare const AgentPersonalitiesGetStatsRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"agentPersonalities.get_stats.request">;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const AgentPersonalitiesGenerateProfileRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"agentPersonalities.generate_profile.request">;
+    requestId: z.ZodString;
+    name: z.ZodString;
+    roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    glowA: z.ZodOptional<z.ZodString>;
+    glowB: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const AgentPersonalitiesGetStatsResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"agentPersonalities.get_stats.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        stats: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const AgentPersonalitiesGenerateProfileResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"agentPersonalities.generate_profile.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        profile: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export type AgentPersonalitiesGenerateProfileResult = z.infer<typeof AgentPersonalitiesGenerateProfileResponseSchema>["payload"];
+export declare const CUE_MOMENTS: readonly ["join", "thinking", "waiting", "done"];
+export type CueMoment = (typeof CUE_MOMENTS)[number];
+export declare const AgentPersonalitySpinnerSchema: z.ZodObject<{
+    glowA: z.ZodString;
+    glowB: z.ZodString;
+}, z.core.$loose>;
+export declare const AgentPersonalityVoiceSchema: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+    name: z.ZodString;
+}, z.core.$loose>;
+export declare const AgentPersonalityVoiceCuesSchema: z.ZodObject<{
+    join: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    thinking: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    waiting: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    done: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export type AgentPersonalityVoiceCues = z.infer<typeof AgentPersonalityVoiceCuesSchema>;
+export declare const AgentPersonalitySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    effortLevel: z.ZodOptional<z.ZodString>;
+    modeId: z.ZodOptional<z.ZodString>;
+    personalityPrompt: z.ZodOptional<z.ZodString>;
+    respectGlobalAppendPrompt: z.ZodOptional<z.ZodBoolean>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    spinner: z.ZodOptional<z.ZodObject<{
+        glowA: z.ZodString;
+        glowB: z.ZodString;
+    }, z.core.$loose>>;
+    voice: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$loose>>;
+    voiceCues: z.ZodOptional<z.ZodObject<{
+        join: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        thinking: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        waiting: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        done: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
+    memoryEnabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type AgentPersonality = z.infer<typeof AgentPersonalitySchema>;
+export type AgentPersonalityVoice = z.infer<typeof AgentPersonalityVoiceSchema>;
+export declare const VisualizerVoiceCuesGenerateRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"visualizer.voiceCues.generate.request">;
+    requestId: z.ZodString;
+    name: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    moment: z.ZodOptional<z.ZodEnum<{
+        join: "join";
+        thinking: "thinking";
+        waiting: "waiting";
+        done: "done";
+    }>>;
+}, z.core.$strip>;
+export declare const VisualizerVoiceCuesGenerateResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"visualizer.voiceCues.generate.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        cues: z.ZodOptional<z.ZodObject<{
+            join: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            thinking: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            waiting: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            done: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export type VisualizerVoiceCuesResult = z.infer<typeof VisualizerVoiceCuesGenerateResponseSchema>["payload"];
+//# sourceMappingURL=personality-schemas.d.ts.map