@k2b/cloud 0.6.0-rc.0 → 0.7.0

package/src/ai/dictation-runtime.ts

@@ -0,0 +1,171 @@
+import { sql } from "bun";
+import { lazySync } from "../_internal/process-sync";
+import { logger, trace } from "../services/logging";
+import { superviseRuntimeTask } from "../services/runtime-lifecycle";
+import { aiModelAccess } from "./model-access";
+import { aiProjects } from "./projects";
+import { AiTranscriptionError, describeTranscriptionFailure, runAiTranscription, type RunAiTranscriptionInput } from "./transcription";
+
+const log = logger("ai:dictations");
+const queue = lazySync((sync) =>
+  sync.queue<{ id: string }>({ id: "cloud-ai-dictations", owner: "cloud", delivery: { ackWaitMs: 45_000, maxAttempts: 50 } }),
+);
+export const enqueueAiDictation = async (shortId: string): Promise<void> => {
+  const [task] = await sql<
+    { id: string }[]
+  >`SELECT id FROM ai.dictations WHERE short_id = ${shortId} AND status = 'queued' AND disposition = 'pending'`;
+  if (task) await queue().send({ data: { id: task.id }, orderingKey: task.id });
+};
+const MAX_ATTEMPTS = 3; // Same automatic attempt budget as workflow inference.
+const LEASE_MS = 45_000;
+
+type ClaimedDictation = {
+  id: string;
+  conversation_id: string;
+  user_id: string;
+  source_path: string;
+  source_bytes: Uint8Array;
+  language: string | null;
+  model_profile_id: string;
+  attempts: number;
+};
+
+/** Nessi 0.12 exposes normalized messages, not typed HTTP errors. Fail closed for unknown errors. */
+export const isRetryableDictationError = (error: unknown): boolean => {
+  if (error instanceof AiTranscriptionError) return error.retryable;
+  if (!(error instanceof Error)) return false;
+  return (
+    /^(openai|openai-compatible) (408|409|425|429|5\d\d): /.test(error.message) ||
+    /^(openai|openai-compatible) connection failed: /.test(error.message)
+  );
+};
+
+export const processAiDictation = async (
+  id: string,
+  signal: AbortSignal,
+  run: (input: RunAiTranscriptionInput) => Promise<{ text: string; modelProfileId: string }> = runAiTranscription,
+): Promise<void> => {
+  const token = crypto.randomUUID();
+  const [task] = await sql<ClaimedDictation[]>`
+    UPDATE ai.dictations SET status = 'running', lease_token = ${token}, lease_until = now() + ${LEASE_MS} * interval '1 millisecond', attempts = attempts + 1, updated_at = now()
+    WHERE id = ${id} AND disposition = 'pending' AND source_bytes IS NOT NULL AND attempts < ${MAX_ATTEMPTS}
+      AND ((status = 'queued' AND next_attempt_at <= now()) OR (status = 'running' AND lease_until < now()))
+    RETURNING id, conversation_id, user_id, source_path, source_bytes, language, model_profile_id, attempts
+  `;
+  if (!task) return;
+  const span = await trace.start({
+    name: "ai.dictation",
+    source: "ai:dictations",
+    category: "ai",
+    attributes: { dictationId: id, conversationId: task.conversation_id, modelProfileId: task.model_profile_id, attempt: task.attempts },
+  });
+  let failure: AiTranscriptionError | undefined;
+  const canceled = new AbortController();
+  const combined = AbortSignal.any([signal, canceled.signal]);
+  let checking = false;
+  const heartbeat = async () => {
+    if (checking) return;
+    checking = true;
+    try {
+      const [row] = await sql`UPDATE ai.dictations d SET lease_until = now() + ${LEASE_MS} * interval '1 millisecond'
+        FROM ai.conversations c WHERE d.id = ${id} AND d.lease_token = ${token} AND d.status = 'running' AND d.disposition = 'pending'
+          AND c.id = d.conversation_id AND c.created_by_user_id = d.user_id AND c.archived_at IS NULL RETURNING d.id`;
+      if (!row) canceled.abort();
+    } catch {
+      canceled.abort();
+    } finally {
+      checking = false;
+    }
+  };
+  const timer = setInterval(() => void heartbeat(), 3_000);
+  try {
+    const [conversation] = await sql<
+      { project_id: string | null }[]
+    >`SELECT project_id FROM ai.conversations WHERE id = ${task.conversation_id} AND created_by_user_id = ${task.user_id} AND archived_at IS NULL`;
+    if (!conversation) throw new Error("Conversation unavailable.");
+    const subject = { type: "user" as const, userId: task.user_id };
+    await aiModelAccess.assertAllowed(task.model_profile_id, subject);
+    if (conversation.project_id && !(await aiProjects.snapshot(conversation.project_id, subject)))
+      throw new Error("Project access unavailable.");
+    const result = await run({
+      task: "dictation",
+      traceParent: span,
+      file: new Blob([new Uint8Array(task.source_bytes)]),
+      filename: task.source_path,
+      requestedModelId: task.model_profile_id,
+      language: task.language ?? undefined,
+      signal: combined,
+      attribution: { userId: task.user_id, conversationId: task.conversation_id },
+    });
+    combined.throwIfAborted();
+    // Same text payload ceiling as the existing file-write endpoint.
+    if (result.text.length > 12_000_000) throw new Error("Transcript exceeds the text file limit.");
+    await sql`UPDATE ai.dictations SET status = 'succeeded', result = ${result.text}, source_bytes = NULL, lease_token = NULL, lease_until = NULL, error_code = NULL, updated_at = now()
+      WHERE id = ${id} AND lease_token = ${token} AND status = 'running' AND disposition = 'pending'`;
+  } catch (error) {
+    failure = describeTranscriptionFailure(error, "configuration", combined.aborted);
+    const interrupted = signal.aborted;
+    const retry = !canceled.signal.aborted && task.attempts < MAX_ATTEMPTS && (interrupted || isRetryableDictationError(error));
+    log[combined.aborted ? "info" : retry ? "warn" : "error"](failure.message, {
+      dictationId: id,
+      traceId: span.traceId,
+      modelProfileId: task.model_profile_id,
+      attempt: task.attempts,
+      retry,
+      errorCode: failure.code,
+    });
+    await sql`UPDATE ai.dictations SET status = ${retry ? "queued" : "failed"}, lease_token = NULL, lease_until = NULL,
+      error_code = ${retry ? null : failure.code}, next_attempt_at = now() + ${task.attempts * 2} * interval '1 second', updated_at = now()
+      WHERE id = ${id} AND lease_token = ${token} AND status = 'running' AND disposition = 'pending'`;
+  } finally {
+    clearInterval(timer);
+    await trace.end({ context: span, status: failure ? "error" : "ok", statusMessage: failure?.message });
+  }
+};
+
+/** DB recovery is authoritative, including a crash after upload commit but before enqueue. */
+export const sweepAiDictations = async (): Promise<void> => {
+  await sql`UPDATE ai.dictations SET status = 'failed', error_code = 'attempts_exhausted', lease_token = NULL, lease_until = NULL, updated_at = now()
+    WHERE disposition = 'pending' AND attempts >= ${MAX_ATTEMPTS} AND (status = 'queued' OR (status = 'running' AND lease_until < now()))`;
+  const tasks = await sql<{ id: string }[]>`SELECT id FROM ai.dictations WHERE disposition = 'pending'
+    AND ((status = 'queued' AND next_attempt_at <= now()) OR (status = 'running' AND lease_until < now())) ORDER BY updated_at LIMIT 100`;
+  for (const task of tasks) await queue().send({ data: { id: task.id }, orderingKey: task.id });
+};
+
+export const startAiDictationRuntime = (): (() => void) => {
+  const controller = new AbortController();
+  void superviseRuntimeTask({
+    name: "AI dictation worker",
+    signal: controller.signal,
+    run: async (signal) => {
+      const worker = await queue().process({ concurrency: 2, signal }, (message) => processAiDictation(message.data.id, message.signal));
+      try {
+        await new Promise<void>((resolve) => {
+          if (signal.aborted) resolve();
+          else signal.addEventListener("abort", () => resolve(), { once: true });
+        });
+      } finally {
+        worker.stop();
+      }
+    },
+    onError: () => log.warn("Dictation worker unavailable; retrying"),
+  });
+  let sweeping = false;
+  const sweep = async () => {
+    if (sweeping || controller.signal.aborted) return;
+    sweeping = true;
+    try {
+      await sweepAiDictations();
+    } catch {
+      log.warn("Dictation recovery unavailable; retrying");
+    } finally {
+      sweeping = false;
+    }
+  };
+  void sweep();
+  const timer = setInterval(() => void sweep(), 15_000);
+  return () => {
+    controller.abort();
+    clearInterval(timer);
+  };
+};

