@k2b/cloud 0.6.0 → 0.8.0

package/src/ai/migrate.ts

@@ -1,7 +1,8 @@
 import { sql } from "bun";
+import { migrateAiMessageQueue } from "./message-queue";
 import { migrateAiModelAccess } from "./model-access-migrate";
+import { migrateAiQuotas } from "./quotas-migrate";
 import { withAiShortId } from "./short-id";
-import { migrateAiTurnUsage } from "./usage-migrate";
 
 const backfillAiShortIds = async (
   constraint: string,
@@ -141,10 +142,21 @@ export const migrateCloudAi = async (): Promise<void> => {
   await sql`ALTER TABLE ai.conversations ADD COLUMN IF NOT EXISTS enrich_failed_at TIMESTAMPTZ`.simple();
   await sql`ALTER TABLE ai.conversations ADD COLUMN IF NOT EXISTS enrich_fail_count INTEGER NOT NULL DEFAULT 0`.simple();
   await sql`ALTER TABLE ai.conversations ADD COLUMN IF NOT EXISTS pinned_at TIMESTAMPTZ`.simple();
+  await sql`ALTER TABLE ai.conversations ADD COLUMN IF NOT EXISTS done BOOLEAN`.simple();
+  await sql`ALTER TABLE ai.conversations ADD COLUMN IF NOT EXISTS last_used_at TIMESTAMPTZ`.simple();
+  await sql`DO $$ BEGIN
+    IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = 'ai' AND table_name = 'conversations' AND column_name = 'done_at') THEN
+      UPDATE ai.conversations SET done = TRUE WHERE done_at IS NOT NULL;
+      ALTER TABLE ai.conversations DROP COLUMN done_at;
+    END IF;
+  END $$`.simple();
   await sql`ALTER TABLE ai.conversations ADD COLUMN IF NOT EXISTS last_viewed_at TIMESTAMPTZ NOT NULL DEFAULT now()`.simple();
   await sql`ALTER TABLE ai.conversations ALTER COLUMN last_viewed_at SET DEFAULT now()`.simple();
   await sql`UPDATE ai.conversations SET last_viewed_at = now() WHERE last_viewed_at IS NULL`.simple();
   await sql`ALTER TABLE ai.conversations ALTER COLUMN last_viewed_at SET NOT NULL`.simple();
+  await sql`UPDATE ai.conversations SET last_used_at = GREATEST(created_at, updated_at, last_viewed_at) WHERE last_used_at IS NULL`.simple();
+  await sql`ALTER TABLE ai.conversations ALTER COLUMN last_used_at SET DEFAULT now()`.simple();
+  await sql`ALTER TABLE ai.conversations ALTER COLUMN last_used_at SET NOT NULL`.simple();
   await sql`ALTER TABLE ai.conversations ADD COLUMN IF NOT EXISTS search_text TEXT NOT NULL DEFAULT ''`.simple();
   await sql`ALTER TABLE ai.conversations ADD COLUMN IF NOT EXISTS search_document TSVECTOR NOT NULL DEFAULT ''::tsvector`.simple();
   await sql`
@@ -242,7 +254,6 @@ export const migrateCloudAi = async (): Promise<void> => {
       input_tokens INTEGER CHECK (input_tokens >= 0),
       output_tokens INTEGER CHECK (output_tokens >= 0),
       total_tokens INTEGER CHECK (total_tokens >= 0),
-      credits_used DOUBLE PRECISION CHECK (credits_used >= 0),
       mode TEXT,
       repaired BOOLEAN,
       attempts INTEGER CHECK (attempts IS NULL OR attempts >= 1),
@@ -447,6 +458,7 @@ export const migrateCloudAi = async (): Promise<void> => {
   await sql`ALTER TABLE ai.turns ADD COLUMN IF NOT EXISTS lease_expires_at TIMESTAMPTZ`.simple();
   await sql`ALTER TABLE ai.turns ADD COLUMN IF NOT EXISTS heartbeat_at TIMESTAMPTZ`.simple();
   await sql`ALTER TABLE ai.turns ADD COLUMN IF NOT EXISTS run_config JSONB`.simple();
+  await sql`ALTER TABLE ai.turns ADD COLUMN IF NOT EXISTS run_budget_ms DOUBLE PRECISION`.simple();
   await sql`ALTER TABLE ai.turns ADD COLUMN IF NOT EXISTS attempt INTEGER NOT NULL DEFAULT 0`.simple();
   await sql`ALTER TABLE ai.turns ADD COLUMN IF NOT EXISTS live_blocks JSONB`.simple();
   await sql`ALTER TABLE ai.turns ADD COLUMN IF NOT EXISTS live_seq BIGINT NOT NULL DEFAULT 0`.simple();
@@ -464,9 +476,15 @@ export const migrateCloudAi = async (): Promise<void> => {
   `.simple();
 
   await sql`
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_ai_turns_one_active_per_conversation
-    ON ai.turns(conversation_id)
-    WHERE status IN ('queued', 'running', 'waiting_for_action')
+    DO $$ BEGIN
+      IF EXISTS (SELECT 1 FROM pg_indexes WHERE schemaname = 'ai'
+        AND indexname = 'idx_ai_turns_one_active_per_conversation' AND indexdef NOT LIKE '%background%') THEN
+        DROP INDEX ai.idx_ai_turns_one_active_per_conversation;
+      END IF;
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_ai_turns_one_active_per_conversation
+        ON ai.turns(conversation_id)
+        WHERE status IN ('queued', 'running', 'waiting_for_action') AND NOT COALESCE(run_config ? 'background', false);
+    END $$
   `.simple();
 
   await sql`
@@ -593,6 +611,14 @@ export const migrateCloudAi = async (): Promise<void> => {
     )
   `.simple();
 
+  await sql`CREATE TABLE IF NOT EXISTS ai.turn_generation_timings (
+    turn_id UUID NOT NULL REFERENCES ai.turns(id) ON DELETE CASCADE,
+    request_id TEXT NOT NULL,
+    started_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    ended_at TIMESTAMPTZ,
+    PRIMARY KEY (turn_id, request_id)
+  )`.simple();
+
   await sql`ALTER TABLE ai.pending_actions ADD COLUMN IF NOT EXISTS review JSONB`.simple();
 
   await sql`
@@ -670,9 +696,6 @@ export const migrateCloudAi = async (): Promise<void> => {
       location TEXT NOT NULL DEFAULT 'server',
       status TEXT NOT NULL DEFAULT 'pending',
       approval_state TEXT NOT NULL DEFAULT 'not_required',
-      input_meta JSONB,
-      output_meta JSONB,
-      error TEXT,
       created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
       started_at TIMESTAMPTZ,
       approval_requested_at TIMESTAMPTZ,
@@ -695,6 +718,23 @@ export const migrateCloudAi = async (): Promise<void> => {
   `.simple();
 
   await sql`ALTER TABLE ai.tool_calls ADD COLUMN IF NOT EXISTS idempotency_key TEXT`.simple();
+
+  // Capability shape, outcome, and latency belong to capabilities.executions,
+  // which the capability dispatcher writes exactly once. ai.tool_calls keeps
+  // only AI-specific state: approval, turn linkage, and the correlating
+  // request id shared with the execution record and the app's audit rows.
+  await sql`ALTER TABLE ai.tool_calls ADD COLUMN IF NOT EXISTS request_id TEXT`.simple();
+  await sql`
+    ALTER TABLE ai.tool_calls
+      DROP COLUMN IF EXISTS input_meta,
+      DROP COLUMN IF EXISTS output_meta,
+      DROP COLUMN IF EXISTS error
+  `.simple();
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_ai_tool_calls_request
+    ON ai.tool_calls(request_id)
+    WHERE request_id IS NOT NULL
+  `.simple();
   await sql`
     CREATE UNIQUE INDEX IF NOT EXISTS idx_ai_tool_calls_idempotency_key
     ON ai.tool_calls(idempotency_key)
@@ -1391,6 +1431,24 @@ export const migrateCloudAi = async (): Promise<void> => {
       CONSTRAINT ai_skills_extra_frontmatter_check CHECK (jsonb_typeof(extra_frontmatter) = 'object')
     )
   `.simple();
+  // pg_trgm is a standard PostgreSQL extension, also used by Mail and Grids.
+  await sql`CREATE EXTENSION IF NOT EXISTS pg_trgm`.simple();
+  await sql`ALTER TABLE ai.skills ADD COLUMN IF NOT EXISTS search_text TEXT
+    GENERATED ALWAYS AS (name || ' ' || description) STORED`.simple();
+  // Optional BM25 improves relevance without changing which Skills are visible.
+  try {
+    const [extension] = await sql<{ installed: boolean }[]>`
+      SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_textsearch') AS installed
+    `;
+    if (extension?.installed) {
+      await sql
+        .unsafe(`CREATE INDEX IF NOT EXISTS skills_search_bm25_idx
+        ON ai.skills USING bm25 ((search_text)) WITH (text_config='simple')`)
+        .simple();
+    }
+  } catch (error) {
+    console.warn("Optional Skill BM25 index unavailable; native Skill search remains active", error);
+  }
   await sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_ai_skills_short_id ON ai.skills(short_id)`.simple();
   await sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_ai_skills_name ON ai.skills(name)`.simple();
   await sql`ALTER TABLE ai.skills ADD COLUMN IF NOT EXISTS managed_key TEXT`.simple();
@@ -1401,6 +1459,12 @@ export const migrateCloudAi = async (): Promise<void> => {
       seeded_at TIMESTAMPTZ NOT NULL DEFAULT now()
     )
   `.simple();
+  // A seed's UUID deliberately has no FK: it is a durable deletion tombstone.
+  await sql`ALTER TABLE ai.skill_seeds ADD COLUMN IF NOT EXISTS skill_id UUID`.simple();
+  await sql`ALTER TABLE ai.skill_seeds ADD COLUMN IF NOT EXISTS catalog_version INTEGER NOT NULL DEFAULT 0`.simple();
+  await sql`ALTER TABLE ai.skills ADD COLUMN IF NOT EXISTS template_id TEXT,
+    ADD COLUMN IF NOT EXISTS template_version INTEGER, ADD COLUMN IF NOT EXISTS template_hash TEXT`.simple();
+  await sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_ai_skills_template_id ON ai.skills(template_id) WHERE template_id IS NOT NULL`.simple();
   await backfillAiShortIds(
     "idx_ai_skills_short_id",
     await sql<{ id: string }[]>`SELECT id FROM ai.skills WHERE short_id IS NULL`,
@@ -1558,6 +1622,15 @@ export const migrateCloudAi = async (): Promise<void> => {
   }
   await sql`ALTER TABLE ai.project_access ALTER COLUMN short_id SET NOT NULL`.simple();
 
+  // Skills and Projects are shared only with authenticated identities.
+  // Preserve each existing grant and permission level while closing anonymous access.
+  await sql`
+    UPDATE auth.access SET authenticated_only = true
+    WHERE user_id IS NULL AND group_id IS NULL AND service_account_id IS NULL
+      AND authenticated_only = false
+      AND id IN (SELECT access_id FROM ai.skill_access UNION SELECT access_id FROM ai.project_access)
+  `;
+
   await sql`
     CREATE TABLE IF NOT EXISTS ai.project_knowledge (
       id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
@@ -1624,6 +1697,15 @@ export const migrateCloudAi = async (): Promise<void> => {
       UNIQUE (project_id, resource_type, resource_id)
     )
   `.simple();
+  await sql`
+    CREATE TABLE IF NOT EXISTS ai.project_skills (
+      project_id UUID NOT NULL REFERENCES ai.projects(id) ON DELETE CASCADE,
+      skill_id UUID NOT NULL REFERENCES ai.skills(id) ON DELETE CASCADE,
+      PRIMARY KEY (project_id, skill_id)
+    )
+  `.simple();
+  await sql`CREATE INDEX IF NOT EXISTS idx_ai_project_skills_skill ON ai.project_skills(skill_id)`.simple();
+
   await sql`ALTER TABLE ai.project_resource_refs ADD COLUMN IF NOT EXISTS short_id TEXT`.simple();
   await sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_ai_project_resource_refs_short_id ON ai.project_resource_refs(project_id, short_id)`.simple();
   await backfillAiShortIds(
@@ -1661,7 +1743,7 @@ export const migrateCloudAi = async (): Promise<void> => {
       created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
       CONSTRAINT ai_live_invalidation_domains_check CHECK (
         cardinality(domains) > 0 AND domains <@ ARRAY[
-          'conversation-list', 'conversation-detail', 'conversation-sources', 'conversation-files', 'conversation-tasks',
+          'conversation-list', 'conversation-detail', 'conversation-sources', 'conversation-files', 'conversation-tasks', 'conversation-dictations',
           'project-list', 'project-detail', 'project-context'
         ]::text[]
       )
@@ -1918,6 +2000,11 @@ export const migrateCloudAi = async (): Promise<void> => {
     END
     $$ LANGUAGE plpgsql
   `.simple();
+  await sql`DROP TRIGGER IF EXISTS ai_live_project_skills_changed ON ai.project_skills`.simple();
+  await sql`
+    CREATE TRIGGER ai_live_project_skills_changed AFTER INSERT OR DELETE ON ai.project_skills
+    FOR EACH ROW EXECUTE FUNCTION ai.live_project_child_changed('project-detail,project-context')
+  `.simple();
   await sql`DROP TRIGGER IF EXISTS ai_live_project_knowledge_changed ON ai.project_knowledge`.simple();
   await sql`
     CREATE TRIGGER ai_live_project_knowledge_changed AFTER INSERT OR UPDATE OR DELETE ON ai.project_knowledge
@@ -2075,8 +2162,99 @@ export const migrateCloudAi = async (): Promise<void> => {
     ADD COLUMN IF NOT EXISTS trace_id TEXT`.simple();
   await sql`CREATE INDEX IF NOT EXISTS idx_ai_structured_runs_user_created ON ai.structured_runs(user_id, created_at DESC)`.simple();
 
-  await migrateAiTurnUsage();
-  await migrateAiModelAccess();
+  await sql`
+    CREATE TABLE IF NOT EXISTS ai.dictations (
+      id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+      short_id TEXT NOT NULL CONSTRAINT ai_dictations_short_id_key UNIQUE,
+      conversation_id UUID NOT NULL REFERENCES ai.conversations(id) ON DELETE CASCADE,
+      user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+      operation_id UUID NOT NULL,
+      request_hash TEXT NOT NULL,
+      source_path TEXT NOT NULL,
+      source_bytes BYTEA,
+      media_type TEXT NOT NULL,
+      model_profile_id TEXT NOT NULL,
+      language TEXT,
+      status TEXT NOT NULL DEFAULT 'queued' CHECK (status IN ('queued', 'running', 'succeeded', 'failed', 'canceled')),
+      disposition TEXT NOT NULL DEFAULT 'pending' CHECK (disposition IN ('pending', 'applied', 'discarded')),
+      result TEXT,
+      error_code TEXT,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      lease_token UUID,
+      lease_until TIMESTAMPTZ,
+      next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      UNIQUE (conversation_id, user_id, operation_id)
+    )
+  `.simple();
+  // Provenance is separate from origin, which still controls file write rights.
+  // Backfill only an unchanged file created in the dictation transaction.
+  await sql`
+    DO $$ BEGIN
+      IF NOT EXISTS (SELECT 1 FROM information_schema.columns
+        WHERE table_schema = 'ai' AND table_name = 'files' AND column_name = 'dictation_recorded_at') THEN
+        ALTER TABLE ai.files ADD COLUMN IF NOT EXISTS dictation_recorded_at TIMESTAMPTZ;
+        UPDATE ai.files f SET dictation_recorded_at = d.created_at FROM ai.dictations d
+        WHERE f.conversation_id = d.conversation_id AND f.path = d.source_path
+          AND f.origin = 'user' AND f.version = 1 AND f.updated_at = d.created_at
+          AND f.dictation_recorded_at IS NULL;
+      END IF;
+    END $$
+  `.simple();
+  await sql`ALTER TABLE ai.turn_files ADD COLUMN IF NOT EXISTS dictation_recorded_at TIMESTAMPTZ`.simple();
+
+  // Retained for the conversation lifetime so a delayed upload cannot undo a discard.
+  await sql`CREATE TABLE IF NOT EXISTS ai.dictation_cancellations (
+    conversation_id UUID NOT NULL REFERENCES ai.conversations(id) ON DELETE CASCADE,
+    user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+    operation_id UUID NOT NULL,
+    PRIMARY KEY (conversation_id, user_id, operation_id)
+  )`.simple();
+  await sql`CREATE INDEX IF NOT EXISTS ai_dictations_pending ON ai.dictations(conversation_id, created_at, id) WHERE disposition = 'pending'`.simple();
+  await sql`CREATE INDEX IF NOT EXISTS ai_dictations_recovery ON ai.dictations(status, next_attempt_at, lease_until) WHERE status IN ('queued', 'running')`.simple();
+  await sql.begin(async (tx) => {
+    await tx`ALTER TABLE ai.live_invalidation_outbox DROP CONSTRAINT IF EXISTS ai_live_invalidation_domains_check`;
+    await tx`ALTER TABLE ai.live_invalidation_outbox ADD CONSTRAINT ai_live_invalidation_domains_check CHECK (
+      domains <@ ARRAY['conversation-list', 'conversation-detail', 'conversation-sources', 'conversation-files', 'conversation-tasks',
+        'conversation-dictations', 'project-list', 'project-detail', 'project-context']::text[] AND cardinality(domains) > 0
+    )`;
+  });
+  await sql`DROP TRIGGER IF EXISTS ai_live_dictations_changed ON ai.dictations`.simple();
+  await sql`DROP TRIGGER IF EXISTS ai_live_dictations_state_changed ON ai.dictations`.simple();
+  await sql`CREATE TRIGGER ai_live_dictations_changed AFTER INSERT OR DELETE ON ai.dictations
+    FOR EACH ROW EXECUTE FUNCTION ai.live_conversation_child_changed('conversation-dictations')`.simple();
+  await sql`CREATE TRIGGER ai_live_dictations_state_changed AFTER UPDATE ON ai.dictations
+    FOR EACH ROW WHEN (OLD.status IS DISTINCT FROM NEW.status OR OLD.disposition IS DISTINCT FROM NEW.disposition)
+    EXECUTE FUNCTION ai.live_conversation_child_changed('conversation-dictations')`.simple();
+
+  // A tool artifact may be reused only by its producing call and while unedited.
+  await sql`ALTER TABLE ai.files ADD COLUMN IF NOT EXISTS producer_call_key TEXT`.simple();
 
+  await migrateAiModelAccess();
+  await migrateAiQuotas();
+
+  await sql`CREATE OR REPLACE FUNCTION ai.sidebar_tool_label(blocks jsonb) RETURNS jsonb AS $$
+    SELECT jsonb_build_object('label', left(COALESCE(block->'presentation'->>'title', block->>'name'),200), 'status', block->>'status')
+    FROM jsonb_array_elements(CASE WHEN jsonb_typeof(blocks) = 'array' THEN blocks ELSE '[]'::jsonb END) WITH ORDINALITY AS entries(block, n)
+    WHERE block->>'kind' = 'tool' ORDER BY n DESC LIMIT 1
+  $$ LANGUAGE sql IMMUTABLE`.simple();
+  await sql`DROP TRIGGER IF EXISTS ai_live_sidebar_tool_changed ON ai.turns`.simple();
+  await sql`CREATE TRIGGER ai_live_sidebar_tool_changed AFTER UPDATE OF live_blocks ON ai.turns
+    FOR EACH ROW WHEN (ai.sidebar_tool_label(OLD.live_blocks) IS DISTINCT FROM ai.sidebar_tool_label(NEW.live_blocks))
+    EXECUTE FUNCTION ai.live_conversation_child_changed('conversation-list')`.simple();
+  await sql`DROP TRIGGER IF EXISTS ai_live_sidebar_plan_changed ON ai.messages`.simple();
+  await sql`CREATE TRIGGER ai_live_sidebar_plan_changed AFTER INSERT ON ai.messages
+    FOR EACH ROW WHEN (NEW.role = 'tool_result' OR NEW.meta IS NOT NULL)
+    EXECUTE FUNCTION ai.live_conversation_child_changed('conversation-list')`.simple();
+  // Separate run history keeps background tool loops out of the interactive chat.
+  await sql`CREATE TABLE IF NOT EXISTS ai.task_messages (LIKE ai.messages INCLUDING DEFAULTS INCLUDING CONSTRAINTS, FOREIGN KEY (conversation_id) REFERENCES ai.conversations(id) ON DELETE CASCADE)`.simple();
+  await sql`CREATE UNIQUE INDEX IF NOT EXISTS ai_task_messages_id ON ai.task_messages(id)`.simple();
+  await sql`CREATE UNIQUE INDEX IF NOT EXISTS ai_task_messages_seq ON ai.task_messages(loop_id, seq)`.simple();
+
+  await sql`ALTER TABLE ai.chat_task_occurrences ADD COLUMN IF NOT EXISTS result_text TEXT`.simple();
+  await sql`ALTER TABLE ai.chat_task_occurrences ADD COLUMN IF NOT EXISTS delivered_at TIMESTAMPTZ`.simple();
+  await sql`ALTER TABLE ai.conversations ADD COLUMN IF NOT EXISTS background_received_at TIMESTAMPTZ`.simple();
+  await migrateAiMessageQueue();
   console.log("  ✓ ai conversation tables");
 };

package/src/ai/model-pricing.ts

@@ -0,0 +1,43 @@
+import { sql } from "bun";
+import { coreSettings } from "../services";
+import { audit } from "../services/audit";
+import { invalidateSettingsCache, set as setSetting } from "../services/settings";
+import { decryptValue } from "../services/settings/crypto";
+import { type AiModelPricing, AiModelPricingSchema } from "../shared/ai-costs";
+import { AiQuotaError } from "./quotas";
+import { parseAiModelProfiles } from "./settings";
+
+/** Change prices only, preserving credentials and model access in their own stores. */
+export async function setAiModelPricing(id: string, pricing: AiModelPricing | null, expected: AiModelPricing | null, actorId: string) {
+  if (pricing) AiModelPricingSchema.parse(pricing);
+  const key = "ai.model_profiles_json";
+  const fallback = await coreSettings.get<string>(key);
+  const result = await sql.begin(async (db) => {
+    const [row] = await db<{ value: string }[]>`SELECT value FROM settings.entries WHERE key=${key} FOR UPDATE`;
+    const raw = row ? await decryptValue(row.value) : fallback;
+    if (typeof raw !== "string") throw new Error("Invalid model configuration.");
+    const parsed = parseAiModelProfiles(raw);
+    if (parsed.error) throw new Error(parsed.error.message);
+    const profile = parsed.profiles.find((profile) => profile.id === id);
+    if (!profile) throw new AiQuotaError("quota_conflict", "Model no longer exists.");
+    if (profile.capabilities.includes("transcription")) throw new AiQuotaError("quota_conflict", "Audio pricing is not supported.");
+    if (JSON.stringify(profile.pricing ?? null) !== JSON.stringify(expected))
+      throw new AiQuotaError("quota_conflict", "Model prices changed. Read them again before updating.");
+    if (pricing) profile.pricing = pricing;
+    else delete profile.pricing;
+    await setSetting(key, JSON.stringify(parsed.profiles), db);
+    await audit.record(
+      {
+        action: "ai.model.pricing",
+        outcome: "allowed",
+        actor: { userId: actorId },
+        target: { type: "ai-model", id },
+        metadata: { pricing },
+      },
+      db,
+    );
+    return { id, pricing: profile.pricing ?? null };
+  });
+  await invalidateSettingsCache([key]);
+  return result;
+}

package/src/ai/pdf-render-worker.ts

@@ -0,0 +1,75 @@
+// Standalone subprocess. No server imports or application credentials.
+
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { createCanvas } from "@napi-rs/canvas";
+import { getDocument } from "pdfjs-dist/legacy/build/pdf.mjs";
+import { z } from "zod";
+
+const MAX_BYTES = 10 * 1024 * 1024;
+const inputSchema = z.object({
+  pdf: z.string().max(Math.ceil((MAX_BYTES * 4) / 3)),
+  pages: z.array(z.number().int().positive()).min(1).max(3),
+});
+const require = createRequire(import.meta.url);
+const root = dirname(require.resolve("pdfjs-dist/package.json"));
+try {
+  const input = inputSchema.parse(JSON.parse(await Bun.stdin.text()));
+  const data = Buffer.from(input.pdf, "base64");
+  if (data.byteLength > MAX_BYTES) throw new Error("PDF exceeds the 10 MiB limit.");
+  const task = getDocument({
+    data: new Uint8Array(data),
+    verbosity: 0,
+    cMapUrl: join(root, "cmaps/"),
+    cMapPacked: true,
+    standardFontDataUrl: join(root, "standard_fonts/"),
+    wasmUrl: join(root, "wasm/"),
+    useSystemFonts: false,
+    stopAtErrors: true,
+    // Bound decoded source-image allocations as well as the output canvas.
+    maxImageSize: 16 * 1024 * 1024,
+  });
+  try {
+    const document = await task.promise;
+    if (input.pages.some((page) => page > document.numPages))
+      throw new Error(`PDF has ${document.numPages} pages. Choose pages within that range.`);
+    const pages: { page: number; png: string }[] = [];
+    let outputBytes = 0;
+    for (const number of input.pages) {
+      const page = await document.getPage(number);
+      const original = page.getViewport({ scale: 1 });
+      if (!(original.width > 0 && original.height > 0 && Number.isFinite(original.width + original.height)))
+        throw new Error("PDF page dimensions are invalid.");
+      const viewport = page.getViewport({ scale: Math.min(2, 2000 / Math.max(original.width, original.height)) });
+      const canvas = createCanvas(Math.ceil(viewport.width), Math.ceil(viewport.height));
+      try {
+        // PDF.js uses the Canvas API implemented by the native canvas; its types
+        // describe browser HTMLCanvasElement rather than the supported Node canvas.
+        await page.render({ canvas: canvas as unknown as HTMLCanvasElement, viewport }).promise;
+        const png: Uint8Array = canvas.toBuffer("image/png");
+        outputBytes += png.byteLength;
+        if (outputBytes > MAX_BYTES) throw new Error("Rendered PDF exceeds the 10 MiB image budget.");
+        pages.push({ page: number, png: Buffer.from(png).toString("base64") });
+      } finally {
+        canvas.width = 0;
+        canvas.height = 0;
+        page.cleanup();
+      }
+    }
+    process.stdout.write(JSON.stringify({ totalPages: document.numPages, pages }));
+  } finally {
+    await task.destroy();
+  }
+} catch (error) {
+  const name = error instanceof Error ? error.name : "";
+  const message =
+    name === "PasswordException"
+      ? "Password-protected PDFs are not supported. Provide an unlocked copy."
+      : name === "InvalidPDFException"
+        ? "The PDF is invalid or damaged."
+        : error instanceof Error
+          ? error.message.slice(0, 500)
+          : "PDF rendering failed.";
+  process.stdout.write(JSON.stringify({ error: message }));
+  process.exitCode = 1;
+}

package/src/ai/pdf-render.fixture.ts

@@ -0,0 +1,28 @@
+/** Small, deterministic PDF with embedded vector text; no fixture download. */
+export function visionPdfFixture(): Uint8Array {
+  const objects = [
+    "<< /Type /Catalog /Pages 2 0 R >>",
+    "<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>",
+    "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 200] /Resources << /Font << /F1 5 0 R >> >> /Contents 6 0 R >>",
+    "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 200] /Resources << /Font << /F1 5 0 R >> >> /Contents 7 0 R >>",
+    "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
+    ...["Invoice INV-7", "Total 42.00 EUR"].map((text) => {
+      const content = `BT /F1 20 Tf 20 120 Td (${text}) Tj ET`;
+      return `<< /Length ${content.length} >>\nstream\n${content}\nendstream`;
+    }),
+  ];
+  let pdf = "%PDF-1.4\n";
+  const offsets = [0];
+  for (const [index, object] of objects.entries()) {
+    offsets.push(pdf.length);
+    pdf += `${index + 1} 0 obj\n${object}\nendobj\n`;
+  }
+  const start = pdf.length;
+  pdf += `xref\n0 ${offsets.length}\n0000000000 65535 f \n`;
+  pdf += offsets
+    .slice(1)
+    .map((offset) => `${String(offset).padStart(10, "0")} 00000 n \n`)
+    .join("");
+  pdf += `trailer\n<< /Size ${offsets.length} /Root 1 0 R >>\nstartxref\n${start}\n%%EOF`;
+  return new TextEncoder().encode(pdf);
+}

package/src/ai/pdf-render.ts

@@ -0,0 +1,77 @@
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+
+declare const __CLOUD_PDF_RENDER_WORKER__: string | undefined;
+let activeRenders = 0;
+export const PDF_MAX_BYTES = 10 * 1024 * 1024;
+export const PdfPages = z
+  .array(z.number().int().positive())
+  .min(1)
+  .max(3)
+  .refine((pages) => new Set(pages).size === pages.length, "Choose each page only once.");
+const RenderResult = z.object({
+  totalPages: z.number().int().positive(),
+  pages: z
+    .array(z.object({ page: z.number().int().positive(), png: z.string() }))
+    .min(1)
+    .max(3),
+});
+
+/** Isolate native decoding from the server: abort/deadline kills the process. */
+export async function renderPdfPages(bytes: Uint8Array, pages: number[] = [1], signal?: AbortSignal) {
+  PdfPages.parse(pages);
+  if (bytes.byteLength > PDF_MAX_BYTES) throw new Error("PDF exceeds the 10 MiB view_image limit.");
+  if (process.platform !== "linux") throw new Error("PDF page inspection requires the Linux Cloud runtime with memory isolation.");
+  const boundedSignal = AbortSignal.any([AbortSignal.timeout(30_000), ...(signal ? [signal] : [])]);
+  boundedSignal.throwIfAborted();
+  if (activeRenders >= 2) throw new Error("PDF rendering is busy. Retry after the current inspection finishes.");
+  activeRenders++;
+  try {
+    const worker =
+      typeof __CLOUD_PDF_RENDER_WORKER__ === "string"
+        ? new URL(__CLOUD_PDF_RENDER_WORKER__, import.meta.url)
+        : new URL("./pdf-render-worker.ts", import.meta.url);
+    // RLIMIT_DATA bounds the decoder heap/native writable mappings on Linux.
+    // Positional arguments keep paths out of shell code. No elevated privileges.
+    const child = Bun.spawn(
+      ["/bin/sh", "-c", 'ulimit -d 524288 || exit 70; exec "$@"', "pdf-decoder", process.execPath, "--no-env-file", fileURLToPath(worker)],
+      {
+        stdin: new Blob([JSON.stringify({ pdf: Buffer.from(bytes).toString("base64"), pages })]),
+        stdout: "pipe",
+        stderr: "ignore",
+        // The decoder needs no application credentials or runtime configuration.
+        env: { PATH: process.env.PATH, LANG: "C.UTF-8" },
+      },
+    );
+    const stop = () => child.kill("SIGKILL");
+    boundedSignal.addEventListener("abort", stop, { once: true });
+    if (boundedSignal.aborted) stop();
+    try {
+      let length = 0;
+      const stdout = child.stdout.pipeThrough(
+        new TransformStream<Uint8Array, Uint8Array>({
+          transform(chunk, controller) {
+            length += chunk.byteLength;
+            // Base64 overhead plus a small JSON envelope over the aggregate PNG budget.
+            if (length > Math.ceil((PDF_MAX_BYTES * 4) / 3) + 4096) throw new Error("Rendered PDF exceeds the 10 MiB image budget.");
+            controller.enqueue(chunk);
+          },
+        }),
+      );
+      const text = await new Response(stdout).text();
+      boundedSignal.throwIfAborted();
+      if (!text.trim()) throw new Error("PDF decoder failed or exceeded its memory budget.");
+      const output: unknown = JSON.parse(text);
+      const failure = z.object({ error: z.string().max(500) }).safeParse(output);
+      if (failure.success) throw new Error(failure.data.error);
+      if ((await child.exited) !== 0) throw new Error("PDF rendering failed.");
+      return RenderResult.parse(output);
+    } finally {
+      boundedSignal.removeEventListener("abort", stop);
+      stop();
+      await child.exited;
+    }
+  } finally {
+    activeRenders--;
+  }
+}