@crievo/omni 0.0.0-stage → 0.1.1

package/reference/voicestudio.md

@@ -0,0 +1,81 @@
+# VoiceStudio
+
+Repository and environment in a folder of yours (`voicestudio.repo` in the
+config; a clone of `debpalash/VoiceStudio` v0.5.7, called `<repo>` below).
+Local FastAPI backend at `http://127.0.0.1:3900`, OmniVoice model on the Mac's
+GPU (MPS). No API key: everything runs locally.
+
+## Start
+
+- App: `cd <repo> && bun run dev` (opens Electron, which starts the backend).
+- Backend only: `bun run dev:api`.
+- Check: `curl -s http://127.0.0.1:3900/health`.
+
+## Voice
+
+**Always the profile named "Pedro".** The id changes every time the clone is
+redone, so the config keeps the name (`voicestudio.profile`) and
+`omnivideo.py voice` looks up the id in `GET /profiles` on every run. Zero or
+more than one profile with that name is an error.
+
+> **Trap:** `POST /generate` with a `profile_id` that doesn't exist **does not
+> error**. It generates with a generic voice, no clone, and faster. That is how
+> a test came out with the wrong voice without any warning. That's why the id
+> is never hardcoded.
+
+Current profile (2026-10-12): `c75067ce`, 66 s reference, language
+Portuguese, no saved transcription. OmniVoice uses at most 20 s of the
+reference: with a longer clip, it picks the 15 s excerpt with the most speech
+by itself.
+
+## Generate
+
+`POST /generate` (multipart), response `audio/wav` 24 kHz mono:
+
+| field | value in omnivideo |
+|---|---|
+| `text` | the line |
+| `profile_id` | resolved by name |
+| `language` | `Portuguese` |
+| `num_step` | 16 (8 = quick draft, 32 = quality) |
+| `speed` | 1.0 |
+| `instruct` | optional, per line |
+
+Every generation goes through the default mastering (`broadcast` preset),
+gets an inaudible watermark (AudioSeal) and goes into the app's history.
+
+## Measured performance (M4, 16 GB)
+
+| situation | cost |
+|---|---|
+| "Pedro" profile, model already loaded | ~20 s fixed per line + 4 to 5 s per second of audio |
+| first line after being idle | +10 s (loading the model; it unloads after 5 min idle) |
+| memory full (swap ≥ 90 %) | up to 9 s per second of audio; long lines blow the limit |
+
+The limit is **305 s of compute per generation**. If it blows: the abandoned
+job keeps running until it finishes, and retrying right away competes with
+it. Wait, split the line, and warn the user about memory
+(`sysctl vm.swapusage`).
+
+Pace of Pedro's voice: 2.3 to 3.4 words per second; the config uses 3.0 to
+estimate.
+
+## Pronunciation
+
+A word coming out wrong goes into the pronunciation dictionary, which applies
+to every generation:
+
+```bash
+curl -s -X POST http://127.0.0.1:3900/pronunciation -H 'content-type: application/json' \
+  -d '{"term": "MCP", "replacement": "éme cê pê", "language": "*"}'
+curl -s http://127.0.0.1:3900/pronunciation          # list
+```
+
+You can also fix a single occurrence, in the text: `[[éme cê pê]]`. But in
+omnivideo the line's text is also the caption, so prefer the dictionary.
+
+## MCP
+
+VoiceStudio also exposes MCP at `http://localhost:3900/mcp/` (registered in
+Claude Code as `voicestudio`). For omnivideo use the API: the MCP returns the
+audio in base64 inside the conversation, which is very heavy.

package/reference/writing-for-voice.md