package/src/ai/dictations.ts

@@ -0,0 +1,188 @@
+import { sql } from "bun";
+import { z } from "zod";
+import { inspectAiAudio } from "./audio-format";
+import { createUniqueAiFileInTransaction } from "./files-store";
+import { AiSaveConversationDraftInputSchema } from "./http";
+import { withAiShortIdForDb } from "./short-id";
+import { saveAiDraftInTransaction } from "./store";
+import type { AiResolvedAudioModel } from "./transcription";
+
+export const AiDictationStartSchema = z.object({
+  operationId: z.uuid(),
+  language: z
+    .string()
+    .regex(/^[a-z]{2}$/)
+    .optional(),
+});
+export const AiDictationListSchema = z.object({ after: z.uuid().optional(), limit: z.coerce.number().int().min(1).max(50).default(20) });
+export type AiDictationStatus = "queued" | "running" | "succeeded" | "failed" | "canceled";
+export type AiDictationDisposition = "pending" | "applied" | "discarded";
+export type AiDictation = {
+  id: string;
+  sourcePath: string;
+  operationId: string;
+  status: AiDictationStatus;
+  disposition: AiDictationDisposition;
+  errorCode: string | null;
+  createdAt: string;
+};
+type DictationRow = {
+  id: string;
+  short_id: string;
+  operation_id: string;
+  source_path: string;
+  status: AiDictationStatus;
+  disposition: AiDictationDisposition;
+  error_code: string | null;
+  created_at: Date;
+  result: string | null;
+  request_hash: string;
+};
+const publicDictation = (row: DictationRow): AiDictation => ({
+  id: row.short_id,
+  sourcePath: row.source_path,
+  operationId: row.operation_id,
+  status: row.status,
+  disposition: row.disposition,
+  errorCode: row.error_code,
+  createdAt: row.created_at.toISOString(),
+});
+export class AiDictationConflict extends Error {}
+
+const lockConversation = async (tx: typeof sql, conversationId: string, userId: string) => {
+  const [row] =
+    await tx`SELECT id FROM ai.conversations WHERE id = ${conversationId} AND created_by_user_id = ${userId} AND archived_at IS NULL FOR UPDATE`;
+  if (!row) throw new Error("Conversation is unavailable.");
+};
+
+export const aiDictations = {
+  async start(input: {
+    conversationId: string;
+    userId: string;
+    operationId: string;
+    bytes: Uint8Array;
+    language?: string;
+    resolveModel: () => Promise<AiResolvedAudioModel>;
+  }): Promise<AiDictation> {
+    AiDictationStartSchema.parse(input);
+    const format = inspectAiAudio(input.bytes);
+    const hash = new Bun.CryptoHasher("sha256")
+      .update(input.bytes)
+      .update(JSON.stringify({ language: input.language ?? null }))
+      .digest("hex");
+    return sql.begin(async (tx) => {
+      await lockConversation(tx, input.conversationId, input.userId);
+      const [canceled] = await tx`SELECT operation_id FROM ai.dictation_cancellations
+        WHERE conversation_id = ${input.conversationId} AND user_id = ${input.userId} AND operation_id = ${input.operationId}`;
+      if (canceled) throw new AiDictationConflict("This recording operation was discarded.");
+      const [previous] = await tx<
+        DictationRow[]
+      >`SELECT * FROM ai.dictations WHERE conversation_id = ${input.conversationId} AND user_id = ${input.userId} AND operation_id = ${input.operationId}`;
+      if (previous) {
+        if (previous.request_hash !== hash)
+          throw new AiDictationConflict("This recording operation already has different audio or options.");
+        return publicDictation(previous);
+      }
+      const [pending] =
+        await tx`SELECT id FROM ai.dictations WHERE conversation_id = ${input.conversationId} AND disposition = 'pending' LIMIT 1`;
+      if (pending) throw new AiDictationConflict("Finish or discard the pending dictation before starting another.");
+      const model = await input.resolveModel();
+      const row = await withAiShortIdForDb(tx, "ai_dictations_short_id_key", async (db, shortId) => {
+        const [created] = await db<DictationRow[]>`
+          INSERT INTO ai.dictations (short_id, conversation_id, user_id, operation_id, request_hash, source_path, source_bytes, media_type, model_profile_id, language)
+          VALUES (${shortId}, ${input.conversationId}, ${input.userId}, ${input.operationId}, ${hash}, ${`/dictation-${shortId}.${format.extension}`}, ${input.bytes}, ${format.mediaType}, ${model.profile.id}, ${input.language ?? null}) RETURNING *
+        `;
+        return created!;
+      });
+      // The inserted snapshot is already counted by the normal file-write quota.
+      const file = await createUniqueAiFileInTransaction(tx, {
+        conversationId: input.conversationId,
+        path: row.source_path,
+        bytes: input.bytes,
+        mediaType: format.mediaType,
+        origin: "user",
+        dictationRecordedAt: new Date(row.created_at).toISOString(),
+      });
+      await tx`UPDATE ai.dictations SET source_path = ${file.path} WHERE id = ${row.id}`;
+      return publicDictation({ ...row, source_path: file.path });
+    });
+  },
+  async list(input: { conversationId: string; userId: string; after?: string; limit?: number }) {
+    const limit = Math.min(50, Math.max(1, input.limit ?? 20));
+    // Cursor is opaque to the UI but validated as a UUID at the API boundary.
+    const rows = await sql<DictationRow[]>`
+      SELECT d.id, d.short_id, d.operation_id, d.source_path, d.status, d.disposition, d.error_code, d.created_at
+      FROM ai.dictations d JOIN ai.conversations c ON c.id = d.conversation_id
+      WHERE d.conversation_id = ${input.conversationId} AND c.created_by_user_id = ${input.userId} AND c.archived_at IS NULL
+        AND d.disposition = 'pending' AND (${input.after ?? null}::uuid IS NULL OR d.id > ${input.after ?? null}::uuid)
+      ORDER BY d.id LIMIT ${limit + 1}
+    `;
+    return { items: rows.slice(0, limit).map(publicDictation), nextCursor: rows.length > limit ? rows[limit - 1]!.id : null };
+  },
+  async get(input: { conversationId: string; userId: string; id: string }) {
+    const [row] = await sql<DictationRow[]>`
+      SELECT d.* FROM ai.dictations d JOIN ai.conversations c ON c.id = d.conversation_id
+      WHERE d.conversation_id = ${input.conversationId} AND c.created_by_user_id = ${input.userId} AND c.archived_at IS NULL AND d.short_id = ${input.id}
+    `;
+    return row ? { ...publicDictation(row), text: row.result } : null;
+  },
+  async discard(input: { conversationId: string; userId: string; id: string }) {
+    return sql.begin(async (tx) => {
+      await lockConversation(tx, input.conversationId, input.userId);
+      await tx`UPDATE ai.dictations SET disposition = 'discarded', status = CASE WHEN status IN ('queued', 'running') THEN 'canceled' ELSE status END,
+        source_bytes = NULL, lease_token = NULL, lease_until = NULL, updated_at = now()
+        WHERE conversation_id = ${input.conversationId} AND user_id = ${input.userId} AND short_id = ${input.id} AND disposition = 'pending'`;
+    });
+  },
+  async discardOperation(input: { conversationId: string; userId: string; operationId: string }) {
+    z.uuid().parse(input.operationId);
+    return sql.begin(async (tx) => {
+      // Same lock as start/apply: the marker also fences a start that has not arrived yet.
+      await lockConversation(tx, input.conversationId, input.userId);
+      const [row] = await tx<DictationRow[]>`SELECT * FROM ai.dictations
+        WHERE conversation_id = ${input.conversationId} AND user_id = ${input.userId} AND operation_id = ${input.operationId}`;
+      if (row?.disposition === "applied") return { disposition: "applied" as const };
+      await tx`INSERT INTO ai.dictation_cancellations (conversation_id, user_id, operation_id)
+        VALUES (${input.conversationId}, ${input.userId}, ${input.operationId}) ON CONFLICT DO NOTHING`;
+      await tx`UPDATE ai.dictations SET disposition = 'discarded', status = 'canceled',
+        source_bytes = NULL, lease_token = NULL, lease_until = NULL, updated_at = now()
+        WHERE conversation_id = ${input.conversationId} AND user_id = ${input.userId} AND operation_id = ${input.operationId}
+          AND disposition = 'pending'`;
+      return { disposition: "discarded" as const };
+    });
+  },
+  async retry(input: { conversationId: string; userId: string; id: string }) {
+    return sql.begin(async (tx) => {
+      await lockConversation(tx, input.conversationId, input.userId);
+      await tx`UPDATE ai.dictations SET status = 'queued', attempts = 0, error_code = NULL, next_attempt_at = now(), updated_at = now()
+        WHERE conversation_id = ${input.conversationId} AND user_id = ${input.userId} AND short_id = ${input.id}
+          AND status = 'failed' AND disposition = 'pending' AND source_bytes IS NOT NULL`;
+    });
+  },
+  async apply(input: { conversationId: string; userId: string; id: string } & z.infer<typeof AiSaveConversationDraftInputSchema>) {
+    AiSaveConversationDraftInputSchema.parse(input);
+    return sql.begin(async (tx) => {
+      await lockConversation(tx, input.conversationId, input.userId);
+      const [row] = await tx<
+        DictationRow[]
+      >`SELECT * FROM ai.dictations WHERE conversation_id = ${input.conversationId} AND user_id = ${input.userId} AND short_id = ${input.id} FOR UPDATE`;
+      if (!row) throw new Error("Dictation is unavailable.");
+      if (row.disposition !== "pending") return { disposition: row.disposition, draft: null };
+      if (row.status !== "succeeded" || row.result === null) throw new AiDictationConflict("Dictation is not ready.");
+      const text = [...input.content.filter((part) => part.type === "text").map((part) => part.text), row.result]
+        .filter(Boolean)
+        .join("\n\n");
+      const content = [...(text ? [{ type: "text" as const, text }] : []), ...input.content.filter((part) => part.type !== "text")];
+      AiSaveConversationDraftInputSchema.parse({ expectedRevision: input.expectedRevision, content });
+      const saved = await saveAiDraftInTransaction(tx, {
+        conversationId: input.conversationId,
+        ownerUserId: input.userId,
+        expectedRevision: input.expectedRevision,
+        content,
+      });
+      if (!saved.ok) throw new AiDictationConflict("The conversation draft changed. Review the saved draft before inserting.");
+      await tx`UPDATE ai.dictations SET disposition = 'applied', updated_at = now() WHERE id = ${row.id}`;
+      return { disposition: "applied" as const, draft: saved.draft };
+    });
+  },
+};

