@k2b/cloud 0.30.0 → 0.32.0

package/src/ai/client-tool-results.ts

@@ -0,0 +1,9 @@
+import type { z } from "zod";
+import { createCloudAiLocalBashTool, createCloudAiLocalTools } from "./default-tools";
+
+// Two 512 KiB Bash streams, fully JSON-escaped at six bytes per character, plus a 64 KiB envelope.
+export const AI_CLIENT_TOOL_ACTION_MAX_BYTES = 2 * 512 * 1024 * 6 + 64 * 1024;
+
+export const aiClientToolOutputSchemas = new Map<string, z.ZodType>(
+  [createCloudAiLocalBashTool(), ...createCloudAiLocalTools()].map((tool) => [tool.def.name, tool.def.outputSchema]),
+);

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

@@ -14,6 +14,7 @@ import { resolveAiCapabilityActor } from "./capability-execution";
 import { CODE_CAPABILITY_TOKEN_HEADER, codeCapabilityOperation } from "./code-capability-transport";
 import { authorizeCodeExecution } from "./code-execution";
 import { aiConversations } from "./store";
+import type { AiApprovalTarget, AiWebsiteReceipt } from "./types";
 
 const log = logger("ai:code-runtime");
 const ISSUANCE_TIMEOUT_MS = 5_000;
@@ -24,7 +25,20 @@ const Reply = z.object({
     status: z.enum(["running", "busy", "done", "lost"]),
     phase: z.enum(["starting", "running", "busy", "waiting_for_user"]).optional(),
     result: z.unknown().optional(),
-    approvals: z.array(z.object({ id: z.uuid(), message: z.string(), decision: z.boolean().nullable() })),
+    approvals: z.array(
+      z.object({
+        id: z.uuid(),
+        approvalId: z.uuid().optional(),
+        message: z.string(),
+        decision: z.boolean().nullable(),
+        /** What the person may remember: the website or Action, derived by the host from the stored request. */
+        remember: z.object({ toolName: z.string(), approvalScope: z.string(), always: z.boolean() }).optional(),
+      }),
+    ),
+    /** The next requests a website approval for this chat let through without asking, after `receiptsAfter`. */
+    receipts: z.array(z.object({ method: z.string(), url: z.string() })).default([]),
+    /** More receipts follow; the answer then leaves out the result until the last one is read. */
+    moreReceipts: z.boolean().default(false),
   }),
 });
 type Context = ToolContext & {
@@ -34,6 +48,9 @@ type Context = ToolContext & {
   locale?: string;
   timeZone?: string;
   reportProgress?: (message: string) => Promise<void>;
+  /** Relays a decision; the managed host consumes the linked platform approval before execution. */
+  requestRelayedApproval?: (message: string, options: { approvalId?: string; target?: AiApprovalTarget }) => Promise<boolean>;
+  reportWebsiteReceipts?: (receipts: AiWebsiteReceipt[]) => Promise<void>;
 };
 
 /** The tab only renders progress and approvals; server calls own all execution and resumption. */
@@ -101,7 +118,7 @@ export const runManagedCodeTool =
       token && token.claims.exp * 1000 - Date.now() >= 10_000 ? token : undefined;
     let signed: Awaited<ReturnType<typeof signInvocationToken>> | undefined;
     let callback: Awaited<ReturnType<typeof signInvocationToken>> | undefined;
-    const request = async (decision?: { id: string; approved: boolean }) => {
+    const request = async ({ decision, receiptsAfter }: { decision?: { id: string; approved: boolean }; receiptsAfter: number }) => {
       context.signal.throwIfAborted();
       await authorizeCodeExecution(context.conversationId!, context.turnId!, actor.user.id);
       signed = usable(signed) ?? (await issue({ targetAppId: "assistant", callingAppId: "core", operation: `tool:${name}` }));
@@ -127,7 +144,7 @@ export const runManagedCodeTool =
         signal: context.signal,
         body: JSON.stringify({
           conversationId: context.conversationId,
-          input: { turnId: context.turnId, callId: context.callId, name, args, ...(decision ? { decision } : {}) },
+          input: { turnId: context.turnId, callId: context.callId, name, args, receiptsAfter, ...(decision ? { decision } : {}) },
         }),
       });
       const body = await readBoundedJson(response, 256 * 1024);
@@ -135,29 +152,41 @@ export const runManagedCodeTool =
         throw new Error("Code host request failed; inspect the existing call before starting another execution");
       return Reply.parse(body.data).data;
     };
