@k2b/cloud 0.6.0 → 0.8.0

package/src/ai/memory-learning.ts

@@ -1,20 +1,21 @@
-import { sql } from "bun";
 import { createHash } from "node:crypto";
+import { sql } from "bun";
 import { z } from "zod";
 import { CloudResourceRefSchema } from "../contracts/capabilities";
 import { coreSettings } from "../services";
 import { logger } from "../services/logging";
 import { normalizeLocale } from "../shared/locale";
 import { parseAiAttachmentMarkers } from "./attachments";
+import { AiBackgroundAdmissionError, AiBackgroundCostError } from "./inference-calls";
+import { type AiBackgroundMemoryProposal, aiMemories } from "./memories";
 import { type AiMemoryLearningChange, aiMemoryLearningRuns } from "./memory-learning-runs";
 import {
+  type AiMemoryWorkflowEvidence,
+  type AiMemoryWorkflowPattern,
   listAiPendingWorkflowPatterns,
   listAiTurnWorkflowEvidence,
   markAiWorkflowPatternReviewed,
-  type AiMemoryWorkflowEvidence,
-  type AiMemoryWorkflowPattern,
 } from "./memory-workflow-evidence";
-import { type AiBackgroundMemoryProposal, aiMemories } from "./memories";
 import { aiConversations } from "./store";
 import type { RunAiStructuredInput, RunAiStructuredResult } from "./structured";
 import { resolveAiBackgroundModel, runAiStructured } from "./structured";