@@ -0,0 +1,67 @@
+# Writing for the voice
+
+The line goes straight to the cloned voice (Fish Audio by default). The voice
+reads punctuation as intonation: each mark becomes a pause, a rise or a break.
+Text that looks good written can come out choppy spoken. The rule is to write
+the way Pedro would speak in a conversation, not the way he would write a post.
+
+Applies to `script.md` (stage 1) and, above all, to the lines in
+`scenes.json` (stage 4). `omnivideo.py status` warns when a
+line breaks the objective rules below.
+
+The narration is Portuguese, so the examples below stay in Portuguese.
+
+## Punctuation
+
+- **The period is the only safe mark.** One sentence, one idea, period.
+- **No colons.** The voice stops and changes tone mid-sentence. Whatever would
+  come after the colon becomes another sentence.
+- **At most one comma**, and only where people naturally breathe ("No
+  Upwork, …"). A comma before a colon is the worst case: two breaks in a row
+  in the middle of one idea.
+- **No appositives or parenthetical clauses** ("que pede, por escrito, …").
+  The voice breaks the intonation at the parenthetical and never recovers.
+- **No semicolons, dashes, parentheses, slashes or ellipses.**
+- **A list becomes a sentence.** "história curta, referência visual e som"
+  after a colon sounds like reading bullet points. Write it with a verb and
+  articles: "Você precisa de uma história curta, uma referência visual e um som."
+
+## Order and rhythm
+
+- **Direct order:** subject, verb, complement. Don't open with a long
+  circumstance.
+- **One idea per sentence.** Two price ranges in one sentence become two
+  sentences (and two lines, which the motion can separate).
+- **Short sentences.** Up to ~15 words sounds natural; 22 is the stage's ceiling.
+- **Colloquial:** "pra", "a gente", "tá", contractions the way people speak.
+
+## Words
+
+- **Numbers as spoken:** "500 dólares", "2 mil", "15 segundos". Ranges with
+  "de … a …", never a hyphen or dash.
+- **Don't end the sentence on a bare number.** "chega a 2 mil." left the voice
+  without a clear ending, and it tacked on an extra sound. Complete it with
+  the unit: "chega a 2 mil dólares."
+- **Version numbers, mixed acronyms and hard foreign words** ("Opus 5.5",
+  "SaaS") have no pronunciation dictionary in Fish. Leave them on screen and
+  say them in Portuguese ("o Opus", "demo de produto"). The motion shows the
+  exact term.
+- **No symbols:** "%" becomes "por cento", "x" becomes "vezes", "→" doesn't exist.
+- AI terms Pedro says in English (prompt, agent, token) stay.
+
+## Real example (2026-10-12)
+
+| written | what the voice did | rewritten |
+|---|---|---|
+| E tem vaga que pede, por escrito: domínio do Opus 5.5. | two breaks in a row (comma and colon) and "5.5" read as a number | E já tem vaga pedindo quem domine o Opus. |
+| No Upwork, vai de 100 dólares por um logo animado até 2 mil por uma demo de SaaS. | long sentence, two ranges | Um logo animado no Upwork sai por 100 dólares. / Uma demo de produto chega a 2 mil dólares. |
+| Começa por demo de SaaS: história curta, referência visual e som. | colon and a bullet-point list | O melhor jeito de começar é a demo de produto. / Você precisa de uma história curta, uma referência visual e um som. |
+| Tem gente vendendo animação a 129 dólares, feita em menos de uma hora. | parenthetical at the end | Tem gente cobrando 129 dólares por uma animação que leva menos de uma hora. |
+| Uma demo de produto chega a 2 mil. | ended on a bare number; the voice tacked a sound onto the end | Uma demo de produto chega a 2 mil dólares. |
+
+## How to check
+
+Read the line out loud, for real, once. If you stopped or changed tone
+anywhere other than the period, rewrite it. After the voice, the voice stage
+marks `← ritmo estranho` (odd rhythm) when a line comes out too fast or too
+slow: it is almost always a hard sentence, not a voice error.

package/requirements.txt

@@ -0,0 +1,3 @@
+requests>=2.31
+soundfile>=0.12
+numpy>=1.26

package/studio/api/app.ts

@@ -0,0 +1,87 @@
+/* The studio's HTTP API (the local runner API): every /api route plus the file routes (/media,
+   /ref, /kit, /sound-draft, /docs). Bun keeps serving the HTML bundle (studio.ts) and hands these
+   paths here. `AppType` types the web client (web/lib/api.ts, hono/client).
+
+   Routers are domain modules under routes/; the cloud candidates (publish, schedule, omnichat,
+   analytics) only reach their own services, so they can move to an edge function as they are. */
+
+import { router } from "./lib/hono";
+import { notFoundResponse, onError } from "./lib/errors";
+import { localOnly } from "./middleware/local-only";
+import { jsonCharset } from "./middleware/json-charset";
+import { admin } from "./routes/admin";
+import { agent } from "./routes/agent";
+import { agentCascade } from "./routes/agent-cascade";
+import { agentHistory } from "./routes/agent-history";
+import { analytics } from "./routes/analytics";
+import { approval } from "./routes/approval";
+import { archive } from "./routes/archive";
+import { captions } from "./routes/captions";
+import { carousel } from "./routes/carousel";
+import { clone } from "./routes/clone";
+import { create, UPLOAD_PATH } from "./routes/create";
+import { events } from "./routes/events";
+import { exportRoutes } from "./routes/export";
+import { media } from "./routes/media";
+import { omnichat } from "./routes/omnichat";
+import { onboarding } from "./routes/onboarding";
+import { publish } from "./routes/publish";
+import { queue } from "./routes/queue";
+import { references } from "./routes/references";
+import { runner } from "./routes/runner";
+import { schedule } from "./routes/schedule";
+import { services } from "./routes/services";
+import { sessions } from "./routes/sessions";
+import { settings } from "./routes/settings";
+import { sound } from "./routes/sound";
+import { thumbnail } from "./routes/thumbnail";
+import { usage } from "./routes/usage";
+import { videos } from "./routes/videos";
+import { voices } from "./routes/voices";
+
+/* the path prefixes studio.ts hands to this app */
+export const API_PREFIXES = ["/api", "/media", "/ref", "/kit", "/sound-draft", "/docs"] as const;
+
+export type AppOptions = { port: number };
+
+export function createApp({ port }: AppOptions) {
+  const api = router()
+    .route("/", create)
+    .route("/", videos)
+    .route("/", captions)
+    .route("/", sound)
+    .route("/", exportRoutes)
+    .route("/", voices)
+    .route("/", approval)
+    .route("/", archive)
+    .route("/", thumbnail)
+    .route("/", carousel)
+    .route("/", publish)
+    .route("/", schedule)
+    .route("/", omnichat)
+    .route("/", sessions)
+    .route("/", references)
+    .route("/", queue)
+    .route("/", runner)
+    .route("/", services)
+    .route("/", usage)
+    .route("/", analytics)
+    .route("/", settings)
+    .route("/", clone)
+    .route("/", onboarding)
+    .route("/", admin)
+    .route("/", agent)
+    .route("/", agentCascade)
+    .route("/", agentHistory)
+    .route("/", events);
+  const app = router()
+    .use(localOnly({ port, uploadPaths: [UPLOAD_PATH] }))
+    .use(jsonCharset)
+    .route("/api", api)
+    .route("/", media);
+  app.onError(onError);
+  app.notFound(() => notFoundResponse());
+  return app;
+}
+
+export type AppType = ReturnType<typeof createApp>;

package/studio/api/lib/errors.ts

@@ -0,0 +1,33 @@
+/* One error format. HttpError carries a status; 404 stays the plain "não encontrado" text the
+   studio always answered, everything else is the { ok: false, error } envelope. */
+
+import type { Context } from "hono";
+import { HTTPException } from "hono/http-exception";
+
+export class HttpError extends Error {
+  constructor(
+    readonly status: 400 | 403 | 404 | 415 | 500,
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+export const NOT_FOUND_TEXT = "não encontrado";
+export const notFoundResponse = () => new Response(NOT_FOUND_TEXT, { status: 404 });
+
+/* throw from a handler: answered by onError as the plain 404 */
+export const notFound = () => new HttpError(404, NOT_FOUND_TEXT);
+
+export function onError(e: Error, c: Context): Response {
+  if (e instanceof HttpError) {
+    if (e.status === 404) return notFoundResponse();
+    return c.json({ ok: false, error: e.message }, e.status);
+  }
+  /* the validator's malformed JSON */
+  if (e instanceof HTTPException && e.status === 400) {
+    return c.json({ ok: false, error: "corpo da requisição: JSON inválido" }, 400);
+  }
+  console.error(e);
+  return c.json({ ok: false, error: e.message || String(e) }, 500);
+}

package/studio/api/lib/files.ts

@@ -0,0 +1,41 @@
+/* Files served as they are (media, reference files, docs, sound drafts, kit). Bun answers Range
+   by itself for Bun.file (206 with Content-Range): it is what video and audio players ask for
+   to seek into the middle of the file. */
+
+import { extname } from "node:path";
+import { notFoundResponse } from "./errors";
+
+const TEXT_CONTENT_TYPES: Record<string, string> = {
+  ".srt": "text/plain; charset=utf-8",
+  ".md": "text/plain; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".css": "text/plain; charset=utf-8",
+};
+
+/* the path segments after the first `skip` ones, decoded: /media/<slug>/<a>/<b> → [slug, a, b] */
+export const pathSegments = (url: string, skip = 2) =>
+  new URL(url).pathname
+    .split("/")
+    .slice(skip)
+    .map(p => decodeURIComponent(p));
+
+/* `?v=` (the file's mtime) makes the URL immutable */
+export async function serveFile(abs: string | null, url: string): Promise<Response> {
+  if (!abs) return notFoundResponse();
+  const file = Bun.file(abs);
+  if (!(await file.exists())) return notFoundResponse();
+  const headers: Record<string, string> = {
+    "cache-control": new URL(url).searchParams.has("v") ? "private, max-age=31536000, immutable" : "no-cache",
+    "x-content-type-options": "nosniff",
+  };
+  const type = TEXT_CONTENT_TYPES[extname(abs).toLowerCase()];
+  if (type) headers["content-type"] = type;
+  return new Response(file, { headers });
+}
+
+/* a stored WAV (voice samples, original recordings): 404 when missing or empty */
+export function serveWav(abs: string | null): Response {
+  const f = abs ? Bun.file(abs) : null;
+  return f?.size ? new Response(f, { headers: { "content-type": "audio/wav" } }) : notFoundResponse();
+}

package/studio/api/lib/hono.ts

@@ -0,0 +1,9 @@
+/* The Hono env every router shares: Bun's server (for server.timeout on long requests and
+   the SSE stream) arrives as c.env.server; tests pass none. */
+
+import { Hono } from "hono";
+import type { Server } from "bun";
+
+export type AppEnv = { Bindings: { server?: Server<unknown> } };
+
+export const router = () => new Hono<AppEnv>();

package/studio/api/lib/result.ts

@@ -0,0 +1,14 @@
+/* Envelope helpers. A service result ({ ok, output?, error?, … }) answers 200 when ok and 400
+   when not, as the studio always did. */
+
+import type { Context } from "hono";
+
+export const result = <T extends { ok: boolean }>(c: Context, r: T) => c.json(r, r.ok ? 200 : 400);
+
+/* a failed result with this message (400) */
+export const fail = (c: Context, error: string) => c.json({ ok: false as const, error }, 400);
+
+/* A service value under the response type the UI reads (shared/types/api.ts). Services build these
+   from the video's files and the tools' JSON output, so the shared type is the contract between
+   the two sides rather than something TS can prove from the service code. */
+export const shaped = <T>(value: unknown) => value as T;

package/studio/api/lib/validate.ts

@@ -0,0 +1,31 @@
+/* zod validators for JSON bodies and query strings: a failure answers 400
+   { ok: false, error: "<campo>: <mensagem>" }, in Portuguese since it may reach the UI. */
+
+import { zValidator } from "@hono/zod-validator";
+import { z } from "zod";
+
+z.config(z.locales.pt());
+/* a missing field reads better as "obrigatório" than as "recebeu undefined" */
+z.config({
+  customError: issue => (issue.code === "invalid_type" && issue.input === undefined ? "obrigatório" : undefined),
+});
+
+export function validationMessage(issues: readonly z.core.$ZodIssue[]): string {
+  const issue = issues[0];
+  if (!issue) return "requisição inválida";
+  const field = issue.path.map(String).join(".") || "corpo";
+  return `${field}: ${issue.message}`;
+}
+
+const invalid = (issues: readonly z.core.$ZodIssue[]) =>
+  Response.json({ ok: false, error: validationMessage(issues) }, { status: 400 });
+
+export const json = <S extends z.ZodType>(schema: S) =>
+  zValidator("json", schema, r => {
+    if (!r.success) return invalid(r.error.issues);
+  });
+
+export const query = <S extends z.ZodType>(schema: S) =>
+  zValidator("query", schema, r => {
+    if (!r.success) return invalid(r.error.issues);
+  });

package/studio/api/lib/video.ts

@@ -0,0 +1,10 @@
+/* The dir of the video a route names, or the plain 404 every video route answers when it is gone. */
+
+import { videoDirs } from "../services/videos";
+import { notFound } from "./errors";
+
+export function videoDir(slug: string): string {
+  const dir = videoDirs().get(slug);
+  if (!dir) throw notFound();
+  return dir;
+}

package/studio/api/middleware/json-charset.ts

@@ -0,0 +1,11 @@
+/* JSON answers keep the content-type Bun's Response.json gave them before the Hono move
+   ("application/json;charset=utf-8"), so nothing downstream sees a different header. */
+
+import { createMiddleware } from "hono/factory";
+import type { AppEnv } from "../lib/hono";
+
+export const jsonCharset = createMiddleware<AppEnv>(async (c, next) => {
+  await next();
+  if (c.res.headers.get("content-type") === "application/json")
+    c.res.headers.set("content-type", "application/json;charset=utf-8");
+});

package/studio/api/middleware/local-only.ts

@@ -0,0 +1,32 @@
+/* Only this machine and only the studio UI. Host blocks DNS rebinding; Origin and mandatory
+   JSON block another page open in the browser from posting here. The upload paths take a raw
+   body instead: their custom x-file-name header makes the browser send a preflight from any
+   other origin, which this server doesn't answer. */
+
+import { createMiddleware } from "hono/factory";
+import type { AppEnv } from "../lib/hono";
+
+export type LocalOnlyOptions = { port: number; uploadPaths?: string[] };
+
+const text = (body: string, status: number) => new Response(body, { status });
+
+export function rejectForeign(req: Request, hosts: Set<string>, origins: Set<string>, upload: boolean) {
+  if (!hosts.has(req.headers.get("host") ?? "")) return text("host não permitido", 403);
+  if (req.method === "GET" || req.method === "HEAD") return null;
+  const origin = req.headers.get("origin");
+  if (origin && !origins.has(origin)) return text("origem não permitida", 403);
+  if (upload) return req.headers.get("x-file-name") ? null : text("falta o nome do arquivo", 415);
+  if (!req.headers.get("content-type")?.startsWith("application/json")) return text("só JSON", 415);
+  return null;
+}
+
+export function localOnly({ port, uploadPaths = [] }: LocalOnlyOptions) {
+  const hosts = new Set([`127.0.0.1:${port}`, `localhost:${port}`]);
+  const origins = new Set([...hosts].map(h => `http://${h}`));
+  const uploads = new Set(uploadPaths);
+  return createMiddleware<AppEnv>(async (c, next) => {
+    const rejected = rejectForeign(c.req.raw, hosts, origins, uploads.has(c.req.path));
+    if (rejected) return rejected;
+    await next();
+  });
+}

package/studio/api/middleware/no-timeout.ts

@@ -0,0 +1,10 @@
+/* Long requests (Instagram reads, uploads, clone, connect, collect, streams): lifts Bun's 10 s
+   idle timeout for this request. */
+
+import { createMiddleware } from "hono/factory";
+import type { AppEnv } from "../lib/hono";
+
+export const noTimeout = createMiddleware<AppEnv>(async (c, next) => {
+  c.env?.server?.timeout(c.req.raw, 0);
+  await next();
+});

package/studio/api/routes/admin.ts

@@ -0,0 +1,18 @@
+/* The admin panel (services/admin.ts): who is looking, and Omni's settings for every user. A
+   non-admin only learns that it isn't one; a change from one is refused. */
+
+import { json } from "../lib/validate";
+import { router } from "../lib/hono";
+import { omniAdmin, setOmniAdmin, viewerOf } from "../services/admin";
+import { omniAdminBody } from "../../shared/schemas/admin";
+
+export const admin = router()
+  .get("/admin", c => {
+    const viewer = viewerOf(c.req.raw);
+    return c.json({ ...viewer, omni: viewer.admin ? omniAdmin() : null });
+  })
+  .post("/admin/omni", json(omniAdminBody), c => {
+    if (!viewerOf(c.req.raw).admin) return c.json({ ok: false as const, error: "só o admin muda a Omni" }, 403);
+    const r = setOmniAdmin(c.req.valid("json"));
+    return r.ok ? c.json(r) : c.json(r, 400);
+  });

package/studio/api/routes/agent-cascade.ts

@@ -0,0 +1,100 @@
+/* Omni in cascade mode (services/agent-cascade.ts): the session, the STT token to reconnect, each
+   turn streamed back as NDJSON (text, tools, staged actions, audio) and the browser's measurements. */
+
+import { json } from "../lib/validate";
+import { router } from "../lib/hono";
+import { fail } from "../lib/result";
+import { noTimeout } from "../middleware/no-timeout";
+import { logEvent } from "../services/agent";
+import {
+  cascadeClip,
+  commitTurn,
+  endCascade,
+  hasCascade,
+  resolveUiCall,
+  runTurn,
+  startCascade,
+  sttSocket,
+} from "../services/agent-cascade";
+import { emptyBody } from "../../shared/schemas/common";
+import {
+  cascadeLogBody,
+  cascadeSessionBody,
+  cascadeTurnBody,
+  cascadeUiResultBody,
+} from "../../shared/schemas/agent-cascade";
+
+export const agentCascade = router()
+  .post("/agent/cascade/session", json(cascadeSessionBody), async c => {
+    try {
+      const b = c.req.valid("json");
+      return c.json({ ok: true as const, ...(await startCascade(b.mode, b.history)) });
+    } catch (e) {
+      return fail(c, String((e as Error)?.message ?? e));
+    }
+  })
+  .post("/agent/cascade/:id/stt", json(emptyBody), async c => {
+    if (!hasCascade(c.req.param("id"))) return fail(c, "sessão desconhecida");
+    try {
+      return c.json({ ok: true as const, ...(await sttSocket()) });
+    } catch (e) {
+      return fail(c, String((e as Error)?.message ?? e));
+    }
+  })
+  /* one NDJSON line per event; the page aborting the request (the user spoke over Omni) stops the turn */
+  .post("/agent/cascade/:id/turn", noTimeout, json(cascadeTurnBody), c => {
+    const id = c.req.param("id");
+    const { text, speculative, screen } = c.req.valid("json");
+    const ctrl = new AbortController();
+    c.req.raw.signal.addEventListener("abort", () => ctrl.abort());
+    const enc = new TextEncoder();
+    const body = new ReadableStream<Uint8Array>({
+      async start(stream) {
+        let open = true;
+        await runTurn(
+          id,
+          text,
+          ctrl.signal,
+          e => {
+            if (!open) return;
+            try {
+              stream.enqueue(enc.encode(`${JSON.stringify(e)}\n`));
+            } catch {
+              open = false;
+            }
+          },
+          speculative === true,
+          screen,
+        );
+        if (open) stream.close();
+      },
+      cancel() {
+        ctrl.abort();
+      },
+    });
+    return new Response(body, { headers: { "content-type": "application/x-ndjson", "cache-control": "no-store" } });
+  })
+  /* the speculative turn in flight was right: the user had finished */
+  .post("/agent/cascade/:id/commit", json(emptyBody), c => c.json({ ok: commitTurn(c.req.param("id")) }))
+  .post("/agent/cascade/:id/ui-result", json(cascadeUiResultBody), c => {
+    const b = c.req.valid("json");
+    return c.json({ ok: resolveUiCall(c.req.param("id"), b.call_id, b.output) });
+  })
+  /* "Ainda tá aí?" and the goodbye, in Omni's voice (raw PCM16 24 kHz) */
+  .get("/agent/cascade/:id/clip/:name", async c => {
+    try {
+      const pcm = await cascadeClip(c.req.param("id"), c.req.param("name"));
+      return new Response(new Blob([pcm as Uint8Array<ArrayBuffer>]), {
+        headers: { "content-type": "application/octet-stream", "cache-control": "no-store" },
+      });
+    } catch (e) {
+      return fail(c, String((e as Error)?.message ?? e));
+    }
+  })
+  .post("/agent/cascade/:id/log", json(cascadeLogBody), c => {
+    const id = c.req.param("id");
+    const b = c.req.valid("json");
+    if (b.type === "end") endCascade(id, b.duration_s, b.stt_audio_s, b.reason);
+    else logEvent({ session: id, ...b, ...(b.type === "turn" ? { mode: "cascade" } : {}) });
+    return c.json({ ok: true as const });
+  });

package/studio/api/routes/agent-history.ts

@@ -0,0 +1,23 @@
+/* Omni's conversation history (services/agent-history.ts): the list, one conversation, the browser's
+   save as the call goes, and deleting one. */
+
+import { json } from "../lib/validate";
+import { router } from "../lib/hono";
+import { fail, result } from "../lib/result";
+import { notFound } from "../lib/errors";
+import { deleteConversation, getConversation, listConversations, saveConversation } from "../services/agent-history";
+import { emptyBody } from "../../shared/schemas/common";
+import { conversationSaveBody } from "../../shared/schemas/agent-history";
+
+export const agentHistory = router()
+  .get("/agent/conversations", c => c.json(listConversations()))
+  .get("/agent/conversations/:id", c => {
+    const conv = getConversation(c.req.param("id"));
+    if (!conv) throw notFound();
+    return c.json(conv);
+  })
+  .post("/agent/conversations/:id", json(conversationSaveBody), c => {
+    const r = saveConversation(c.req.param("id"), c.req.valid("json"));
+    return r.ok ? c.json(r) : fail(c, r.error);
+  })
+  .post("/agent/conversations/:id/delete", json(emptyBody), c => result(c, deleteConversation(c.req.param("id"))));