@k2b/cloud 0.44.0 → 0.46.0

package/src/ai/chat/message-utils.ts

@@ -327,6 +327,7 @@ export const displayToolName = (name: string, locale: string) => {
 
 const BUILT_IN_TOOL_ICONS = new Map<string, string>([
   ["card", "ti ti-layout-cards"],
+  ["map", "ti ti-map-search"],
   ["cloud_card", "ti ti-layout-cards"],
   ["chart", "ti ti-chart-bar"],
   ["survey", "ti ti-forms"],

package/src/ai/chat/tool-names.ts

@@ -10,6 +10,7 @@ const toolNames = i18n.define({
     en: {
       calculate: "Calculate",
       card: "Card",
+      map: "Places and maps",
       chart: "Chart",
       survey: "Survey",
       text_editor: "Text editor",
@@ -86,6 +87,7 @@ const toolNames = i18n.define({
     de: {
       calculate: "Rechnen",
       card: "Karte",
+      map: "Orte und Karten",
       chart: "Diagramm",
       survey: "Umfrage",
       text_editor: "Texteditor",

package/src/ai/chat/turn-layout.ts

@@ -70,11 +70,12 @@ const resultTarget = (block: ToolBlock): string | null => {
 };
 
 const isResult = (block: ToolBlock, phase: AiTurnPhase, codePresentations: boolean): boolean => {
+  if (block.name === "map" && block.result && typeof block.result === "object" && "map" in block.result) return true;
   if (isFailedTool(block) || block.status === "rejected" || block.status === "awaiting_approval") return false;
   // A running delivery reserves its place once its arguments arrived: a new version of an earlier result must find the
   // earlier place before it takes one of its own.
   const delivered = block.status === "completed" || (live(phase) && block.status === "running" && block.args !== undefined);
-  if (block.name === "present" || isCardToolName(block.name) || isChartToolName(block.name)) return delivered;
+  if (block.name === "map" || block.name === "present" || isCardToolName(block.name) || isChartToolName(block.name)) return delivered;
   if (block.name === "code_present") return codePresentations && delivered;
   return hasCapabilityTable(block);
 };

package/src/ai/chat/turn-view.tsx

@@ -23,6 +23,7 @@ import { CompactionBlockView, CompactToolRow, SurveyToolView, TextEditorToolView
 import { CapabilityTablePreview } from "./capability-table";
 import { CloudChartBlock } from "./chart-block";
 import { PresentToolBlock } from "./file-tools";
+import { AiMapToolBlock } from "./map-widget";
 import { useAiChatActions } from "./message-actions";
 import { aiToolIcon, displayToolName, isCardToolName, isChartToolName, isRecord, isSurveyToolName } from "./message-utils";
 import { aiChatMessages } from "./messages";
@@ -438,6 +439,9 @@ function AiTurnResultView(props: { result: Accessor<AiTurnResult | undefined>; r
     <Show when={block()}>
       {(current) => (
         <Switch>
+          <Match when={current().name === "map"}>
+            <AiMapToolBlock block={current()} />
+          </Match>
           <Match when={current().name === "present"}>
             <PresentToolBlock block={current()} />
           </Match>
@@ -653,7 +657,18 @@ export function AiTurnView(props: { segment: Accessor<AiTurnSegment>; disclosure
   const chatActions = useAiChatActions();
   const layout = () => props.segment().layout;
   const results = createMemo(() => new Map(layout().results.map((result) => [result.id, result])));
-  const resultIds = createMemo(() => [...results().keys()]);
+  const isMapFollowup = (id: string) => {
+    const block = results().get(id)?.block;
+    return (
+      block?.name === "map" &&
+      typeof block.result === "object" &&
+      block.result !== null &&
+      "anchor" in block.result &&
+      block.result.anchor === false
+    );
+  };
+  const resultIds = createMemo(() => [...results().keys()].filter((id) => !isMapFollowup(id)));
+  const mapFollowupIds = createMemo(() => [...results().keys()].filter(isMapFollowup));
   const actions = createMemo(() => new Map(layout().actions.map((action) => [action.id, action])));
   const actionIds = createMemo(() => [...actions().keys()]);
   const live = () => isLive(props.segment().phase);
@@ -709,6 +724,7 @@ export function AiTurnView(props: { segment: Accessor<AiTurnSegment>; disclosure
             earlier={() => props.segment().earlier}
           />
         </Show>
+        <For each={mapFollowupIds()}>{(id) => <AiTurnResultView result={() => results().get(id)} receipt={() => false} />}</For>
         <Show when={props.segment().scheduledTask?.stop ? undefined : props.segment().scheduledTask?.reason}>
           {(reason) => (
             <Chat.Activity

package/src/ai/default-tools.ts

@@ -56,6 +56,7 @@ import {
   CloudAiLocalWriteInputSchema,
   CloudAiLocalWriteOutputSchema,
 } from "./local-tool-contracts";
+import { createCloudAiMapTool } from "./map-tool";
 import { createCloudAiMarkdownToPdfTool } from "./markdown-pdf-tool";
 import { createAiTodoTool } from "./todo-tool";
 import { defineAiTool } from "./tools";
@@ -303,6 +304,7 @@ export const CLOUD_AI_DEFERRED_BUILTIN_TOOL_NAMES = new Set<string>([
   "markdown_to_pdf",
   "html_to_pdf",
   "present",
+  "map",
   "read_cloud_resource",
 ]);
 
@@ -314,6 +316,7 @@ export const createConfiguredDefaultCloudAiTools = async (config?: {
 }) => {
   const tools: AiRuntimeTool[] = [
     ...createDefaultCloudAiTools(),
+    createCloudAiMapTool(),
     ...createCodeSourceTools(),
     createCloudAiListFilesTool(),
     createCloudAiReadFileTool(),

package/src/ai/dictation-runtime.ts

@@ -1,5 +1,6 @@
 import { sql } from "bun";
 import { lazySync } from "../_internal/process-sync";
+import { get as getUser } from "../services/accounts/users";
 import { logger, trace } from "../services/logging";
 import { superviseRuntimeTask } from "../services/runtime-lifecycle";
 import { aiModelAccess } from "./model-access";
@@ -85,8 +86,11 @@ export const processAiDictation = async (
     if (!conversation) throw new Error("Conversation unavailable.");
     const subject = { type: "user" as const, userId: task.user_id };
     await aiModelAccess.assertAllowed(task.model_profile_id, subject);
-    if (conversation.project_id && !(await aiProjects.snapshot(conversation.project_id, subject)))
-      throw new Error("Project access unavailable.");
+    if (conversation.project_id) {
+      const user = await getUser({ id: task.user_id });
+      if (!user || !(await aiProjects.snapshot(conversation.project_id, { actor: { kind: "user", user }, accessSubject: subject })))
+        throw new Error("Project access unavailable.");
+    }
     const result = await run({
       task: "dictation",
       traceParent: span,

package/src/ai/executor.ts

@@ -57,6 +57,7 @@ import { answerOpenToolCalls } from "./open-tool-calls";
 import { type AiUserPrefs, aiActorUser, aiUserPrefs } from "./prefs";
 import { createCloudAiReadProjectKnowledgeTool, createCloudAiSearchProjectTool } from "./project-tool";
 import { aiProjects } from "./projects";
+import type { AiResourceContext } from "./projects-authorization";
 import {
   AI_TURN_LEASE_MS,
   type AiTurnBlock,
@@ -306,6 +307,11 @@ const accessSubjectForActor = (actor: RequestActor | undefined): AccessSubject |
   return { type: "service_account", serviceAccountId: actor.serviceAccount.id };
 };
 
+const resourceContextForActor = (actor: RequestActor | undefined): AiResourceContext | null => {
+  const accessSubject = accessSubjectForActor(actor);
+  return actor && accessSubject ? { actor, accessSubject } : null;
+};
+
 export type ExecutorConfig = {
   leaseOwner: string;
   heartbeatMs: number;
@@ -541,7 +547,7 @@ const createEventMapper = (
       args: "args" in patch ? patch.args : existing?.args,
       status: patch.status ?? existing?.status ?? "running",
       at: patch.at ?? existing?.at,
-      result: "result" in patch ? patch.result : existing?.result,
+      result: patch.isError && existing?.result !== undefined ? existing.result : "result" in patch ? patch.result : existing?.result,
       isError: "isError" in patch ? patch.isError : existing?.isError,
       approval: approval && !allowRememberedApprovals ? { ...approval, allowAlways: false, allowChat: false } : approval,
       review: patch.review ?? existing?.review,
@@ -883,7 +889,7 @@ export class AiTurnExecutor {
       if (allowed) material.tools = material.tools.filter((tool) => allowed.has(tool.def.name));
       chatId ||= conversation?.shortId ?? "";
       if (config.project) {
-        const subject = accessSubjectForActor(material.actor);
+        const subject = resourceContextForActor(material.actor);
         const project = subject ? await aiProjects.getByShortId(config.project.id, subject, "read") : null;
         if (!project) {
           throw new AiTurnFailure("not_allowed", "Project access is no longer available.");
@@ -966,11 +972,11 @@ export class AiTurnExecutor {
     const timeZone = String((await coreSettings.get<string>("app.timezone")) || "").trim() || "UTC";
     const promptLocale = normalizeLocale(config.locale ?? (await coreSettings.get<string>("app.locale")));
     const project = config.project;
-    const projectSubject = project ? accessSubjectForActor(material.actor) : null;
+    const projectSubject = project ? resourceContextForActor(material.actor) : null;
     // Skills are an Assistant/default-tool capability. Custom and structured
     // executions must not gain an implicit database dependency or extra tools.
     const skillSubject =
-      defaultToolSource && resolved.profile.capabilities.includes("tools") ? accessSubjectForActor(material.actor) : null;
+      defaultToolSource && resolved.profile.capabilities.includes("tools") ? resourceContextForActor(material.actor) : null;
     const availableSkills = skillSubject
       ? (await aiSkills.list(skillSubject, { authority: toolAuthority })).filter((skill) => skill.enabled)
       : [];
@@ -1074,6 +1080,11 @@ export class AiTurnExecutor {
     const dynamicToolRuntimeContext = {
       turnId,
       reportToolProgress: (callId: string, message: string) => pipeline.reportToolProgress(callId, message),
+      reportToolResult: (callId: string, result: unknown) => pipeline.reportToolResult(callId, result),
+      maxToolResultChars: resolveAiToolResultMaxChars({
+        contextWindow: resolved.provider.contextWindow,
+        configuredMaxChars: settings.maxToolResultChars,
+      }),
       reportWebsiteReceipts: (callId: string, receipts: AiWebsiteReceipt[]) => pipeline.reportWebsiteReceipts(callId, receipts),
       localToolsEnabled: activeTools.some((tool) => tool.def.name === "local_upload"),
       attachedFilePaths: new Set(config.files?.attached.map((file) => file.path) ?? []),
@@ -2495,6 +2506,13 @@ class StreamPipeline {
     await this.maybeSnapshot();
   }
 
+  async reportToolResult(callId: string, result: unknown): Promise<void> {
+    const block = this.blocks.find((block) => block.kind === "tool" && block.callId === callId);
+    if (!block || block.kind !== "tool" || block.status !== "running") return;
+    await this.emitOp(this.mapper.setTool(callId, { result }));
+    await this.maybeSnapshot();
+  }
+
   async reportToolProgress(callId: string, progress: string): Promise<void> {
     const block = this.blocks.find((block) => block.kind === "tool" && block.callId === callId);
     if (!block || block.kind !== "tool" || block.progress === progress) return;

package/src/ai/index.ts

@@ -290,6 +290,7 @@ export {
   type AiProjectReference,
   aiProjects,
 } from "./projects";
+export { type AiResourceContext, AiResourceCredentialError } from "./projects-authorization";
 export {
   type AiProjectsRoutes,
   aiProjectsRoutes,

package/src/ai/map-contracts.ts

@@ -0,0 +1,209 @@
+import { z } from "zod";
+import {
+  GeoAddressSchema,
+  GeoAvailabilityDataSchema,
+  GeoCategorySchema,
+  GeoCostsSchema,
+  GeoPlaceSchema,
+  GeoPlaceSearchInputSchema,
+  GeoPointSchema,
+} from "../contracts/geo";
+import {
+  GeoRouteChangesSchema,
+  GeoRouteOptionsSchema,
+  GeoRoutePlanSchema,
+  GeoRouteSchema,
+  GeoRouteUpdateDataSchema,
+} from "../contracts/geo-route";
+
+/** Provider website text is optional and is not guaranteed to be a valid URL. */
+export const aiMapWebsite = (value: string | undefined): string | undefined => {
+  try {
+    const url = new URL(value ?? "");
+    return url.protocol === "https:" || url.protocol === "http:" ? value : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const label = z.string().trim().min(1).max(160);
+const web = z.object({ placeId: z.string().max(2048), description: z.string().max(600), url: z.url().max(2000) }).strict();
+// A map may accumulate two full Places result pages. Subsequent searches replace the secondary group.
+export const AiMapSchema = z
+  .object({
+    id: z.uuid(),
+    conversationId: z.string(),
+    revision: z.number().int().positive(),
+    title: label,
+    selectionId: z.string().optional(),
+    timeZone: z.string().optional(),
+    kind: z.enum(["places", "route"]),
+    pending: z.boolean().optional(),
+    pendingTurnId: z.uuid().optional(),
+    retryUsesMarks: z.boolean().optional(),
+    originCallId: z.string().optional(),
+    anchorSeq: z.number().int().positive().optional(),
+    viewedAt: z.iso.datetime().optional(),
+    lastSearch: z
+      .object({
+        categories: z.array(GeoCategorySchema),
+        name: GeoPlaceSearchInputSchema.shape.name,
+        near: z.string().optional(),
+        placeId: z.string().optional(),
+        radiusMeters: z.number().optional(),
+        title: label,
+        along: z.object({ fromKm: z.number(), toKm: z.number(), bufferMeters: z.number().optional() }).optional(),
+      })
+      .optional(),
+    searchAddress: z.object({ text: z.string(), address: GeoAddressSchema }).strict().optional(),
+    availability: GeoAvailabilityDataSchema,
+    groups: z.array(z.object({ title: label, places: z.array(GeoPlaceSchema).max(20) }).strict()).max(2),
+    web: z.array(web).max(40),
+    route: GeoRouteSchema.optional(),
+    plan: GeoRoutePlanSchema.optional(),
+    preview: z.object({ result: GeoRouteUpdateDataSchema, changes: GeoRouteChangesSchema, title: label }).strict().optional(),
+    undo: z.object({ route: GeoRouteSchema, title: label }).strict().optional(),
+    receipt: z.object({ title: label, at: z.iso.datetime() }).strict().optional(),
+    candidates: z.array(GeoAddressSchema).max(5).optional(),
+    ambiguousStopId: z.string().optional(),
+    picker: z.array(GeoPlaceSchema).max(5).optional(),
+    retryInsertStopId: z.uuid().optional(),
+    issue: z
+      .object({
+        code: z.string(),
+        scope: z.enum(["person", "cloud"]).optional(),
+        resetsAt: z.string().optional(),
+        retryAfterSeconds: z.number().optional(),
+        costs: GeoCostsSchema.optional(),
+        requiredCredits: z.number().nonnegative().optional(),
+        availableCredits: z.number().optional(),
+        turnId: z.uuid().optional(),
+        requiresCostConfirmation: z.literal(true).optional(),
+        shortfallCredits: z.number().nonnegative().optional(),
+      })
+      .strict()
+      .optional(),
+  })
+  .strict();
+export type AiMap = z.infer<typeof AiMapSchema>;
+
+const search = z
+  .object({
+    categories: z.array(GeoCategorySchema).min(1).max(5),
+    name: GeoPlaceSearchInputSchema.shape.name,
+    near: z.string().min(1).max(300).optional(),
+    placeId: z.string().max(2048).optional(),
+    radiusMeters: z.number().min(1).max(50000).optional(),
+    along: z
+      .object({ fromKm: z.number().nonnegative(), toKm: z.number().positive(), bufferMeters: z.number().min(100).max(5000).optional() })
+      .strict()
+      .optional(),
+    title: label,
+  })
+  .strict();
+// Model-facing inputs cannot inject points, polylines, or a provider result. These are resolved on the server.
+const stop = z
+  .object({
+    id: z.string().min(1).max(40),
+    address: z.string().min(1).max(300).optional(),
+    placeId: z.string().max(2048).optional(),
+    label: label.optional(),
+  })
+  .strict()
+  .refine((value) => Boolean(value.address) !== Boolean(value.placeId), "Supply exactly one address or verified place ID");
+export const AiMapCommandSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("places"), search, web: z.array(web).max(20).optional() }).strict(),
+  z
+    .object({
+      type: z.literal("route"),
+      stops: z
+        .array(stop)
+        .min(2)
+        .max(26)
+        .refine((stops) => new Set(stops.map((s) => s.id)).size === stops.length, "Stop IDs must be unique"),
+      options: GeoRouteOptionsSchema.optional(),
+      title: label,
+    })
+    .strict(),
+  z.object({ type: z.literal("search"), search, insert: z.boolean().optional(), web: z.array(web).max(20).optional() }).strict(),
+  z.object({ type: z.literal("describe"), web: z.array(web).max(40) }).strict(),
+  z
+    .object({
+      type: z.literal("preview"),
+      change: z.discriminatedUnion("type", [
+        z.object({ type: z.literal("insert"), placeId: z.string().max(2048), afterStopId: z.string().optional() }).strict(),
+        z.object({ type: z.literal("move"), stopId: z.string(), toIndex: z.number().int().min(0).max(25) }).strict(),
+        z.object({ type: z.literal("optimize") }).strict(),
+        z
+          .object({
+            type: z.literal("options"),
+            options: GeoRouteOptionsSchema,
+            leg: z.object({ fromStopId: z.string(), toStopId: z.string() }).strict().optional(),
+          })
+          .strict(),
+      ]),
+    })
+    .strict(),
+  z.object({ type: z.literal("choose"), index: z.number().int().min(0).max(4) }).strict(),
+  z.object({ type: z.literal("accept") }).strict(),
+  z.object({ type: z.literal("discard") }).strict(),
+  z.object({ type: z.literal("undo") }).strict(),
+  z.object({ type: z.literal("retry") }).strict(),
+]);
+export const AiMapBrowserCommandSchema = z.union([
+  AiMapCommandSchema,
+  z.object({ type: z.literal("location"), destinationId: z.string(), point: GeoPointSchema }).strict(),
+  z
+    .object({ type: z.literal("repair"), stopId: z.string(), address: z.string().trim().min(1).max(300), point: GeoPointSchema.optional() })
+    .strict(),
+]);
+export type AiMapCommand = z.infer<typeof AiMapBrowserCommandSchema>;
+export const AiMapToolInputSchema = z
+  .object({ mapId: z.uuid().optional(), revision: z.number().int().positive().optional(), command: AiMapCommandSchema })
+  .strict();
+export const AiMapReferenceSchema = AiMapSchema.pick({
+  id: true,
+  conversationId: true,
+  revision: true,
+  title: true,
+  kind: true,
+  pending: true,
+  anchorSeq: true,
+}).extend({ reference: z.literal(true) });
+export const AiMapToolResultSchema = z
+  .object({ map: z.union([AiMapSchema, AiMapReferenceSchema]), anchor: z.boolean(), summary: z.unknown().optional() })
+  .strict();
+/** Geometry belongs to the durable map, never to the model context or streaming result budget. */
+export const aiMapToolResult = (map: AiMap, anchor: boolean): z.infer<typeof AiMapToolResultSchema> => ({
+  anchor,
+  map: {
+    reference: true,
+    id: map.id,
+    conversationId: map.conversationId,
+    revision: map.revision,
+    title: map.title,
+    kind: map.kind,
+    pending: map.pending,
+    anchorSeq: map.anchorSeq,
+  },
+  summary: {
+    mapId: map.id,
+    revision: map.revision,
+    places: map.groups.map((g) => ({
+      title: g.title.slice(0, 64),
+      places: g.places.map((p, i) => ({
+        id: map.groups.indexOf(g) === 0 ? String(i + 1) : String.fromCharCode(65 + i),
+        name: p.name.slice(0, 48),
+      })),
+    })),
+    candidates: map.candidates?.map((p, index) => ({ index, address: p.formatted.slice(0, 96) })),
+    picker: map.picker?.map((p, i) => ({ id: `pick-${i + 1}`, name: p.name.slice(0, 48), atMeters: p.atMeters })),
+    stops: map.route?.stops.map((s) => ({ id: s.id, label: s.label?.slice(0, 48) })),
+    distanceMeters: map.route?.distanceMeters,
+    durationSeconds: map.route?.durationSeconds,
+    preview: map.preview ? { title: map.preview.title, delta: map.preview.result.delta } : undefined,
+    issue: map.issue,
+  },
+});
+export type AiMapToolResult = z.infer<typeof AiMapToolResultSchema>;
+export const AiMapActionSchema = z.object({ revision: z.number().int().positive(), command: AiMapBrowserCommandSchema }).strict();

package/src/ai/map-execution.ts

@@ -0,0 +1,14 @@
+import type { AiMapCommand } from "./map-contracts";
+import { type AiMapContext, applyAiMap } from "./map-service";
+import { type AiMapStored, aiMaps } from "./map-store";
+
+/** Lock and check the revision before provider work; a concurrent or stale click cannot spend against this map. */
+export async function executeStoredAiMap(
+  conversationId: string,
+  ownerUserId: string,
+  before: AiMapStored,
+  command: AiMapCommand,
+  context: AiMapContext,
+) {
+  return aiMaps.mutate(conversationId, ownerUserId, before.map.revision, before.map.id, (current) => applyAiMap(current, command, context));
+}