@k2b/cloud 0.41.0 → 0.42.0

package/src/ai/client/controller.ts

@@ -138,6 +138,15 @@ export type CreateAiChatControllerOptions = {
 
 const isAccessor = <T>(value: T | Accessor<T>): value is Accessor<T> => typeof value === "function";
 
+class AiRequestError extends Error {
+  constructor(
+    message: string,
+    readonly status: number,
+  ) {
+    super(message);
+  }
+}
+
 const readError = async (response: Response, fallback: string): Promise<string> => {
   const body = await response.json().catch(() => null);
   return body && typeof body === "object" && "message" in body && typeof body.message === "string" ? body.message : fallback;
@@ -190,6 +199,17 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   const initialProjection = options.initialDetail ? detailToProjection(options.initialDetail) : emptyProjection();
   const [state, setState] = createStore<AiChatProjection>(initialProjection);
   const completedDuringSend = new Map<string, string>();
+  let disposed = false;
+  const submissionBodies = new Map<string, string>();
+  // Only a confirmed draft-save response can give this submission its identity.
+  const [creationErrorStatus, setCreationErrorStatus] = createSignal<number | null>(null);
+  const [uncertainSubmissions, setUncertainSubmissions] = createSignal<Record<string, number>>({});
+  const clearUncertainSubmission = (conversationId: string) =>
+    setUncertainSubmissions((current) => {
+      const next = { ...current };
+      delete next[conversationId];
+      return next;
+    });
   const [pendingSends, setPendingSends] = createSignal<Record<string, AiStoredMessage | undefined>>({});
   const clearPendingSend = (conversationId: string) =>
     setPendingSends((current) => {
@@ -251,7 +271,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
 
   const request = async <T>(path: string, init: RequestInit, fallback: string): Promise<T> => {
     const response = await fetch(url(path), { ...init, headers: { "Content-Type": "application/json", ...init.headers } });
-    if (!response.ok) throw new Error(await readError(response, fallback));
+    if (!response.ok) throw new AiRequestError(await readError(response, fallback), response.status);
     return (await response.json()) as T;
   };
 
@@ -688,6 +708,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
 
   const createConversation = async (
     input: {
+      requestId?: string;
       title?: string;
       projectId?: string;
       draft?: { content: AiDraftContentPart[] };
@@ -696,6 +717,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   ) => {
     const generation = ++conversationOpenGeneration;
     clearErrors();
+    setCreationErrorStatus(null);
     try {
       const conversation = await request<AiConversation>(
         `/conversations`,
@@ -714,6 +736,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       return conversation;
     } catch (createError) {
       if (generation === conversationOpenGeneration) {
+        setCreationErrorStatus(createError instanceof AiRequestError ? createError.status : null);
         setGlobalError(createError instanceof Error ? createError.message : "Failed to create conversation");
       }
       return null;
@@ -766,7 +789,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     input: ComposerDraftInput,
     conversationId: string | null,
   ): Promise<{ conversationId: string; content: AiDraftContentPart[]; revision: number } | null> => {
-    if (!conversationId) return null;
+    if (!conversationId || uncertainSubmissions()[conversationId] !== undefined) return null;
     const conversation = isActiveConversation(conversationId) ? state.conversation : cache.get(conversationId)?.conversation;
     if (!conversation) return null;
 
@@ -833,7 +856,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     return queueDraftOperation(async () => persistComposerDraft(input, await targetConversation));
   };
 
-  const queuedAttempts = new Map<string, { key: string; files?: File[]; id: string; saved: { revision: number } }>();
+  const queuedAttempts = new Map<string, { key: string; files?: File[]; id: string }>();
   const queueMessage = (input: ComposerDraftInput & { modelProfileId?: string }): Promise<boolean> => {
     if (!input.conversationId || !isComposerDraftSendable(input)) return Promise.resolve(false);
     const conversationId = input.conversationId;
@@ -845,38 +868,46 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
       storedFiles: input.storedFiles,
       model: input.modelProfileId,
     });
+    const previous = queuedAttempts.get(conversationId);
+    if (uncertainSubmissions()[conversationId] !== undefined) {
+      const same =
+        previous?.key === key &&
+        (previous.files ?? []).length === (input.files ?? []).length &&
+        (previous.files ?? []).every((file, index) => file === input.files?.[index]);
+      return same ? retrySubmission(conversationId).then((result) => result === "accepted") : Promise.resolve(false);
+    }
     return queueDraftOperation(async () => {
+      if (uncertainSubmissions()[conversationId] !== undefined) return false;
+      let submittedRevision: number | undefined;
       try {
-        const previous = queuedAttempts.get(conversationId);
-        const same =
-          previous?.key === key &&
-          (previous.files ?? []).length === (input.files ?? []).length &&
-          (previous.files ?? []).every((file, index) => file === input.files?.[index]);
-        const saved = same ? previous.saved : await persistComposerDraft(input, conversationId);
+        const saved = await persistComposerDraft(input, conversationId);
         if (!saved) return false;
-        const queueId = same ? previous.id : crypto.randomUUID();
-        queuedAttempts.set(conversationId, { key, files: input.files, id: queueId, saved });
-        await request(
-          `/conversations/${conversationId}/turns`,
-          {
-            method: "POST",
-            body: JSON.stringify({
-              draftRevision: saved.revision,
-              queueId,
-              modelProfileId: input.modelProfileId,
-              clientToolIds: options.clientToolIds?.filter((id) => options.frontendTools?.[id]),
-            }),
-          },
-          "Failed to queue message",
-        );
+        const queueId = crypto.randomUUID();
+        const body = JSON.stringify({
+          draftRevision: saved.revision,
+          queueId,
+          modelProfileId: input.modelProfileId,
+          clientToolIds: options.clientToolIds?.filter((id) => options.frontendTools?.[id]),
+        });
+        queuedAttempts.set(conversationId, { key, files: input.files, id: queueId });
+        submissionBodies.set(conversationId, body);
+        submittedRevision = saved.revision;
+        await request(`/conversations/${conversationId}/turns`, { method: "POST", body }, "Failed to queue message");
         if (isActiveConversation(conversationId)) {
           if ((state.conversation?.draft.revision ?? 0) <= saved.revision)
             setState("conversation", "draft", { content: [], revision: saved.revision + 1, updatedAt: new Date().toISOString() });
         } else invalidateInactiveCache(conversationId);
         queuedAttempts.delete(conversationId);
+        submissionBodies.delete(conversationId);
         if (isActiveConversation(conversationId)) setGlobalError(null);
         return true;
       } catch (error) {
+        if (submittedRevision !== undefined && !(error instanceof AiRequestError && error.status >= 400 && error.status < 500)) {
+          setUncertainSubmissions((current) => ({ ...current, [conversationId]: submittedRevision! }));
+        } else {
+          queuedAttempts.delete(conversationId);
+          submissionBodies.delete(conversationId);
+        }
         setConversationError(conversationId, error instanceof Error ? error.message : "Failed to queue message");
         return false;
       }
@@ -888,7 +919,8 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     const targetConversation = input.conversationId ? Promise.resolve(input.conversationId) : ensureConversation();
     return queueDraftOperation(async () => {
       const conversationId = await targetConversation;
-      if (!conversationId || (isActiveConversation(conversationId) && running())) return false;
+      if (!conversationId || uncertainSubmissions()[conversationId] !== undefined || (isActiveConversation(conversationId) && running()))
+        return false;
       if (isActiveConversation(conversationId)) clearErrors();
       const baseProjection = isActiveConversation(conversationId)
         ? { conversation: state.conversation, messages: [...state.messages], activeTurn: state.activeTurn }
@@ -928,6 +960,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
         setRunStatusRaw("streaming");
       }
 
+      let submittedRevision: number | undefined;
       try {
         const savedDraft = await persistComposerDraft(input, conversationId);
         if (!savedDraft) {
@@ -956,18 +989,22 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
             },
           },
         }));
+        submittedRevision = savedDraft.revision;
+        const submissionBody = JSON.stringify({
+          draftRevision: savedDraft.revision,
+          clientToolIds: options.clientToolIds?.filter((id) => options.frontendTools?.[id]),
+          modelProfileId: input.modelProfileId,
+        });
+        submissionBodies.set(conversationId, submissionBody);
         const result = await request<SubmitTurnResult>(
           `/conversations/${conversationId}/turns`,
           {
             method: "POST",
-            body: JSON.stringify({
-              draftRevision: savedDraft.revision,
-              clientToolIds: options.clientToolIds?.filter((id) => options.frontendTools?.[id]),
-              modelProfileId: input.modelProfileId,
-            }),
+            body: submissionBody,
           },
           "AI request failed",
         );
+        submissionBodies.delete(conversationId);
         const alreadyFinished = completedDuringSend.get(conversationId) === result.turn.id;
         completedDuringSend.delete(conversationId);
         if (alreadyFinished) clearPendingSend(conversationId);
@@ -1006,7 +1043,13 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
         return true;
       } catch (sendError) {
         completedDuringSend.delete(conversationId);
-        clearPendingSend(conversationId);
+        // A 4xx on this first submission rejects it. Transport/5xx failures may have committed.
+        if (
+          submittedRevision !== undefined &&
+          !(sendError instanceof AiRequestError && sendError.status >= 400 && sendError.status < 500)
+        ) {
+          setUncertainSubmissions((current) => ({ ...current, [conversationId]: submittedRevision! }));
+        } else clearPendingSend(conversationId);
         if (invalidateInactiveCache(conversationId)) return false;
         setState("messages", (prev) => prev.filter((message) => message.id !== optimistic.id));
         cache.set(conversationId, { conversation: state.conversation, messages: state.messages, activeTurn: state.activeTurn });
@@ -1017,6 +1060,73 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     });
   };
 
+  // Keep the local draft locked until its post-submission revision is available.
+  // A positive lookup alone must not hydrate the composer from a stale cached draft.
+  const finishAcceptedSubmission = async (conversationId: string): Promise<"accepted" | "unknown"> => {
+    const revision = uncertainSubmissions()[conversationId];
+    if (revision === undefined || disposed) return "unknown";
+    if (isActiveConversation(conversationId)) {
+      if (!(await refreshActiveConversation())) return "unknown";
+      if (isActiveConversation(conversationId) && (state.conversation?.draft.revision ?? -1) <= revision) return "unknown";
+    } else cache.delete(conversationId);
+    if (disposed) return "unknown";
+    submissionBodies.delete(conversationId);
+    queuedAttempts.delete(conversationId);
+    clearUncertainSubmission(conversationId);
+    clearPendingSend(conversationId);
+    if (isActiveConversation(conversationId)) setGlobalError(null);
+    return "accepted";
+  };
+
+  /** Read only: a missing message in a history window never proves non-acceptance. */
+  const reconcileSubmission = async (conversationId: string): Promise<"accepted" | "unknown" | "none"> => {
+    const revision = uncertainSubmissions()[conversationId];
+    if (revision === undefined) return "none";
+    try {
+      const queue = queuedAttempts.get(conversationId);
+      let accepted: boolean;
+      if (queue) {
+        const pending = await request<Array<{ id: string }>>(
+          `/conversations/${conversationId}/queue`,
+          {},
+          "Failed to check message status",
+        );
+        // Drained/cancelled entries disappear from this view. Absence never proves rejection;
+        // an explicit frozen retry still uses the server's durable queue receipt.
+        accepted = pending.some((message) => message.id === queue.id);
+      } else {
+        const result = await request<{ submission: { messageId: string; turnId: string | null } | null }>(
+          `/conversations/${conversationId}/submission/${revision}`,
+          {},
+          "Failed to check message status",
+        );
+        accepted = Boolean(result.submission);
+      }
+      if (!accepted || disposed || uncertainSubmissions()[conversationId] !== revision) return "unknown";
+      return await finishAcceptedSubmission(conversationId);
+    } catch (error) {
+      setConversationError(conversationId, error instanceof Error ? error.message : "Failed to check message status");
+      return "unknown";
+    }
+  };
+
+  /** Explicit retry of the same frozen submission. Never saves or chooses another revision. */
+  const retrySubmission = (conversationId: string) =>
+    queueDraftOperation(async (): Promise<"accepted" | "unknown" | "none"> => {
+      const resolved = await reconcileSubmission(conversationId);
+      if (resolved !== "unknown" || disposed) return resolved;
+      const body = submissionBodies.get(conversationId);
+      if (!body) return "unknown";
+      try {
+        await request<SubmitTurnResult>(`/conversations/${conversationId}/turns`, { method: "POST", body }, "AI request failed");
+        if (disposed) return "unknown";
+        return await finishAcceptedSubmission(conversationId);
+      } catch {
+        // Even a conflict cannot turn the earlier lost response into a known rejection.
+        return reconcileSubmission(conversationId);
+      }
+    });
+
   const submitSteer = async (input: { text: string; clientRequestId: string; blockId: string }) => {
     const conversationId = activeConversationId();
     const turn = state.activeTurn;
@@ -1426,7 +1536,10 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     runFrontendTools();
   }
 
-  onCleanup(() => closeStream());
+  onCleanup(() => {
+    disposed = true;
+    closeStream();
+  });
 
   const hasMoreHistory = () => {
     const conversationId = activeConversationId();
@@ -1457,6 +1570,11 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     openConversation,
     refreshActiveConversation,
     createConversation,
+    /** HTTP status for the reported creation failure; null also covers an unknown network outcome. */
+    creationErrorStatus,
+    uncertainSubmissions,
+    reconcileSubmission,
+    retrySubmission,
     saveDraft,
     queueMessage,
     send,

package/src/ai/client/transport.ts

@@ -73,7 +73,14 @@ export async function* parseAiSse(response: Response, signal: AbortSignal): Asyn
           .filter((line) => line.startsWith("data:"))
           .map((line) => line.slice(5).trimStart())
           .join("\n");
-        if (data) yield JSON.parse(data) as AiStreamEvent;
+        if (data) {
+          const value: unknown = JSON.parse(data);
+          if (value && typeof value === "object" && "code" in value && value.code === "app_access_denied") {
+            const message = "message" in value && typeof value.message === "string" ? value.message : "Application access denied";
+            throw new AiStreamError("access_denied", message);
+          }
+          yield value as AiStreamEvent;
+        }
       }
     }
   } finally {
@@ -133,8 +140,13 @@ export const subscribeAiStream = (input: {
           if (stopped) break;
           input.onEvent(event);
         }
-      } catch {
+      } catch (error) {
         if (stopped) return;
+        if (error instanceof AiStreamError) {
+          stopped = true;
+          input.onError?.(error);
+          return;
+        }
       } finally {
         clearConnectTimer();
         if (activeAttempt === attempt) activeAttempt = null;

package/src/ai/code-capability-routes.ts

@@ -1,6 +1,7 @@
 import { type Context, Hono } from "hono";
 import { z } from "zod";
 import { readBoundedJson } from "../_internal/bounded-json";
+import { withCapabilityRequestTimeout } from "../_internal/capability-timeout";
 import { dispatchCapability } from "../api/capabilities";
 import { dispatchCapabilityStream } from "../api/capability-streams";
 import { CAPABILITY_MAX_REQUEST_BYTES } from "../contracts/capabilities";
@@ -37,30 +38,33 @@ export function createCodeCapabilityRoutes(
     credentialKind: "session",
     scopes: [],
   });
-  const invoke = async (c: Context<AuthContext>, review = false) => {
-    const body = await readBoundedJson(c.req.raw, CAPABILITY_MAX_REQUEST_BYTES);
-    const input = body.ok ? Input.safeParse(body.data) : null;
-    if (!input?.success) return Response.json({ code: "VALIDATION_FAILED", message: "Invalid capability input" }, { status: 400 });
-    const conversation = await store.getConversation({ conversationId: c.req.param("conversationId")! });
-    const appId = c.req.param("appId")!;
-    const capabilityId = c.req.param("capabilityId")!;
-    if (conversation?.allowedTools && !conversation.allowedTools.includes(`${appId}.${capabilityId}`)) return denied();
-    const config = await store.getTurnRunConfig({ conversationId: c.req.param("conversationId")!, turnId: c.req.param("turnId")! });
-    if (!config || config.kind === "compact") return denied();
-    return (dependencies.dispatch ?? dispatchCapability)({
-      request: c.req.raw,
-      authority: turnAuthority(c),
-      origin: "assistant",
-      continuation: codeCapabilityOperation(c.req.param("conversationId")!, c.req.param("turnId")!),
-      mandate: config.mandate ? { mandateId: config.mandate.id, mandateRevision: config.mandate.revision, ownerAppId: "core" } : undefined,
-      review,
-      kind: review || c.req.param("kind") === "actions" ? "actions" : "queries",
-      appId,
-      capabilityId,
-      input: input.data.input,
-      locale: getLocale(c),
+  const invoke = async (c: Context<AuthContext>, review = false) =>
+    withCapabilityRequestTimeout(c, review ? "review" : c.req.param("kind") === "actions" ? "action" : "query", async () => {
+      const body = await readBoundedJson(c.req.raw, CAPABILITY_MAX_REQUEST_BYTES);
+      const input = body.ok ? Input.safeParse(body.data) : null;
+      if (!input?.success) return Response.json({ code: "VALIDATION_FAILED", message: "Invalid capability input" }, { status: 400 });
+      const conversation = await store.getConversation({ conversationId: c.req.param("conversationId")! });
+      const appId = c.req.param("appId")!;
+      const capabilityId = c.req.param("capabilityId")!;
+      if (conversation?.allowedTools && !conversation.allowedTools.includes(`${appId}.${capabilityId}`)) return denied();
+      const config = await store.getTurnRunConfig({ conversationId: c.req.param("conversationId")!, turnId: c.req.param("turnId")! });
+      if (!config || config.kind === "compact") return denied();
+      return (dependencies.dispatch ?? dispatchCapability)({
+        request: c.req.raw,
+        authority: turnAuthority(c),
+        origin: "assistant",
+        continuation: codeCapabilityOperation(c.req.param("conversationId")!, c.req.param("turnId")!),
+        mandate: config.mandate
+          ? { mandateId: config.mandate.id, mandateRevision: config.mandate.revision, ownerAppId: "core" }
+          : undefined,
+        review,
+        kind: review || c.req.param("kind") === "actions" ? "actions" : "queries",
+        appId,
+        capabilityId,
+        input: input.data.input,
+        locale: getLocale(c),
+      });
     });
-  };
   return new Hono<AuthContext>()
     .use("/:conversationId/:turnId/*", async (c, next) => {
       await next();

package/src/ai/code-runtime-tools.ts

@@ -4,7 +4,8 @@ import { readBoundedJson } from "../_internal/bounded-json";
 import { getApp } from "../_internal/registry";
 import type { RequestActor } from "../server";
 import { IDENTITY_REFRESH_TIMEOUT_MS } from "../services/identity/constants";
-import { signInvocationToken } from "../services/identity/invocation-token";
+import { invocationAuthorityFromRequest } from "../services/identity/invocation-authority";
+import { issueInvocationToken as signInvocationToken } from "../services/identity/issue-invocation";
 import { withActiveIdentitySigner } from "../services/identity/key-ring";
 import { logger } from "../services/logging";
 import { LOCALE_HEADER } from "../shared/locale";
@@ -62,11 +63,12 @@ export const runManagedCodeTool =
     if (!runConfig || runConfig.kind === "compact" || Boolean(runConfig.background) !== Boolean(runConfig.mandate)) {
       throw new Error("Code execution requires a valid turn and task-scoped background authority.");
     }
-    const { actor } = await resolveAiCapabilityActor({
+    const authority = await resolveAiCapabilityActor({
       conversationId: context.conversationId,
       persistedActor: context.actor,
       store: aiConversations,
     });
+    const { actor } = authority;
     await authorizeCodeExecution(context.conversationId, context.turnId, actor.user.id);
     await context.reportProgress?.(context.locale?.startsWith("de") ? "Ausführungshost verbinden" : "Connecting execution host");
     const app = await getApp("assistant");
@@ -81,21 +83,17 @@ export const runManagedCodeTool =
         try {
           return await withActiveIdentitySigner(
             "invocation",
-            (signer) =>
-              signInvocationToken({
-                ...audience,
-                schemaHash: null,
-                authority: {
-                  sub: actor.user.id,
-                  principal_type: "user",
-                  access_subject_type: "user",
-                  access_subject_id: actor.user.id,
-                  credential_kind: "session",
-                  scopes: [],
+            (signer, db) =>
+              signInvocationToken(
+                {
+                  ...audience,
+                  schemaHash: null,
+                  authority: invocationAuthorityFromRequest(authority),
+                  signer,
+                  issuer: signer.issuer,
                 },
-                signer,
-                issuer: signer.issuer,
-              }),
+                { db, groupsAdmin: signer.groupsAdmin },
+              ),
             { signal: context.signal, timeoutMs: ISSUANCE_TIMEOUT_MS },
           );
         } catch (error) {

package/src/ai/code-source-tools.ts

@@ -8,7 +8,8 @@ import {
   completeCapabilityClaim,
   markCapabilityClaimUncertain,
 } from "../capabilities/claims";
-import { signInvocationToken } from "../services/identity/invocation-token";
+import { invocationAuthorityFromRequest } from "../services/identity/invocation-authority";
+import { issueInvocationToken as signInvocationToken } from "../services/identity/issue-invocation";
 import { withActiveIdentitySigner } from "../services/identity/key-ring";
 import { LOCALE_HEADER } from "../shared/locale";
 import { resolveAiCapabilityActor } from "./capability-execution";
@@ -53,11 +54,12 @@ export function createCodeSourceTool(name: CodeSourceToolName) {
     promptHint: "promptHint" in definition ? definition.promptHint : undefined,
   }).server(async (input, context) => {
     if (!context.conversationId) throw new Error("Code tools require an Assistant conversation.");
-    const { actor } = await resolveAiCapabilityActor({
+    const authority = await resolveAiCapabilityActor({
       conversationId: context.conversationId,
       persistedActor: context.actor,
       store: aiConversations,
     });
+    const { actor } = authority;
     const databaseOperations: Partial<Record<CodeSourceToolName, string>> = {
       code_sql: "query",
       code_database_read: "status",
@@ -97,23 +99,19 @@ export function createCodeSourceTool(name: CodeSourceToolName) {
       await authorizeDatabase?.();
       const signed = await withActiveIdentitySigner(
         "invocation",
-        (signer) =>
-          signInvocationToken({
-            targetAppId: "assistant",
-            callingAppId: "core",
-            operation: `tool:${name}`,
-            schemaHash: null,
-            authority: {
-              sub: actor.user.id,
-              principal_type: "user",
-              access_subject_type: "user",
-              access_subject_id: actor.user.id,
-              credential_kind: "session",
-              scopes: [],
+        (signer, db) =>
+          signInvocationToken(
+            {
+              targetAppId: "assistant",
+              callingAppId: "core",
+              operation: `tool:${name}`,
+              schemaHash: null,
+              authority: invocationAuthorityFromRequest(authority),
+              signer,
+              issuer: signer.issuer,
             },
-            signer,
-            issuer: signer.issuer,
-          }),
+            { db, groupsAdmin: signer.groupsAdmin },
+          ),
         { signal, timeoutMs: 5000 },
       );
       const headers = new Headers({ authorization: `Bearer ${signed.token}`, "content-type": "application/json" });