deepspace 0.27.1 → 0.28.1

package/dist/worker.js

@@ -1345,7 +1345,7 @@ function handleDelete(ctx, ws, attachment, payload) {
     ctx.send(ws, serverBuild.error(result.error));
   }
 }
-function putRecord(ctx, collection, recordId, data, userId, userRole, skipUserRbac = false, systemUpdate = false) {
+function putRecord(ctx, collection, recordId, data, userId, userRole, skipUserRbac = false, systemUpdate = false, updateOnly = false) {
   const resolved = resolveCollection(ctx, collection);
   if (!resolved.ok) return { success: false, error: resolved.error };
   const schema = resolved.schema;
@@ -1363,6 +1363,12 @@ function putRecord(ctx, collection, recordId, data, userId, userRole, skipUserRb
   }
   const existing = getRecord(ctx.sql, collection, recordId, schema);
   const isUpdate = existing !== null;
+  if (updateOnly && !isUpdate) {
+    return {
+      success: false,
+      error: `records.update: no record "${recordId}" in ${collection} \u2014 updates never create; use records.create.`
+    };
+  }
   const mergedData = isUpdate ? { ...existing.data, ...data } : { ...data };
   for (const col of columns) {
     if (col.readonly) continue;
@@ -2521,7 +2527,7 @@ async function executeTool(ctx, toolName, params, userId, userRole, skipUserRbac
       if (!collection) return { success: false, error: "Missing required param: collection" };
       if (!recordId) return { success: false, error: "Missing required param: recordId" };
       if (!data) return { success: false, error: "Missing required param: data" };
-      return putRecord(ctx, collection, recordId, data, userId, userRole, skipUserRbac);
+      return putRecord(ctx, collection, recordId, data, userId, userRole, skipUserRbac, false, true);
     }
     case "records.delete": {
       const collection = params.collection;
@@ -6186,10 +6192,10 @@ async function writeQuotaSummary(bucket, key, previousEtag, summary) {
   });
   return object ? { etag: object.etag, summary } : null;
 }
-async function ensureQuotaSummary(bucket, storage, prefixes, forceMeasure = false, excludedMarkerKey) {
+async function ensureQuotaSummary(bucket, storage, prefixes, measure = "reuse", excludedMarkerKey) {
   for (let attempt = 0; attempt < 4; attempt++) {
     const current = await readQuotaSummary(bucket, storage.quotaKey);
-    if (!forceMeasure && current.summary && accountPrefixesEqual(current.summary.prefixes, prefixes)) {
+    if (measure !== "force" && current.summary && accountPrefixesEqual(current.summary.prefixes, prefixes) && !(measure === "repairDirty" && current.summary.dirty && Date.now() - current.summary.measuredAt >= QUOTA_REPAIR_COOLDOWN_MS)) {
       return current;
     }
     const usedBytes = await measuredAllocationUsage(bucket, storage, prefixes, excludedMarkerKey);
@@ -6377,7 +6383,7 @@ async function reserveQuotaSummary(bucket, storage, prefixes, initial, chargeByt
         bucket,
         storage,
         prefixes,
-        false,
+        "reuse",
         markerKey ?? void 0
       );
       if (!ensured) {
@@ -6402,7 +6408,7 @@ async function reserveQuotaSummary(bucket, storage, prefixes, initial, chargeByt
         bucket,
         storage,
         prefixes,
-        true,
+        "force",
         markerKey ?? void 0
       );
       if (!refreshed?.summary) {
@@ -6495,7 +6501,7 @@ async function storageUsage(bucket, storage) {
   try {
     const prefixes = await allocationPrefixes(storage);
     if (prefixes === null) return null;
-    const current = await ensureQuotaSummary(bucket, storage, prefixes);
+    const current = await ensureQuotaSummary(bucket, storage, prefixes, "repairDirty");
     return current?.summary?.usedBytes ?? null;
   } catch (error) {
     console.error("[files:quota] usage:", error);
@@ -7444,8 +7450,8 @@ function buildCronContext(env, ownerUserId, roomId = "default") {
 }
 
 // src/server/utils/app-role.ts
-async function resolveAppRole(env, userId) {
-  if (userId === env.OWNER_USER_ID) return "admin";
+async function resolveAppMembership(env, userId, signal) {
+  if (userId === env.OWNER_USER_ID) return { member: true, role: "admin" };
   const stub = env.RECORD_ROOMS.get(env.RECORD_ROOMS.idFromName(`app:${env.DEEPSPACE_APP_ID}`));
   try {
     const res = await stub.fetch(
@@ -7459,16 +7465,21 @@ async function resolveAppRole(env, userId) {
         body: JSON.stringify({
           tool: "records.get",
           params: { collection: "users", recordId: userId }
-        })
+        }),
+        signal
       })
     );
     const json = await res.json();
-    const role = json.data?.record?.data?.role;
-    return json.success && isWriterRole(role) ? role : "viewer";
+    if (!json.success || !json.data?.record) return { member: false, role: "viewer" };
+    const role = json.data.record.data?.role;
+    return { member: true, role: isWriterRole(role) ? role : "viewer" };
   } catch {
-    return "viewer";
+    return null;
   }
 }
+async function resolveAppRole(env, userId) {
+  return (await resolveAppMembership(env, userId))?.role ?? "viewer";
+}
 
 // src/server/utils/ai.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
@@ -7903,6 +7914,9 @@ function locateTrimmableArray(result) {
   }
   return void 0;
 }
+function utf8ByteLength(text) {
+  return new TextEncoder().encode(text).byteLength;
+}
 function capToolResultSize(result, byteCap) {
   let serialized;
   try {
@@ -7911,7 +7925,7 @@ function capToolResultSize(result, byteCap) {
     return { success: false, error: "Tool result could not be serialized." };
   }
   if (typeof serialized !== "string") return result;
-  if (serialized.length <= byteCap) return result;
+  if (utf8ByteLength(serialized) <= byteCap) return result;
   if (result && typeof result === "object") {
     const located = locateTrimmableArray(result);
     if (located) {
@@ -7920,7 +7934,7 @@ function capToolResultSize(result, byteCap) {
       const build = (k) => setPath(result, path, items.slice(0, k), { truncated: true, returned: k, total });
       const fits = (k) => {
         try {
-          return JSON.stringify(build(k)).length <= byteCap;
+          return utf8ByteLength(JSON.stringify(build(k))) <= byteCap;
         } catch {
           return false;
         }
@@ -7940,7 +7954,7 @@ function capToolResultSize(result, byteCap) {
   return {
     success: false,
     truncated: true,
-    error: `Tool result exceeded ${byteCap} bytes (was ${serialized.length}). Retry with a narrower query (e.g. add a \`where\` filter, reduce \`limit\`, or call records.get for a single record).`,
+    error: `Tool result exceeded ${byteCap} bytes (was ${utf8ByteLength(serialized)}). Retry with a narrower query (e.g. add a \`where\` filter, reduce \`limit\`, or call records.get for a single record).`,
     preview: serialized.slice(0, 2e3)
   };
 }
@@ -8092,10 +8106,15 @@ async function prepareMessagesWithCompaction(messages, config, options) {
         newSummary: { text, throughId }
       };
     } catch (err) {
-      console.error("prepareMessagesWithCompaction: summarizer failed, falling back to sliding window", err);
+      console.error(
+        "prepareMessagesWithCompaction: summarizer failed, falling back to sliding window",
+        err
+      );
     }
   } else {
-    console.warn("prepareMessagesWithCompaction: messages lack ids; cannot anchor a summary, falling back to sliding window");
+    console.warn(
+      "prepareMessagesWithCompaction: messages lack ids; cannot anchor a summary, falling back to sliding window"
+    );
   }
   return {
     messages: applySlidingWindow(working, config.contextBudget, config.minKept)
@@ -9094,38 +9113,43 @@ function documentationLimiterErrorSummary(error) {
   });
 }
 
-// src/documentation/worker/request-body.ts
-var RequestBodyTooLargeError = class extends Error {
+// src/shared/bounded-body.ts
+var BodyTooLargeError = class extends Error {
   constructor(maxBytes) {
-    super(`Request body exceeds ${maxBytes} bytes`);
+    super(`Body exceeds ${maxBytes} bytes`);
     this.maxBytes = maxBytes;
-    this.name = "RequestBodyTooLargeError";
+    this.name = "BodyTooLargeError";
   }
 };
-async function readBoundedRequestText(request2, maxBytes) {
+async function readBoundedBodyText(source, maxBytes) {
   if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
     throw new TypeError("maxBytes must be a positive safe integer");
   }
-  const declared = request2.headers.get("content-length");
+  const declared = source.headers.get("content-length");
   if (declared && /^\d+$/.test(declared.trim()) && Number(declared) > maxBytes) {
-    throw new RequestBodyTooLargeError(maxBytes);
+    await source.body?.cancel().catch(() => void 0);
+    throw new BodyTooLargeError(maxBytes);
   }
-  if (!request2.body) return "";
-  const reader = request2.body.getReader();
+  if (!source.body) return "";
+  const reader = source.body.getReader();
   const decoder = new TextDecoder();
   let bytes = 0;
   let text = "";
-  while (true) {
-    const chunk = await reader.read();
-    if (chunk.done) break;
-    bytes += chunk.value.byteLength;
-    if (bytes > maxBytes) {
-      await reader.cancel().catch(() => void 0);
-      throw new RequestBodyTooLargeError(maxBytes);
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      bytes += chunk.value.byteLength;
+      if (bytes > maxBytes) {
+        await reader.cancel().catch(() => void 0);
+        throw new BodyTooLargeError(maxBytes);
+      }
+      text += decoder.decode(chunk.value, { stream: true });
     }
-    text += decoder.decode(chunk.value, { stream: true });
+    return text + decoder.decode();
+  } finally {
+    reader.releaseLock();
   }
-  return text + decoder.decode();
 }
 
 // src/documentation/worker/assistant-routes.ts
@@ -9165,13 +9189,13 @@ function registerDocumentationAssistantRoutes(app, resolveAuth, publicBasePath =
     }
     let body = null;
     try {
-      const raw = await readBoundedRequestText(c.req.raw, MAX_REQUEST_BYTES);
+      const raw = await readBoundedBodyText(c.req.raw, MAX_REQUEST_BYTES);
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         body = parsed;
       }
     } catch (error) {
-      if (error instanceof RequestBodyTooLargeError) {
+      if (error instanceof BodyTooLargeError) {
         return c.json({ error: `request exceeds ${MAX_REQUEST_BYTES} bytes` }, 413);
       }
       return c.json({ error: "request body must be valid JSON" }, 400);
@@ -9591,9 +9615,9 @@ function registerDocumentationMcpRoutes(app, publicBasePath = DOCUMENTATION_BASE
     }
     let raw;
     try {
-      raw = await readBoundedRequestText(c.req.raw, MAX_REQUEST_BYTES2);
+      raw = await readBoundedBodyText(c.req.raw, MAX_REQUEST_BYTES2);
     } catch (error) {
-      if (error instanceof RequestBodyTooLargeError) {
+      if (error instanceof BodyTooLargeError) {
         return mcpError(null, -32600, `Request exceeds ${MAX_REQUEST_BYTES2} bytes`, 413);
       }
       return mcpError(null, -32700, "Unable to read request body", 400);
@@ -9922,6 +9946,24 @@ async function verifyJwt(config, token) {
   }
 }
 
+// src/server/auth/agentToken.ts
+var AGENT_TOKEN_SCOPE = "agent";
+function agentTokenIssuer(issuer) {
+  return `${issuer.replace(/\/+$/, "")}/agent`;
+}
+async function verifyAgentToken(config, token, targetOrigin) {
+  const outcome = await verifyJwt(
+    {
+      ...config,
+      issuer: agentTokenIssuer(config.issuer),
+      audience: targetOrigin
+    },
+    token
+  );
+  if (!outcome.result || outcome.result.claims.scope === AGENT_TOKEN_SCOPE) return outcome;
+  return { ...outcome, result: null, error: new Error("Invalid agent token scope") };
+}
+
 // src/server/auth/internalAuth.ts
 var nodeCryptoPromise = null;
 async function loadNodeCrypto() {
@@ -10200,6 +10242,231 @@ function registerClientErrorRoute(app) {
   app.post(CLIENT_ERROR_PATH, (c) => handleClientErrorReport(c.req.raw));
 }
 
+// src/server/agent-tools.ts
+import { asSchema } from "ai";
+
+// src/shared/agent-tool-protocol.ts
+var AGENT_TOOL_REQUEST_BODY_CAP = 64 * 1024;
+var AGENT_TOOL_RESPONSE_BODY_CAP = 1024 * 1024;
+
+// src/server/agent-tools.ts
+function jsonResponse3(body, status = 200) {
+  return rawJsonResponse(JSON.stringify(body), status);
+}
+function rawJsonResponse(body, status = 200) {
+  return new Response(body, {
+    status,
+    headers: {
+      "Cache-Control": "no-store",
+      "Content-Type": "application/json; charset=utf-8"
+    }
+  });
+}
+function errorResponse(status, code) {
+  const errors = {
+    unauthenticated: "Authentication is required.",
+    forbidden: "You are not allowed to use assistant tools.",
+    access_check_unavailable: "Access could not be verified. Try again.",
+    tool_not_found: "The requested tool is not available.",
+    invalid_json: "The request body must be valid JSON.",
+    invalid_tool_input: "The tool input is invalid.",
+    payload_too_large: "The request body is too large.",
+    tool_configuration_error: "Assistant tools are not configured correctly.",
+    tool_execution_failed: "The tool could not be executed.",
+    invalid_tool_result: "The tool returned an invalid result.",
+    tool_result_too_large: "The tool returned a result that is too large."
+  };
+  return jsonResponse3({ ok: false, code, error: errors[code] }, status);
+}
+function parseToolRequestBody(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  if (!Object.hasOwn(parsed, "input")) return null;
+  return { input: parsed.input };
+}
+function isAsyncIterable(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function") && Symbol.asyncIterator in value;
+}
+function jsonText(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    return typeof serialized === "string" ? serialized : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function executableTool(tools, name) {
+  if (!Object.hasOwn(tools, name)) return void 0;
+  const tool3 = tools[name];
+  return typeof tool3.execute === "function" ? { ...tool3, execute: tool3.execute } : void 0;
+}
+function toolMetadata(tools) {
+  return Object.entries(tools).flatMap(([name, tool3]) => {
+    if (typeof tool3.execute !== "function") return [];
+    const inputSchema = asSchema(tool3.inputSchema);
+    const entry = {
+      name,
+      description: typeof tool3.description === "string" ? tool3.description : "",
+      inputSchema: inputSchema.jsonSchema
+    };
+    if (tool3.outputSchema) entry.outputSchema = asSchema(tool3.outputSchema).jsonSchema;
+    return [entry];
+  }).sort((left, right) => left.name.localeCompare(right.name));
+}
+function createUserToolExecutor(env, userId, signal) {
+  const roomId = env.RECORD_ROOMS.idFromName(`app:${env.DEEPSPACE_APP_ID}`);
+  const room = env.RECORD_ROOMS.get(roomId);
+  return async (toolName, params) => {
+    const response = await room.fetch(
+      new Request("https://internal/api/tools/execute", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-User-Id": userId
+        },
+        body: JSON.stringify({ tool: toolName, params }),
+        signal
+      })
+    );
+    return capToolResultSize(await response.json(), DEFAULT_CONTEXT_CONFIG.toolResultCap);
+  };
+}
+async function resolveCallerTools(options, request2, env) {
+  let access;
+  try {
+    access = await options.resolveAccess(request2, env);
+  } catch {
+    return errorResponse(500, "tool_configuration_error");
+  }
+  if (!access.ok) {
+    return errorResponse(
+      access.status,
+      access.status === 401 ? "unauthenticated" : access.status === 403 ? "forbidden" : "access_check_unavailable"
+    );
+  }
+  try {
+    return options.buildTools(createUserToolExecutor(env, access.auth.userId, request2.signal));
+  } catch {
+    return errorResponse(500, "tool_configuration_error");
+  }
+}
+function registerAgentToolRoutes(app, options) {
+  app.get("/_deepspace/agent/tools", async (c) => {
+    const tools = await resolveCallerTools(options, c.req.raw, c.env);
+    if (tools instanceof Response) return tools;
+    try {
+      const serialized = jsonText({
+        ok: true,
+        app: { id: c.env.DEEPSPACE_APP_ID, name: c.env.APP_NAME },
+        tools: toolMetadata(tools)
+      });
+      if (!serialized || utf8ByteLength(serialized) > AGENT_TOOL_RESPONSE_BODY_CAP) {
+        return errorResponse(500, "tool_configuration_error");
+      }
+      return rawJsonResponse(serialized);
+    } catch {
+      return errorResponse(500, "tool_configuration_error");
+    }
+  });
+  app.post("/_deepspace/agent/tools/:name", async (c) => {
+    const tools = await resolveCallerTools(options, c.req.raw, c.env);
+    if (tools instanceof Response) return tools;
+    let tool3;
+    try {
+      tool3 = executableTool(tools, c.req.param("name"));
+    } catch {
+      return errorResponse(500, "tool_configuration_error");
+    }
+    if (!tool3) return errorResponse(404, "tool_not_found");
+    let text;
+    try {
+      text = await readBoundedBodyText(c.req.raw, AGENT_TOOL_REQUEST_BODY_CAP);
+    } catch (error) {
+      return error instanceof BodyTooLargeError ? errorResponse(413, "payload_too_large") : errorResponse(400, "invalid_json");
+    }
+    const body = parseToolRequestBody(text);
+    if (body === void 0) return errorResponse(400, "invalid_json");
+    if (body === null) return errorResponse(400, "invalid_tool_input");
+    let input = body.input;
+    try {
+      const validation = asSchema(tool3.inputSchema).validate;
+      if (validation) {
+        const result = await validation(input);
+        if (!result.success) return errorResponse(400, "invalid_tool_input");
+        input = result.value;
+      }
+    } catch {
+      return errorResponse(400, "invalid_tool_input");
+    }
+    let output;
+    try {
+      output = await tool3.execute(input, {
+        toolCallId: crypto.randomUUID(),
+        messages: [],
+        abortSignal: c.req.raw.signal
+      });
+    } catch {
+      return errorResponse(500, "tool_execution_failed");
+    }
+    if (isAsyncIterable(output)) return errorResponse(500, "invalid_tool_result");
+    try {
+      if (tool3.outputSchema) {
+        const validation = asSchema(tool3.outputSchema).validate;
+        if (validation) {
+          const result = await validation(output);
+          if (!result.success) return errorResponse(500, "invalid_tool_result");
+          output = result.value;
+        }
+      }
+    } catch {
+      return errorResponse(500, "invalid_tool_result");
+    }
+    const serialized = jsonText(output === void 0 ? null : output);
+    if (!serialized) return errorResponse(500, "invalid_tool_result");
+    if (utf8ByteLength(serialized) > DEFAULT_CONTEXT_CONFIG.toolResultCap) {
+      return errorResponse(500, "tool_result_too_large");
+    }
+    return rawJsonResponse(`{"ok":true,"result":${serialized}}`);
+  });
+  app.all("/_deepspace/agent", () => errorResponse(404, "tool_not_found"));
+  app.all("/_deepspace/agent/*", () => errorResponse(404, "tool_not_found"));
+}
+
+// src/server/agent-target.ts
+var PRODUCTION_OFFICIAL_AGENT_ORIGINS = ["https://admin.deep.space"];
+var PRODUCTION_APP_DOMAIN = "app.space";
+function normalizeAgentTargetOrigin(value, policy) {
+  if (typeof value !== "string" || !value) return null;
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return null;
+  }
+  if (url.username || url.password || url.search || url.hash || url.pathname !== "/") return null;
+  const hostname = url.hostname.toLowerCase();
+  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(hostname);
+  if (loopback) {
+    return policy.allowLoopback && ["http:", "https:"].includes(url.protocol) ? url.origin : null;
+  }
+  if (url.protocol !== "https:" || url.port) return null;
+  if (policy.appDomain.toLowerCase() === PRODUCTION_APP_DOMAIN && PRODUCTION_OFFICIAL_AGENT_ORIGINS.includes(url.origin)) {
+    return url.origin;
+  }
+  const suffix = `.${policy.appDomain.toLowerCase()}`;
+  if (!hostname.endsWith(suffix)) return null;
+  const label = hostname.slice(0, -suffix.length);
+  return !label.includes(".") && validateAppName(label).valid ? url.origin : null;
+}
+
+// src/shared/auth-session.ts
+var SESSION_COOKIE = "__Secure-better-auth.session_token";
+
 // src/shared/log-events.ts
 var LOG_LEVELS = ["debug", "log", "info", "warn", "error"];
 var APP_LOG_EVENT_KEYS = [
@@ -10217,6 +10484,9 @@ export {
   ACCOUNT_STORAGE_LIMIT_BYTES,
   ACTION_ROUTES_BEARER_GUARD_MIGRATION_ID,
   ACTION_TOOLS_DELETE_WHERE_MIGRATION_ID,
+  AGENT_TOKEN_SCOPE,
+  AGENT_TOOL_REQUEST_BODY_CAP,
+  AGENT_TOOL_RESPONSE_BODY_CAP,
   AI_CHATS_SCHEMA,
   AI_MESSAGES_SCHEMA,
   ALLOWED_BINDING_TYPES,
@@ -10268,6 +10538,7 @@ export {
   MSG_SYNC_UPDATE,
   MSG_YJS_AWARENESS,
   MSG_YJS_SYNC,
+  PRODUCTION_OFFICIAL_AGENT_ORIGINS,
   PresenceRoom,
   REACTIONS_SCHEMA,
   READ_RECEIPTS_SCHEMA,
@@ -10286,6 +10557,7 @@ export {
   RegistryClientError,
   SDK_RUN_WORKER_FIRST,
   SECURE_ROOM_BOUNDARIES_MIGRATION_ID,
+  SESSION_COOKIE,
   STRICT_APP_ID_RE,
   SYSTEM_ASSIGNED_COLUMNS,
   SYSTEM_COLLECTIONS,
@@ -10298,6 +10570,7 @@ export {
   USERS_COLUMNS,
   WORKER_OWNED_NOT_FOUND_MIGRATION_ID,
   YjsRoom,
+  agentTokenIssuer,
   apiWorkerFetch,
   appendMessage,
   applyAiToolDefaults,
@@ -10331,6 +10604,7 @@ export {
   createDeepSpaceAuth,
   createEncoder,
   createScopedR2Handler,
+  createUserToolExecutor,
   dataToColumnValues,
   decodeJwtPayload,
   deepSpaceAgentErrorSummary,
@@ -10376,6 +10650,7 @@ export {
   mintAppId,
   mintUlid,
   noopPermissionContext,
+  normalizeAgentTargetOrigin,
   normalizeKnowledgeFolder,
   parseQuotaLimit,
   platformCorsPatterns,
@@ -10384,10 +10659,12 @@ export {
   priceBindingUsageEvent,
   readVarUint,
   readVarUint8Array,
+  registerAgentToolRoutes,
   registerClientErrorRoute,
   registerDeepSpaceDocumentation,
   registryErrorJson,
   registryStub,
+  resolveAppMembership,
   resolveAppName,
   resolveAppRole,
   resolveColumn,
@@ -10411,6 +10688,7 @@ export {
   validateAppName,
   validateBindingManifest,
   validateDoManifest,
+  verifyAgentToken,
   verifyJwt,
   writeVarUint,
   writeVarUint8Array