@@ -217,13 +218,7 @@ export const buildMemoryLearningTranscript = (messages: AiStoredMessage[]): stri
   messages
     .flatMap((stored) => {
       const message = stored.message;
-      if (
-        stored.kind !== "message" ||
-        message.role !== "user" ||
-        stored.meta?.agentMessage ||
-        stored.meta?.scheduledTask
-      )
-        return [];
+      if (stored.kind !== "message" || message.role !== "user" || stored.meta?.agentMessage || stored.meta?.scheduledTask) return [];
       return message.content.flatMap((part) => {
         if (typeof part === "string") return part.trim() ? [part.trim()] : [];
         if (part.type !== "text") return [];
@@ -305,7 +300,15 @@ const estimatedTokens = (systemPrompt: string, taskInput: string): number =>
 
 const workflowEvidenceKey = (pattern: AiMemoryWorkflowPattern): string =>
   createHash("sha256")
-    .update(JSON.stringify([pattern.userId, pattern.capabilityId, pattern.resourceRef.type, pattern.resourceRef.id, ...[...pattern.turnIds].sort()]))
+    .update(
+      JSON.stringify([
+        pattern.userId,
+        pattern.capabilityId,
+        pattern.resourceRef.type,
+        pattern.resourceRef.id,
+        ...[...pattern.turnIds].sort(),
+      ]),
+    )
     .digest("hex");
 
 const toProposal = (change: z.infer<typeof AiMemoryLearningChangeSchema>): AiBackgroundMemoryProposal => ({
@@ -329,7 +332,8 @@ const applyChanges = async (
       !evidence.actions.some(
         (action) => action.resourceRef.type === change.resourceRef?.type && action.resourceRef.id === change.resourceRef.id,
       )
-    ) continue;
+    )
+      continue;
     const results = await aiMemories.applyBackgroundProposal({
       userId: evidence.candidate.userId,
       sourceConversationId: evidence.candidate.conversationId,
@@ -376,9 +380,7 @@ const workflowPatternInput = async (
   return {
     source: evidence[0] ?? null,
     mutableMemoryIds: new Set(
-      selected.memories
-        .filter((memory) => memory.source === "background" && memory.priority === "normal")
-        .map((memory) => memory.shortId),
+      selected.memories.filter((memory) => memory.source === "background" && memory.priority === "normal").map((memory) => memory.shortId),
     ),
     input: [
       `CAPABILITY: ${pattern.capabilityId}`,
@@ -395,7 +397,8 @@ const workflowPatternInput = async (
 const usageNumbers = (usage: RunAiStructuredResult<z.ZodType>["usage"], reserved: number) => {
   const inputTokens = usage?.input;
   const outputTokens = usage?.output;
-  const total = usage?.total ?? (inputTokens !== undefined || outputTokens !== undefined ? (inputTokens ?? 0) + (outputTokens ?? 0) : undefined);
+  const total =
+    usage?.total ?? (inputTokens !== undefined || outputTokens !== undefined ? (inputTokens ?? 0) + (outputTokens ?? 0) : undefined);
   return { inputTokens, outputTokens, accountedTokens: total ?? reserved };
 };
 
@@ -414,8 +417,7 @@ export const learnAiMemoriesFromPrivateChats = async (
   }
 
   const configuredBudget =
-    input.deps?.monthlyTokenBudget ??
-    Number(await coreSettings.get<number>(AI_MEMORY_LEARNING_MONTHLY_TOKEN_BUDGET_SETTING_KEY));
+    input.deps?.monthlyTokenBudget ?? Number(await coreSettings.get<number>(AI_MEMORY_LEARNING_MONTHLY_TOKEN_BUDGET_SETTING_KEY));
   const monthlyTokenBudget =
     Number.isFinite(configuredBudget) && configuredBudget > 0
       ? Math.floor(configuredBudget)
@@ -432,9 +434,7 @@ export const learnAiMemoriesFromPrivateChats = async (
   let defaultLocale: Promise<string> | undefined;
   const resolveLearningLocale = (locale?: string | null): Promise<string> => {
     if (locale) return Promise.resolve(normalizeLocale(locale));
-    defaultLocale ??= (input.deps?.readDefaultLocale ?? (() => coreSettings.get<string>("app.locale")))().then(
-      normalizeLocale,
-    );
+    defaultLocale ??= (input.deps?.readDefaultLocale ?? (() => coreSettings.get<string>("app.locale")))().then(normalizeLocale);
     return defaultLocale;
   };
 
@@ -514,6 +514,18 @@ export const learnAiMemoriesFromPrivateChats = async (
       if (status === "skipped") summary.skipped += 1;
       processedCandidates += 1;
     } catch (error) {
+      if (error instanceof AiBackgroundCostError || error instanceof AiBackgroundAdmissionError) {
+        summary.skipped += 1;
+        if (runId)
+          await aiMemoryLearningRuns.finish({
+            runId,
+            status: "skipped",
+            durationMs: Date.now() - startedAt,
+            changes: [],
+            accountedTokens: 0,
+          });
+        return summary;
+      }
       summary.failed += 1;
       processedCandidates += 1;
       await markFailed(candidate).catch(() => undefined);
@@ -564,7 +576,11 @@ export const learnAiMemoriesFromPrivateChats = async (
       if (!runId) continue;
       const result = await structured({
         task: "memory-learn-workflow",
-        attribution: { userId: pattern.userId, conversationId: context.source.candidate.conversationId, turnId: context.source.candidate.turnId },
+        attribution: {
+          userId: pattern.userId,
+          conversationId: context.source.candidate.conversationId,
+          turnId: context.source.candidate.turnId,
+        },
         appId: "ai",
         systemPrompt: workflowPrompt,
         input: context.input,
@@ -578,15 +594,19 @@ export const learnAiMemoriesFromPrivateChats = async (
       if (result.output.workflow && (await learningEnabled(pattern.userId))) {
         const memoryIds = result.output.workflow.memoryIds;
         const action = memoryIds.length > 1 ? "merge" : memoryIds.length === 1 ? "replace" : "add";
-        changes = await applyChanges(context.source, [
-          {
-            action,
-            kind: "workflow",
-            content: result.output.workflow.content,
-            memoryIds,
-            resourceRef: pattern.resourceRef,
-          },
-        ], context.mutableMemoryIds);
+        changes = await applyChanges(
+          context.source,
+          [
+            {
+              action,
+              kind: "workflow",
+              content: result.output.workflow.content,
+              memoryIds,
+              resourceRef: pattern.resourceRef,
+            },
+          ],
+          context.mutableMemoryIds,
+        );
       }
       await markAiWorkflowPatternReviewed(pattern);
       await aiMemoryLearningRuns.finish({
@@ -600,6 +620,18 @@ export const learnAiMemoriesFromPrivateChats = async (
       summary.updated += changes.filter((change) => change.action === "updated" || change.action === "merged").length;
       if (changes.length === 0) summary.skipped += 1;
     } catch (error) {
+      if (error instanceof AiBackgroundCostError || error instanceof AiBackgroundAdmissionError) {
+        summary.skipped += 1;
+        if (runId)
+          await aiMemoryLearningRuns.finish({
+            runId,
+            status: "skipped",
+            durationMs: Date.now() - startedAt,
+            changes: [],
+            accountedTokens: 0,
+          });
+        return summary;
+      }
       summary.failed += 1;
       if (runId) {
         await aiMemoryLearningRuns

package/src/ai/memory-tool.ts

@@ -108,11 +108,7 @@ export const createCloudAiMemoryTool = (evidence = "") =>
     }
 
     const memory = await aiMemories.getByShortId(userId, input.id);
-    if (
-      memory &&
-      !memoryMutationSupportedByEvidence(evidence, input.id) &&
-      !memoryMutationSupportedByEvidence(evidence, memory.content)
-    ) {
+    if (memory && !memoryMutationSupportedByEvidence(evidence, input.id) && !memoryMutationSupportedByEvidence(evidence, memory.content)) {
       return { ok: false, message: "A memory can only be forgotten when the user identifies it in this turn." };
     }
     if (!memory || !(await aiMemories.deleteByShortId(userId, input.id))) return { ok: false, message: "Memory not found." };

package/src/ai/memory-workflow-evidence.ts

@@ -37,10 +37,15 @@ export const recordAiMemoryWorkflowEvidence = async (input: {
       input.resources.flatMap((resource) => {
         const parsed = CloudResourceRefSchema.safeParse(resource.ref);
         if (!parsed.success) return [];
-        return [[`${parsed.data.type}\0${parsed.data.id}`, {
-          ref: parsed.data,
-          ...(resource.title ? { title: resource.title.trim().slice(0, MAX_RESOURCE_TITLE_CHARS) } : {}),
-        }] as const];
+        return [
+          [
+            `${parsed.data.type}\0${parsed.data.id}`,
+            {
+              ref: parsed.data,
+              ...(resource.title ? { title: resource.title.trim().slice(0, MAX_RESOURCE_TITLE_CHARS) } : {}),
+            },
+          ] as const,
+        ];
       }),
     ).values(),
   ].slice(0, MAX_RECEIPT_RESOURCES);

package/src/ai/message-queue.ts

@@ -0,0 +1,178 @@
+import { sql } from "bun";
+import { logger } from "../services/logging";
+import { aiChatAccessSubject, isAssistantChatTurn } from "./assistant-models";
+import { editAiDraftText } from "./draft-content";
+import { canonicalizeAiConversationAttachments } from "./file-context";
+import { AI_FILES_MAX_CONVERSATION_BYTES_DEFAULT } from "./files-store";
+import { aiInputToUserMessage, aiTurnInputToContent } from "./http";
+import { AiQuotaError, aiQuotas } from "./quotas";
+import { aiResourceMarker } from "./resource-markers";
+import { aiConversations } from "./store";
+import type { AiConversationService, AiDraftContentPart } from "./types";
+
+const log = logger("ai:message-queue");
+export const AI_MESSAGE_QUEUE_LIMIT = 32;
+export class AiMessageQueueConflict extends Error {}
+
+type Submission = Parameters<AiConversationService["submitChatTurn"]>[0];
+
+export const migrateAiMessageQueue = async () => {
+  await sql`CREATE TABLE IF NOT EXISTS ai.queued_messages (
+    id uuid PRIMARY KEY, conversation_id uuid NOT NULL REFERENCES ai.conversations(id) ON DELETE CASCADE,
+    position bigint GENERATED ALWAYS AS IDENTITY, submission jsonb NOT NULL, content jsonb NOT NULL,
+    status text NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','failed','submitted','cancelled')),
+    error text, created_at timestamptz NOT NULL DEFAULT now()
+  )`.simple();
+  await sql`ALTER TABLE ai.queued_messages ADD COLUMN IF NOT EXISTS quota_checked_at TIMESTAMPTZ`.simple();
+  await sql`CREATE INDEX IF NOT EXISTS ai_queued_messages_pending ON ai.queued_messages(conversation_id, position) WHERE status IN ('pending','failed')`.simple();
+  await sql`CREATE TABLE IF NOT EXISTS ai.queued_message_files (
+    message_id uuid NOT NULL REFERENCES ai.queued_messages(id) ON DELETE CASCADE,
+    path text NOT NULL, bytes bytea NOT NULL, media_type text NOT NULL, size bigint NOT NULL,
+    origin text NOT NULL, dictation_recorded_at timestamptz, updated_at timestamptz NOT NULL, version bigint NOT NULL,
+    PRIMARY KEY(message_id, path)
+  )`.simple();
+  await sql`DROP TRIGGER IF EXISTS ai_live_queued_messages_changed ON ai.queued_messages`.simple();
+  await sql`CREATE TRIGGER ai_live_queued_messages_changed AFTER INSERT OR DELETE ON ai.queued_messages
+    FOR EACH ROW EXECUTE FUNCTION ai.live_conversation_child_changed('conversation-detail,conversation-list')`.simple();
+  await sql`DROP TRIGGER IF EXISTS ai_live_queued_messages_updated ON ai.queued_messages`.simple();
+  await sql`CREATE TRIGGER ai_live_queued_messages_updated AFTER UPDATE ON ai.queued_messages
+    FOR EACH ROW WHEN (OLD.status IS DISTINCT FROM NEW.status OR OLD.error IS DISTINCT FROM NEW.error OR OLD.content IS DISTINCT FROM NEW.content)
+    EXECUTE FUNCTION ai.live_conversation_child_changed('conversation-detail,conversation-list')`.simple();
+};
+
+export const listQueuedMessages = async (conversationId: string) => {
+  const rows = await sql<{ id: string; content: AiDraftContentPart[]; error: string | null }[]>`
+    SELECT id, content, error FROM ai.queued_messages
+    WHERE conversation_id = ${conversationId}::uuid AND status IN ('pending','failed') ORDER BY position`;
+  return rows.map((row) => ({ id: row.id, content: row.content, failed: Boolean(row.error) }));
+};
+
+export const queuedMessageAccepted = async (conversationId: string, id: string) => {
+  const [row] = await sql`SELECT id FROM ai.queued_messages WHERE id=${id}::uuid AND conversation_id=${conversationId}::uuid`;
+  return Boolean(row);
+};
+
+export const enqueueChatMessage = async (id: string, input: Submission, content: AiDraftContentPart[]) =>
+  sql.begin(async (tx) => {
+    const [conversation] = await tx<{ draft_revision: number; project_id: string | null }[]>`
+    SELECT draft_revision, project_id FROM ai.conversations WHERE id = ${input.conversationId}::uuid AND archived_at IS NULL FOR UPDATE`;
+    if (!conversation) throw new AiMessageQueueConflict("Conversation not found.");
+    const [existing] =
+      await tx`SELECT id FROM ai.queued_messages WHERE id = ${id}::uuid AND conversation_id = ${input.conversationId}::uuid`;
+    if (existing) return;
+    if (Number(conversation.draft_revision) !== input.expectedDraftRevision)
+      throw new AiMessageQueueConflict("Conversation draft changed before the message was queued.");
+    if (conversation.project_id !== input.expectedProjectId)
+      throw new AiMessageQueueConflict("Conversation Project changed before the message was queued.");
+    const [count] = await tx<
+      { count: number }[]
+    >`SELECT count(*)::int AS count FROM ai.queued_messages WHERE conversation_id = ${input.conversationId}::uuid AND status IN ('pending','failed')`;
+    if (count!.count >= AI_MESSAGE_QUEUE_LIMIT) throw new AiMessageQueueConflict("The message queue is full (32 messages).");
+    const [size] = await tx<
+      { size: number }[]
+    >`SELECT COALESCE(sum(f.size),0)::float8 AS size FROM ai.queued_message_files f JOIN ai.queued_messages q ON q.id = f.message_id WHERE q.conversation_id = ${input.conversationId}::uuid`;
+    if (
+      Number(size!.size) + (input.runConfig.files?.attached ?? []).reduce((sum, file) => sum + file.size, 0) >
+      AI_FILES_MAX_CONVERSATION_BYTES_DEFAULT
+    )
+      throw new AiMessageQueueConflict("Queued attachments exceed the conversation file budget.");
+    const { expectedDraftRevision, ...submission } = input;
+    await tx`INSERT INTO ai.queued_messages(id, conversation_id, submission, content) VALUES (${id}::uuid, ${input.conversationId}::uuid, (${JSON.stringify(submission)}::text)::jsonb, (${JSON.stringify(content)}::text)::jsonb)`;
+    for (const file of input.runConfig.files?.attached ?? []) {
+      const copied =
+        await tx`INSERT INTO ai.queued_message_files(message_id,path,bytes,media_type,size,origin,dictation_recorded_at,updated_at,version)
+      SELECT ${id}::uuid,path,bytes,media_type,size,origin,dictation_recorded_at,updated_at,version FROM ai.files
+      WHERE conversation_id = ${input.conversationId}::uuid AND path = ${file.path} AND version = ${file.version ?? -1} RETURNING path`;
+      if (!copied.length) throw new AiMessageQueueConflict("An attached file changed before the message was queued.");
+    }
+    await tx`UPDATE ai.conversations SET draft_content = '[]'::jsonb, draft_revision = draft_revision + 1, draft_updated_at = now(), last_used_at = now(), done = CASE WHEN done IS TRUE THEN NULL ELSE done END WHERE id = ${input.conversationId}::uuid`;
+  });
+
+/** Cancellation and retry share the conversation lock with promotion. */
+export const updateQueuedMessage = async (conversationId: string, id: string, action: "cancel" | "retry") =>
+  sql.begin(async (tx) => {
+    await tx`SELECT id FROM ai.conversations WHERE id = ${conversationId}::uuid FOR UPDATE`;
+    const changed = await tx`UPDATE ai.queued_messages SET status = ${action === "cancel" ? "cancelled" : "pending"}, error = NULL
+    WHERE id = ${id}::uuid AND conversation_id = ${conversationId}::uuid AND status IN ('pending','failed') RETURNING id`;
+    if (action === "cancel" && changed.length) {
+      await tx`DELETE FROM ai.queued_message_files WHERE message_id = ${id}::uuid`;
+      await tx`UPDATE ai.queued_messages SET submission = '{}'::jsonb, content = '[]'::jsonb WHERE id = ${id}::uuid`;
+    }
+    return Boolean(changed.length);
+  });
+
+/** Edit only queued text; immutable attachments and the independent composer draft stay intact. */
+export const editQueuedMessage = async (conversationId: string, id: string, text: string) =>
+  sql.begin(async (tx) => {
+    await tx`SELECT id FROM ai.conversations WHERE id = ${conversationId}::uuid FOR UPDATE`;
+    const [row] = await tx<{ submission: Submission; content: AiDraftContentPart[] }[]>`SELECT submission, content FROM ai.queued_messages
+    WHERE id = ${id}::uuid AND conversation_id = ${conversationId}::uuid AND status IN ('pending','failed') FOR UPDATE`;
+    if (!row) return false;
+    const content = editAiDraftText(row.content, text);
+    const parts = content.map((part) =>
+      part.type === "text"
+        ? part
+        : part.type === "project-file"
+          ? { type: "text" as const, text: `Project file: ${part.path}` }
+          : part.type === "file"
+            ? { type: "attachment" as const, path: part.path, mediaType: part.mediaType, size: part.size }
+            : { type: "text" as const, text: aiResourceMarker({ ref: part.ref, title: part.title, icon: part.icon, href: part.href }) },
+    );
+    const { message } = aiInputToUserMessage(aiTurnInputToContent({ content: parts }));
+    const userMessage = canonicalizeAiConversationAttachments(message, row.submission.runConfig.files);
+    if (userMessage.role !== "user") throw new Error("Queued message must be a user message.");
+    const submission = {
+      ...row.submission,
+      userMessage,
+      runConfig: {
+        ...row.submission.runConfig,
+        input: userMessage.content,
+        selectedSkillIds: [
+          ...new Set(content.flatMap((part) => (part.type === "resource" && part.ref.type === "core.ai.skill" ? [part.ref.id] : []))),
+        ],
+      },
+    };
+    await tx`UPDATE ai.queued_messages SET submission = (${JSON.stringify(submission)}::text)::jsonb,
+    content = (${JSON.stringify(content)}::text)::jsonb WHERE id = ${id}::uuid`;
+    return true;
+  });
+
+/** Existing turn creation owns execution and recovery; the DB lock owns FIFO and deduplication. */
+export const drainQueuedMessages = async (
+  enqueue: (job: { conversationId: string; turnId: string }) => Promise<unknown>,
+  conversationId?: string,
+) => {
+  const rows = await sql<{ id: string; conversation_id: string; submission: Submission }[]>`
+    SELECT q.id, q.conversation_id, q.submission FROM ai.queued_messages q
+    JOIN ai.conversations c ON c.id = q.conversation_id
+    WHERE (q.status = 'pending' OR (q.status = 'failed' AND q.error IN ('quota_exhausted','quota_usage_unknown'))) AND c.archived_at IS NULL AND c.created_by_user_id IS NOT NULL
+      AND (${conversationId ?? null}::uuid IS NULL OR q.conversation_id = ${conversationId ?? null}::uuid)
+      AND NOT EXISTS (SELECT 1 FROM ai.queued_messages earlier WHERE earlier.conversation_id = q.conversation_id AND earlier.position < q.position AND earlier.status IN ('pending','failed'))
+      AND NOT EXISTS (SELECT 1 FROM ai.turns t WHERE t.conversation_id = q.conversation_id AND NOT COALESCE(t.run_config ? 'background', false) AND t.status IN ('queued','running','waiting_for_action'))
+    ORDER BY q.quota_checked_at NULLS FIRST, q.position LIMIT ${AI_MESSAGE_QUEUE_LIMIT}`;
+  for (const row of rows) {
+    try {
+      const quotaSubject = aiChatAccessSubject(row.submission.runConfig.actor);
+      if (isAssistantChatTurn(row.submission.runConfig) && quotaSubject)
+        await aiQuotas.assertAllowed(quotaSubject, row.submission.modelProfileId);
+      await sql`UPDATE ai.queued_messages SET status='pending', error=NULL WHERE id=${row.id}::uuid AND status='failed' AND error IN ('quota_exhausted','quota_usage_unknown')`;
+      const result = await aiConversations.submitChatTurn({ ...row.submission, queuedMessageId: row.id });
+      await enqueue({ conversationId: row.conversation_id, turnId: result.turn.id });
+    } catch (error) {
+      if (error instanceof AiQuotaError) {
+        await sql`UPDATE ai.queued_messages SET status='failed', error=${error.code}, quota_checked_at=clock_timestamp() WHERE id=${row.id}::uuid AND status IN ('pending','failed')`;
+        continue;
+      }
+      // Another dispatcher may have consumed it or a new foreground turn may have won.
+      const reason = error instanceof Error ? error.message : String(error);
+      if (reason === "Queued message is no longer ready." || reason.includes("idx_ai_turns_one_active_per_conversation")) continue;
+      await sql`UPDATE ai.queued_messages SET status = 'failed', error = 'dispatch_failed' WHERE id = ${row.id}::uuid AND status = 'pending'`;
+      log.error("Queued message dispatch failed", {
+        conversationId: row.conversation_id,
+        messageId: row.id,
+        code: "queue_dispatch_failed",
+        errorType: error instanceof Error ? error.name : "unknown",
+      });
+    }
+  }
+};