package/src/ai/draft-content.ts

@@ -0,0 +1,34 @@
+import type { AiDraftContentPart } from "./types";
+
+export const aiDraftPartLabel = (part: AiDraftContentPart): string => part.type === "text" ? part.text
+  : part.type === "resource" ? part.title ?? part.ref.id
+  : part.type === "project-file" ? part.path : part.path.split("/").at(-1) || part.path;
+
+export const aiDraftText = (content: readonly AiDraftContentPart[]) => content.map(part =>
+  part.type === "text" || part.inline ? aiDraftPartLabel(part) : "").join("");
+
+/** Queue text edits preserve untouched inline identities and ordinary attachments. */
+export function editAiDraftText(content: readonly AiDraftContentPart[], text: string): AiDraftContentPart[] {
+  const before = aiDraftText(content);
+  let start = 0, oldEnd = before.length, newEnd = text.length;
+  while (start < oldEnd && start < newEnd && before[start] === text[start]) start++;
+  while (oldEnd > start && newEnd > start && before[oldEnd - 1] === text[newEnd - 1]) { oldEnd--; newEnd--; }
+  let position = 0;
+  const retained = content.flatMap(part => {
+    if (part.type === "text") { position += part.text.length; return []; }
+    if (!part.inline) return [];
+    const from = position; position += aiDraftPartLabel(part).length;
+    if (position <= start) return [{ from, end: position, part }];
+    if (from >= oldEnd) return [{ from: from + newEnd - oldEnd, end: position + newEnd - oldEnd, part }];
+    return [];
+  });
+  const result: AiDraftContentPart[] = [];
+  let offset = 0;
+  for (const item of retained) {
+    if (item.from > offset) result.push({ type: "text", text: text.slice(offset, item.from) });
+    result.push(item.part); offset = item.end;
+  }
+  if (offset < text.length) result.push({ type: "text", text: text.slice(offset) });
+  result.push(...content.filter(part => part.type !== "text" && !part.inline));
+  return result;
+}

package/src/ai/enrich.ts

@@ -1,3 +1,4 @@
+import { AiBackgroundAdmissionError, AiBackgroundCostError } from "./inference-calls";
 import { z } from "zod";
 import { coreSettings } from "../services";
 import type { TraceContext } from "../services/logging";
@@ -257,6 +258,11 @@ export const enrichDirtyAiConversations = async (input: {
         try {
           await enrichOne(conversation, span);
         } catch (error) {
+          if (error instanceof AiBackgroundCostError || error instanceof AiBackgroundAdmissionError) {
+            summary.skipped += 1;
+            await store.recordEnrichmentRun({ conversationId: conversation.id, status: "skipped", trigger });
+            break;
+          }
           // Stays dirty; the failure marker backs it off so one poison chat
           // cannot burn a model call every single slot.
           summary.failed += 1;