@k2b/cloud 0.6.0 → 0.8.0

package/src/ai/routes.ts

@@ -1,4 +1,5 @@
 import { type Context, Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
 import { z } from "zod";
 import { listCapabilities } from "../_internal/registry";
 import {
@@ -15,11 +16,16 @@ import {
   respond,
   v,
 } from "../server";
+import { logger } from "../services/logging";
 import { coreSettings } from "../services/settings/api";
 import type { AiToolApprovalContext } from "./approvals";
 import { assistantAiSettingsState, listAssistantAiModels, selectAssistantAiModelId } from "./assistant-models";
+import { AI_AUDIO_MAX_BYTES } from "./audio-format";
 import { buildAiCapabilityCatalog } from "./capabilities";
+import { getAiChatQuotas } from "./chat-quotas";
 import { createConfiguredDefaultCloudAiTools } from "./default-tools";
+import { enqueueAiDictation } from "./dictation-runtime";
+import { AiDictationConflict, AiDictationListSchema, AiDictationStartSchema, aiDictations } from "./dictations";
 import { aiProjectFilePathFromMount } from "./file-mount";
 import { AI_FILES_MAX_FILE_BYTES_DEFAULT, aiFileStore, decodeAiFileContent, guessAiMediaType, normalizeAiFilePath } from "./files-store";
 import {
@@ -41,6 +47,15 @@ import { aiMaintenanceJobs } from "./maintenance";
 import { AI_MEMORY_CONTENT_MAX_CHARS, aiMemories } from "./memories";
 import { aiMemoryLearningRuns } from "./memory-learning-runs";
 import { createCloudAiMemoryTool } from "./memory-tool";
+import {
+  AiMessageQueueConflict,
+  editQueuedMessage,
+  enqueueChatMessage,
+  listQueuedMessages,
+  queuedMessageAccepted,
+  updateQueuedMessage,
+} from "./message-queue";
+import { aiModelAccess } from "./model-access";
 import { personalAiModelPolicy } from "./personal-agent";
 import { aiActorUser, aiPrefsUserId, aiUserPrefs } from "./prefs";
 import { aiProjects } from "./projects";
@@ -51,9 +66,11 @@ import {
   AiTurnActionSchema,
   abortAiTurn,
   listPendingAiTurnActions,
+  prepareAiChatTurn,
   submitAiChatTurn,
   submitAiCompaction,
   submitAiTurnAction,
+  wakeAiMessageQueue,
 } from "./runtime";
 import { readAiSettingsState, selectAiModelProfile } from "./settings";
 import { AI_SHORT_ID_PATTERN } from "./short-id";
@@ -64,6 +81,7 @@ import { aiConversations } from "./store";
 import { createAiConversationStreamResponse, loadAiStreamState } from "./stream";
 import { composeAiSystemPrompt } from "./system-prompt";
 import { aiToolPromptHints } from "./tools";
+import { resolveAiAudioModel } from "./transcription";
 import type { AiConversation, AiModelPolicy, AiTurn } from "./types";
 
 /** Everything a resolved, authorized request needs to run against the shared runtime. */
@@ -102,6 +120,10 @@ const ConversationListQuerySchema = z
       .enum(["true", "false"])
       .transform((value) => value === "true")
       .optional(),
+    done: z
+      .enum(["true", "false"])
+      .transform((value) => value === "true")
+      .optional(),
     status: z.enum(["running", "needs_attention", "failed", "unread"]).optional(),
     projectId: z.string().regex(AI_SHORT_ID_PATTERN).optional(),
     unassigned: z
@@ -123,6 +145,7 @@ const ConversationMetadataInputSchema = z.object({
 });
 
 const ConversationProjectInputSchema = z.object({
+  onlyUnassigned: z.boolean().optional(),
   projectId: z.string().regex(AI_SHORT_ID_PATTERN).nullable(),
 });
 
@@ -212,12 +235,13 @@ const rememberLastUsedModel = (actor: RequestActor, modelProfileId: string | nul
 };
 
 const conversationDetail = async (conversation: AiConversation, subject: AccessSubject) => {
-  const [state, timeline] = await Promise.all([
+  const [state, timeline, publicView] = await Promise.all([
     loadAiStreamState(conversation),
     aiConversations.listConversationTimeline({ conversationId: conversation.id }),
+    publicConversationFor(conversation, subject),
   ]);
   return {
-    conversation: await publicConversationFor(conversation, subject),
+    conversation: publicView,
     messages: state.messages.map((message) => ({ ...message, id: message.shortId })),
     hasMoreMessages: state.hasMoreMessages ?? false,
     activeTurn: state.activeTurn,
@@ -284,6 +308,10 @@ export const aiRoutes = (() => {
       .get("/status", async (c) => {
         return respond(c, ok(await assistantAiSettingsState(c.get("accessSubject"))));
       })
+      .get("/quotas", async (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json(await getAiChatQuotas(c.get("accessSubject")));
+      })
       .get("/models", async (c) => {
         return respond(c, ok(await listAssistantAiModels(c.get("accessSubject"))));
       })
@@ -428,6 +456,7 @@ export const aiRoutes = (() => {
                 ownerUserId: ctx.ownerUserId,
                 search: query.q,
                 archived: query.archived,
+                done: query.done,
                 status: query.status,
                 projectId: project?.id,
                 unassigned: query.unassigned,
@@ -448,6 +477,7 @@ export const aiRoutes = (() => {
           ownerUserId: ctx.ownerUserId,
           search: query.q,
           archived: query.archived,
+          done: query.done,
           status: query.status,
           projectId: project?.id,
           unassigned: query.unassigned,
@@ -552,7 +582,7 @@ export const aiRoutes = (() => {
         if (ctx instanceof Response) return ctx;
         const conversation = await loadConversation(c, ctx);
         if (!conversation) return notFound(c);
-        const messageId = c.req.param("messageId");
+        const messageId = c.req.param("messageId") ?? "";
         if (!messageId) return respond(c, fail(err.badInput("Invalid message id.")));
         const input = c.req.valid("json");
         const feedback = await aiConversations.setMessageFeedback({
@@ -571,7 +601,7 @@ export const aiRoutes = (() => {
         if (ctx instanceof Response) return ctx;
         const conversation = await loadConversation(c, ctx);
         if (!conversation) return notFound(c);
-        const messageId = c.req.param("messageId");
+        const messageId = c.req.param("messageId") ?? "";
         if (!messageId) return respond(c, fail(err.badInput("Invalid message id.")));
         return (await aiConversations.clearMessageFeedback({
           conversationId: conversation.id,
@@ -650,8 +680,10 @@ export const aiRoutes = (() => {
           conversationId: conversation.id,
           ownerUserId: ctx.ownerUserId,
           projectId: project?.id ?? null,
+          onlyUnassigned: body.onlyUnassigned,
         });
         if (!result.ok) {
+          if (result.reason === "already_assigned") return respond(c, fail(err.conflict("This chat already belongs to a Project.")));
           if (result.reason === "active_turn") {
             return respond(c, fail(err.conflict("Wait for the active turn before changing the Project.")));
           }
@@ -683,6 +715,22 @@ export const aiRoutes = (() => {
         });
         return updated ? respond(c, ok(await publicConversationFor(updated, c.get("accessSubject")))) : notFound(c);
       })
+      .put("/conversations/:conversationId/done", v("json", z.object({ done: z.boolean().nullable() })), async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation) return notFound(c);
+        const result = await aiConversations.setConversationDone({
+          conversationId: conversation.id,
+          ownerUserId: ctx.ownerUserId,
+          done: c.req.valid("json").done,
+        });
+        if (!result.ok)
+          return result.reason === "active_turn"
+            ? respond(c, fail(err.conflict("Stop the current response before marking this chat done.")))
+            : notFound(c);
+        return respond(c, ok(await publicConversationFor(result.conversation, c.get("accessSubject"))));
+      })
       .post("/conversations/:conversationId/archive", async (c) => {
         const ctx = await resolveContext(c);
         if (ctx instanceof Response) return ctx;
@@ -720,6 +768,43 @@ export const aiRoutes = (() => {
         });
         return viewed ? respond(c, ok({ ok: true })) : notFound(c);
       })
+      .get("/conversations/:conversationId/queue", async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        return conversation ? respond(c, ok(await listQueuedMessages(conversation.id))) : notFound(c);
+      })
+      .patch(
+        "/conversations/:conversationId/queue/:messageId",
+        v("json", z.object({ text: z.string().trim().min(1).max(20000) }).strict()),
+        async (c) => {
+          const ctx = await resolveContext(c);
+          if (ctx instanceof Response) return ctx;
+          const conversation = await loadConversation(c, ctx);
+          if (!conversation || !z.uuid().safeParse(c.req.param("messageId")).success) return notFound(c);
+          return (await editQueuedMessage(conversation.id, c.req.param("messageId") ?? "", c.req.valid("json").text))
+            ? respond(c, ok({ ok: true }))
+            : notFound(c);
+        },
+      )
+      .delete("/conversations/:conversationId/queue/:messageId", async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation || !z.uuid().safeParse(c.req.param("messageId")).success) return notFound(c);
+        if (!(await updateQueuedMessage(conversation.id, c.req.param("messageId") ?? "", "cancel"))) return notFound(c);
+        wakeAiMessageQueue(conversation.id);
+        return respond(c, ok({ ok: true }));
+      })
+      .post("/conversations/:conversationId/queue/:messageId/retry", async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation || !z.uuid().safeParse(c.req.param("messageId")).success) return notFound(c);
+        if (!(await updateQueuedMessage(conversation.id, c.req.param("messageId") ?? "", "retry"))) return notFound(c);
+        wakeAiMessageQueue(conversation.id);
+        return respond(c, ok({ ok: true }));
+      })
       .put("/conversations/:conversationId/draft", v("json", AiSaveConversationDraftInputSchema), async (c) => {
         const ctx = await resolveContext(c);
         if (ctx instanceof Response) return ctx;
@@ -749,6 +834,7 @@ export const aiRoutes = (() => {
         const conversation = await loadConversation(c, ctx);
         if (!conversation) return notFound(c);
         const body = c.req.valid("json");
+        if (body.queueId && (await queuedMessageAccepted(conversation.id, body.queueId))) return respond(c, ok({ queued: true }));
         if (conversation.draft.revision !== body.draftRevision) {
           return respond(c, fail(err.conflict("The conversation draft changed in another session.")));
         }
@@ -756,6 +842,7 @@ export const aiRoutes = (() => {
         const resourceParts = conversation.draft.content.filter((part) => part.type === "resource");
         const turnContent = conversation.draft.content.map((part) => {
           if (part.type === "text") return { type: "text" as const, text: part.text };
+          if (part.type === "project-file") return { type: "text" as const, text: `Project file: ${part.path}` };
           if (part.type === "file") {
             return { type: "attachment" as const, path: part.path, mediaType: part.mediaType, size: part.size };
           }
@@ -768,8 +855,8 @@ export const aiRoutes = (() => {
         const project = conversation.projectId ? await aiProjects.snapshot(conversation.projectId, c.get("accessSubject")) : null;
         if (conversation.projectId && !project) return respond(c, fail(err.notFound("Project")));
         try {
-          const result = await submitAiChatTurn({
-            assistantChat: true,
+          const submission = {
+            assistantChat: true as const,
             conversationId: conversation.id,
             chatId: conversation.shortId,
             input,
@@ -780,7 +867,7 @@ export const aiRoutes = (() => {
             modelPolicy: ctx.modelPolicy,
             project: project ?? undefined,
             clientToolIds: body.clientToolIds,
-            toolSource: { kind: "default", appTools: true },
+            toolSource: { kind: "default" as const, appTools: true },
             toolApprovalContext: ctx.toolApprovalContext,
             expectedDraftRevision: body.draftRevision,
             expectedProjectId: conversation.projectId,
@@ -788,7 +875,13 @@ export const aiRoutes = (() => {
             expectedFiles: conversation.draft.content.flatMap((part) =>
               part.type === "file" ? [{ path: part.path, version: part.version }] : [],
             ),
-          });
+          };
+          if (body.queueId) {
+            await enqueueChatMessage(body.queueId, await prepareAiChatTurn(submission), conversation.draft.content);
+            wakeAiMessageQueue(conversation.id);
+            return respond(c, ok({ queued: true }));
+          }
+          const result = await submitAiChatTurn(submission);
           rememberLastUsedModel(ctx.actor, result.turn.modelProfileId);
           return respond(
             c,
@@ -803,6 +896,11 @@ export const aiRoutes = (() => {
             201,
           );
         } catch (error) {
+          if (
+            error instanceof AiMessageQueueConflict ||
+            (error instanceof Error && error.message === "Queued messages must be sent first.")
+          )
+            return respond(c, fail(err.conflict(error.message)));
           return toAiErrorResponse(c, error);
         }
       })
@@ -832,7 +930,7 @@ export const aiRoutes = (() => {
         if (ctx instanceof Response) return ctx;
         const conversation = await loadConversation(c, ctx);
         if (!conversation) return notFound(c);
-        const messageId = c.req.param("messageId");
+        const messageId = c.req.param("messageId") ?? "";
 
         const messages = await aiConversations.listMessages({ conversationId: conversation.id });
         const target = messages.find((m) => m.shortId === messageId);
@@ -881,6 +979,7 @@ export const aiRoutes = (() => {
             truncateFromSeq: target.seq,
             fileSnapshot: originalRunConfig?.kind !== "compact" ? originalRunConfig?.files : undefined,
             retrySourceTurnId: target.loopId ?? undefined,
+            clientToolIds: originalRunConfig?.kind !== "compact" ? originalRunConfig?.clientToolIds : undefined,
           });
           rememberLastUsedModel(ctx.actor, result.turn.modelProfileId);
           return respond(
@@ -904,7 +1003,7 @@ export const aiRoutes = (() => {
         if (ctx instanceof Response) return ctx;
         const conversation = await loadConversation(c, ctx);
         if (!conversation) return notFound(c);
-        const messageId = c.req.param("messageId");
+        const messageId = c.req.param("messageId") ?? "";
 
         const messages = await aiConversations.listMessages({ conversationId: conversation.id });
         const target = messages.find((m) => m.shortId === messageId);
@@ -1029,6 +1128,130 @@ export const aiRoutes = (() => {
         const files = await aiFileStore.list({ conversationId: conversation.id, prefix: c.req.valid("query").prefix ?? "/" });
         return respond(c, ok({ files, totalBytes: await aiFileStore.totalBytes(conversation.id) }));
       })
+      .post("/conversations/:conversationId/dictations", bodyLimit({ maxSize: AI_AUDIO_MAX_BYTES + 65_536 }), async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation) return notFound(c);
+        try {
+          const form = await c.req.formData();
+          const file = form.get("file");
+          if (!(file instanceof File)) return respond(c, fail(err.badInput("Attach one audio recording.")));
+          const options = AiDictationStartSchema.parse({
+            operationId: form.get("operationId"),
+            language: form.get("language") ?? undefined,
+          });
+          const dictation = await aiDictations.start({
+            ...options,
+            conversationId: conversation.id,
+            userId: ctx.ownerUserId,
+            bytes: new Uint8Array(await file.arrayBuffer()),
+            resolveModel: async () => {
+              const model = await resolveAiAudioModel({ allowedDataBoundaries: ctx.modelPolicy.allowedDataBoundaries });
+              await aiModelAccess.assertAllowed(model.profile.id, c.get("accessSubject"));
+              return model;
+            },
+          });
+          await enqueueAiDictation(dictation.id).catch(() => undefined); // The DB sweep heals failed delivery.
+          return respond(c, ok(dictation));
+        } catch (error) {
+          return respond(
+            c,
+            fail(
+              error instanceof AiDictationConflict
+                ? err.conflict(error.message)
+                : err.badInput(error instanceof Error ? error.message : "Recording upload failed."),
+            ),
+          );
+        }
+      })
+      .post("/conversations/:conversationId/dictations/discard", v("json", z.object({ operationId: z.uuid() })), async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation) return notFound(c);
+        return respond(
+          c,
+          ok(
+            await aiDictations.discardOperation({
+              conversationId: conversation.id,
+              userId: ctx.ownerUserId,
+              operationId: c.req.valid("json").operationId,
+            }),
+          ),
+        );
+      })
+      .get("/conversations/:conversationId/dictations", v("query", AiDictationListSchema), async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation) return notFound(c);
+        return respond(
+          c,
+          ok(await aiDictations.list({ ...c.req.valid("query"), conversationId: conversation.id, userId: ctx.ownerUserId })),
+        );
+      })
+      .get("/conversations/:conversationId/dictations/:dictationId", async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation) return notFound(c);
+        const result = await aiDictations.get({
+          conversationId: conversation.id,
+          userId: ctx.ownerUserId,
+          id: z.string().regex(AI_SHORT_ID_PATTERN).parse(c.req.param("dictationId")),
+        });
+        return result ? respond(c, ok(result)) : notFound(c);
+      })
+      .post("/conversations/:conversationId/dictations/:dictationId/apply", v("json", AiSaveConversationDraftInputSchema), async (c) => {
+        const ctx = await resolveContext(c);
+        if (ctx instanceof Response) return ctx;
+        const conversation = await loadConversation(c, ctx);
+        if (!conversation) return notFound(c);
+        try {
+          return respond(
+            c,
+            ok(
+              await aiDictations.apply({
+                ...c.req.valid("json"),
+                conversationId: conversation.id,
+                userId: ctx.ownerUserId,
+                id: z.string().regex(AI_SHORT_ID_PATTERN).parse(c.req.param("dictationId")),
+              }),
+            ),
+          );
+        } catch (error) {
+          return respond(
+            c,
+            fail(
+              error instanceof AiDictationConflict
+                ? err.conflict(error.message)
+                : err.badInput(error instanceof Error ? error.message : "Dictation could not be inserted."),
+            ),
+          );
+        }
+      })
+      .post(
+        "/conversations/:conversationId/dictations/:dictationId/action",
+        v("json", z.object({ action: z.enum(["discard", "retry"]) })),
+        async (c) => {
+          const ctx = await resolveContext(c);
+          if (ctx instanceof Response) return ctx;
+          const conversation = await loadConversation(c, ctx);
+          if (!conversation) return notFound(c);
+          const input = {
+            conversationId: conversation.id,
+            userId: ctx.ownerUserId,
+            id: z.string().regex(AI_SHORT_ID_PATTERN).parse(c.req.param("dictationId")),
+          };
+          if (c.req.valid("json").action === "discard") await aiDictations.discard(input);
+          else {
+            await aiDictations.retry(input);
+            await enqueueAiDictation(input.id).catch(() => undefined);
+          }
+          return respond(c, ok({ success: true }));
+        },
+      )
       .post("/conversations/:conversationId/files", async (c) => {
         const ctx = await resolveContext(c);
         if (ctx instanceof Response) return ctx;
@@ -1042,7 +1265,9 @@ export const aiRoutes = (() => {
           return respond(c, fail(err.badInput(`File exceeds the ${Math.floor(AI_FILES_MAX_FILE_BYTES_DEFAULT / (1024 * 1024))} MB limit`)));
         }
         const name = (file.name || "upload").replaceAll("/", "_").replaceAll("\\", "_").replaceAll("\0", "").slice(0, 160) || "upload";
-        const path = normalizeAiFilePath(`/${name}`);
+        const directory = form?.get("directory") ?? "/";
+        if (typeof directory !== "string") return respond(c, fail(err.badInput("Invalid directory")));
+        const path = normalizeAiFilePath(`${directory.replace(/\/$/, "")}/${name}`);
         if (!path) return respond(c, fail(err.badInput("Invalid file name")));
         if (aiProjectFilePathFromMount(path) !== null) return respond(c, fail(err.badInput("The /project namespace is reserved.")));
 
@@ -1055,6 +1280,11 @@ export const aiRoutes = (() => {
           });
           return respond(c, ok({ file: stat }));
         } catch (error) {
+          logger("ai:files").warn("Conversation upload failed", {
+            code: "file_upload_failed",
+            conversationId: conversation.id,
+            errorType: error instanceof Error ? error.name : "unknown",
+          });
           return respond(c, fail(err.badInput(error instanceof Error ? error.message : "Upload failed")));
         }
       })

package/src/ai/run-timeout.ts

@@ -0,0 +1,12 @@
+/** Preserve why execution stopped instead of reporting an operator deadline as a user abort. */
+export class AiRunTimeout extends Error {
+  constructor(readonly budgetMs: number | null) {
+    super("AI_RUN_TIMEOUT");
+  }
+  messageFor(locale?: string): string {
+    const minutes = this.budgetMs ? this.budgetMs / 60_000 : null;
+    return locale?.startsWith("de")
+      ? `Laufzeitlimit${minutes ? ` von ${minutes} Minuten` : ""} erreicht. Du kannst die Aufgabe mit einer neuen Nachricht fortsetzen.`
+      : `Run time limit${minutes ? ` of ${minutes} minutes` : ""} reached. You can continue the task with a new message.`;
+  }
+}

package/src/ai/runtime-tools.ts

@@ -1,12 +1,19 @@
+export { CloudAiTranscribeAudioInputSchema, CloudAiTranscribeAudioOutputSchema, createCloudAiTranscribeAudioTool } from "./audio-tool";
 export {
   CLOUD_AI_DEFERRED_BUILTIN_TOOL_NAMES,
   createCloudAiCardTool,
+  createCloudAiCodeTools,
   createCloudAiLocalBashTool,
   createCloudAiSurveyTool,
   createCloudAiTextEditorTool,
   createConfiguredDefaultCloudAiTools,
   createDefaultCloudAiTools,
 } from "./default-tools";
+export {
+  CloudAiFetchFileInputSchema,
+  CloudAiFetchFileOutputSchema,
+  createCloudAiFetchFileTool,
+} from "./fetch-file-tool";
 export {
   CloudAiCalculateInputSchema,
   CloudAiCalculateOutputSchema,
@@ -26,11 +33,6 @@ export {
   evaluateAiDate,
   evaluateAiMath,
 } from "./file-tools";
-export {
-  CloudAiFetchFileInputSchema,
-  CloudAiFetchFileOutputSchema,
-  createCloudAiFetchFileTool,
-} from "./fetch-file-tool";
 export {
   CloudAiMarkdownToPdfInputSchema,
   CloudAiMarkdownToPdfOutputSchema,