+    const backgroundApproval = async (): Promise<boolean> => {
+      throw new Error("Background code cannot request interactive approval. Update task grants in the normal chat.");
+    };
     return waitForManagedCodeCall(
       request,
-      runConfig.background
-        ? {
-            ...context,
-            requestApproval: async () => {
-              throw new Error("Background code cannot request interactive approval. Update task grants in the normal chat.");
-            },
-          }
-        : context,
+      runConfig.background ? { ...context, requestApproval: backgroundApproval, requestRelayedApproval: backgroundApproval } : context,
     );
   };
 
-/** Ordered reviews are replayed through Nessi before consuming a durable result. */
+/**
+ * Ordered reviews are replayed through Nessi before consuming a durable result. Each request a website approval let
+ * through is reported as a receipt as soon as the host names it, so the chat shows it with its full URL whatever the
+ * run's outcome. Receipts arrive page by page after the ones already reported.
+ */
 export async function waitForManagedCodeCall(
-  request: (decision?: { id: string; approved: boolean }) => Promise<z.infer<typeof Reply>["data"]>,
-  context: Pick<ToolContext, "signal" | "requestApproval"> & { locale?: string; reportProgress?: (message: string) => Promise<void> },
+  request: (input: { decision?: { id: string; approved: boolean }; receiptsAfter: number }) => Promise<z.input<typeof Reply>["data"]>,
+  context: Pick<ToolContext, "signal" | "requestApproval"> & {
+    locale?: string;
+    reportProgress?: (message: string) => Promise<void>;
+    /** Relays a decision; the managed host consumes the linked platform approval before execution. */
+    requestRelayedApproval?: (message: string, options: { approvalId?: string; target?: AiApprovalTarget }) => Promise<boolean>;
+    reportWebsiteReceipts?: (receipts: AiWebsiteReceipt[]) => Promise<void>;
+  },
 ): Promise<z.infer<ReturnType<typeof z.json>>> {
   const seen = new Set<string>();
   let lastPhase: string | undefined;
+  let receiptsAfter = 0;
   while (true) {
     context.signal.throwIfAborted();
-    const state = await request();
+    const state = Reply.shape.data.parse(await request({ receiptsAfter }));
+    if (state.receipts.length) {
+      await context.reportWebsiteReceipts?.(state.receipts.map((receipt, index) => ({ index: receiptsAfter + index, ...receipt })));
+      receiptsAfter += state.receipts.length;
+    }
+    if (state.moreReceipts) continue;
     if (state.phase && state.phase !== lastPhase) {
       lastPhase = state.phase;
       const labels = context.locale?.startsWith("de")
@@ -179,9 +208,13 @@ export async function waitForManagedCodeCall(
     // Skipping already resolved reviews would shift Nessi's child action IDs.
     for (const approval of state.approvals) {
       if (seen.has(approval.id)) continue;
-      const approved = await context.requestApproval(approval.message);
+      if (!context.requestRelayedApproval) throw new Error("Managed code approval requires a relay context");
+      const approved = await context.requestRelayedApproval(approval.message, {
+        approvalId: approval.approvalId,
+        target: approval.remember,
+      });
       seen.add(approval.id);
-      if (approval.decision === null) await request({ id: approval.id, approved });
+      if (approval.decision === null) await request({ decision: { id: approval.id, approved }, receiptsAfter });
     }
     if (state.status === "done") {
       // Nessi records a thrown error as a failed tool result the model can act on.

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

@@ -12,15 +12,6 @@ const ArtifactPath = z
   .max(180)
   .regex(/^[a-zA-Z0-9_.-]+(?:\/[a-zA-Z0-9_.-]+)*$/)
   .refine((path) => path.split("/").every((part) => part !== "." && part !== ".."));
-const ArtifactFile = z
-  .object({
-    path: ArtifactPath,
-    content: z
-      .string()
-      .max(1024 * 1024)
-      .describe("Complete source file content; read existing content before replacing it."),
-  })
-  .strict();
 const Icon = z
   .string()
   .regex(/^ti ti-[a-z0-9-]+$/)
@@ -39,15 +30,6 @@ const DatabaseSql = z.object({
   params: z.array(z.json()).max(1000).default([]),
 });
 
-const CodeWriteInput = Id.extend({
-  expectedRevision: z.number().int().positive(),
-  entry: ArtifactPath.optional().describe("index.html for an app with an interface, or the script that code_run executes."),
-  files: z
-    .array(z.union([ArtifactFile, z.object({ path: ArtifactPath, fromFile: AiFileReference }).strict()]))
-    .min(1)
-    .max(64),
-});
-
 const DbName = z
   .string()
   .regex(/^[A-Za-z][A-Za-z0-9_]*$/)
@@ -305,11 +287,33 @@ export const CODE_SOURCE_TOOLS = {
       "Create a private reusable App: an index.html interface with optional style.css and app.js, published actions and optional persistence. Starts with a minimal index.html. For one-off analysis, use code_run with code instead. Returns id and entry path; write source with code_write. Optional icon uses the complete class, e.g. ti ti-chart-bar; omit it when unsure. Does not run or share anything.",
     input: ArtifactCreate.pick({ title: true, description: true, icon: true }),
   },
+  // Source text stays top-level because some providers corrupt strings nested in arrays.
+  // Imports carry only references, so they keep an array and one review per batch.
   code_write: {
     description:
-      "Atomically save complete source files against expectedRevision from code_read/create. Other files stay unchanged. Returns revision and compiler diagnostics; never runs. fromFile imports one exact chat/Project/App file reference as UTF-8 source without printing bytes. File imports receive fresh review because source may be shared or published. Use code_file_stat first; source file and bundle byte limits apply.",
-    review: (input: unknown) => CodeWriteInput.parse(input).files.some((file) => "fromFile" in file),
-    input: CodeWriteInput,
+      "Save one complete source file against expectedRevision from code_read, code_create or the previous write. Other files stay unchanged. Write a multi-file app with one call per file and wait for each result, passing its returned revision as the next expectedRevision; calls sent together in one response share a stale revision, so all but the first fail with CONFLICT. Returns revision, the lines and length of every file, and compiler diagnostics for the saved state; an import of a file not yet written is reported as missing until it is saved. Never runs. Copy exact chat, Project or App files with code_import.",
+    input: Id.extend({
+      expectedRevision: z.number().int().positive().describe("Revision from code_read, code_create or the previous write."),
+      path: ArtifactPath.describe("Relative path of the file to save."),
+      content: z
+        .string()
+        .max(1024 * 1024)
+        .describe("Complete file content as plain text; read existing content before replacing it."),
+      entry: ArtifactPath.optional().describe("index.html for an app with an interface, or the script that code_run executes."),
+    }),
+  },
+  code_import: {
+    description:
+      "Atomically import exact chat, Project or App file references as UTF-8 source files against expectedRevision, without printing their bytes. One fresh review covers the whole batch because source may be shared or published. Use code_file_stat first; source file and bundle byte limits apply. Returns revision, the lines and length of every file, imported and diagnostics. Write source text with code_write.",
+    review: true,
+    input: Id.extend({
+      expectedRevision: z.number().int().positive(),
+      entry: ArtifactPath.optional().describe("index.html for an app with an interface, or the script that code_run executes."),
+      files: z
+        .array(z.object({ path: ArtifactPath, fromFile: AiFileReference }).strict())
+        .min(1)
+        .max(64),
+    }),
   },
   code_remove: {
     description:

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

@@ -21,6 +21,7 @@ import { defineAiTool } from "./tools";
 const WRITE_TOOLS = new Set([
   "code_create",
   "code_write",
+  "code_import",
   "code_remove",
   "code_update",
   "code_fork",
@@ -131,7 +132,7 @@ export function createCodeSourceTool(name: CodeSourceToolName) {
       if (!response.ok) throw new Error("Assistant tool request failed.");
       return { data: reply.data.data, status: response.status };
     };
-    if ("review" in definition && (typeof definition.review === "function" ? definition.review(input) : definition.review)) {
+    if ("review" in definition && definition.review) {
       const preview = z.object({ data: z.object({ message: z.string().min(1) }) }).parse((await send(true)).data).data;
       if (!authorizeDatabase && !(await context.requestApproval(preview.message)))
         throw new Error("The user declined this change. No mutation was sent.");
@@ -191,5 +192,6 @@ export const createCodeSourceTools = () => [
   createCodeSourceTool("code_update"),
   createCodeSourceTool("code_create"),
   createCodeSourceTool("code_write"),
+  createCodeSourceTool("code_import"),
   createCodeSourceTool("code_remove"),
 ];