@k2b/cloud 0.30.0 → 0.31.0

package/src/ai/chat/web-tools.tsx

@@ -1,8 +1,10 @@
-import { Chat, ScrollArea } from "@k2b/ui";
+import { Button, Chat, ScrollArea, useLocale } from "@k2b/ui";
 import { createSignal, For, Show } from "solid-js";
 import { formatAiFileSize } from "../attachments";
 import type { AiTurnBlock } from "../protocol";
+import { useAiChatActions } from "./message-actions";
 import { isRecord } from "./message-utils";
+import { aiChatMessages } from "./messages";
 import { AiToolActivity } from "./tool-disclosure";
 
 type ToolBlock = Extract<AiTurnBlock, { kind: "tool" }>;
@@ -200,3 +202,95 @@ export function FetchFileToolBlock(props: { block: ToolBlock }) {
     </Show>
   );
 }
+
+type WebsiteReceipt = { method: string; url: string };
+
+/**
+ * Requests a website approval for this chat let through without asking, from a code run or a page read. The call
+ * reports them as they go out, so they are there whether it succeeded, failed, or its turn stopped.
+ */
+export const websiteReceipts = (block: ToolBlock): WebsiteReceipt[] => block.receipts ?? [];
+
+const originOf = (url: string): string => {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return url;
+  }
+};
+
+/**
+ * The receipt of every request a website approval let through: one row per website with each full URL, query
+ * included, and a revoke action that makes the next request ask again.
+ */
+export function WebsiteReceipts(props: { block: ToolBlock }) {
+  const actions = useAiChatActions();
+  const locale = useLocale();
+  const t = () => aiChatMessages(locale());
+  const groups = () => {
+    const byOrigin = new Map<string, WebsiteReceipt[]>();
+    for (const receipt of websiteReceipts(props.block)) {
+      const origin = originOf(receipt.url);
+      byOrigin.set(origin, [...(byOrigin.get(origin) ?? []), receipt]);
+    }
+    return [...byOrigin].map(([origin, receipts]) => ({ origin, receipts }));
+  };
+  return (
+    <For each={groups()}>
+      {(group) => {
+        const [state, setState] = createSignal<"idle" | "busy" | "revoked" | "failed">("idle");
+        const host = () => domainOf(group.origin);
+        const revoke = async () => {
+          if (!actions.onRevokeWebsite || state() === "busy") return;
+          setState("busy");
+          try {
+            await actions.onRevokeWebsite(group.origin);
+            setState("revoked");
+          } catch {
+            setState("failed");
+          }
+        };
+        return (
+          <Chat.Activity
+            icon="ti ti-world-check"
+            label={host()}
+            description={
+              state() === "revoked"
+                ? t().websiteRevoked
+                : state() === "failed"
+                  ? t().revokeFailed
+                  : t().websiteAllowedForChat({ count: group.receipts.length })
+            }
+            defaultOpen
+            bodyInset={false}
+            trailing={
+              // The button keeps its place and label once revoked, so nothing moves; the description says it is revoked.
+              <Show when={actions.onRevokeWebsite}>
+                <Button
+                  size="xs"
+                  variant="ghost"
+                  loading={state() === "busy"}
+                  disabled={state() === "revoked"}
+                  aria-label={t().revokeWebsiteFor({ host: host() })}
+                  onClick={() => void revoke()}
+                >
+                  {t().revoke}
+                </Button>
+              </Show>
+            }
+          >
+            <ul class="flex w-full min-w-0 flex-col gap-0.5 rounded-md bg-zinc-100/70 px-2 py-1.5 text-xs [box-shadow:var(--ui-control-recess)] dark:bg-zinc-950/70">
+              <For each={group.receipts}>
+                {(receipt) => (
+                  <li class="min-w-0 break-all font-mono text-[11px] text-secondary">
+                    <span class="font-semibold text-primary">{receipt.method}</span> {receipt.url}
+                  </li>
+                )}
+              </For>
+            </ul>
+          </Chat.Activity>
+        );
+      }}
+    </For>
+  );
+}

package/src/ai/client/controller.ts

@@ -1284,7 +1284,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     conversationId: string,
     turnId: string,
     callId: string,
-    action: { type: "approval_response"; approved: boolean; remember?: "always" } | { type: "tool_result"; result: unknown },
+    action: { type: "approval_response"; approved: boolean; remember?: "chat" | "always" } | { type: "tool_result"; result: unknown },
   ) => {
     if (isActiveConversation(conversationId) && runStatus() === "stopping") return false;
     try {
@@ -1325,7 +1325,7 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
   const submitTurnAction = (
     turnId: string,
     callId: string,
-    action: { type: "approval_response"; approved: boolean; remember?: "always" } | { type: "tool_result"; result: unknown },
+    action: { type: "approval_response"; approved: boolean; remember?: "chat" | "always" } | { type: "tool_result"; result: unknown },
   ) => {
     const conversationId = activeConversationId();
     if (!conversationId) return Promise.resolve(false);
@@ -1333,7 +1333,10 @@ export const createAiChatController = (options: CreateAiChatControllerOptions) =
     return submitTurnActionForConversation(conversationId, turnId, callId, action);
   };
 
-  const respondToApproval = async (request: { turnId: string; callId: string }, input: { approved: boolean; remember?: "always" }) => {
+  const respondToApproval = async (
+    request: { turnId: string; callId: string },
+    input: { approved: boolean; remember?: "chat" | "always" },
+  ) => {
     const conversationId = activeConversationId();
     if (!conversationId) return false;
     const submitted = await submitTurnAction(request.turnId, request.callId, {

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"),
 ];