deepspace 0.28.0 → 0.28.2

package/dist/worker.js

@@ -2600,7 +2600,12 @@ async function executeTool(ctx, toolName, params, userId, userRole, skipUserRbac
     case "user.current": {
       if (!userId) return { success: false, error: "No userId provided" };
       const user = getUser(ctx.sql, userId, ctx.schemaRegistry);
-      if (!user) return { success: false, error: "User not found" };
+      if (!user) {
+        return {
+          success: false,
+          error: "No users row for this identity yet \u2014 it is created by signing in to the app in a browser. Tool access does not require one, so other tools keep working."
+        };
+      }
       return { success: true, data: { user } };
     }
     // The same roster the socket's `user.list` returns, for the same caller.
@@ -7450,8 +7455,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(
@@ -7465,16 +7470,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";
@@ -7909,6 +7919,9 @@ function locateTrimmableArray(result) {
   }
   return void 0;
 }
+function utf8ByteLength(text) {
+  return new TextEncoder().encode(text).byteLength;
+}
 function capToolResultSize(result, byteCap) {
   let serialized;
   try {
@@ -7917,7 +7930,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) {
@@ -7926,7 +7939,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;
         }
@@ -7946,7 +7959,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)
   };
 }
@@ -8098,10 +8111,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)
@@ -9100,38 +9118,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
@@ -9171,13 +9194,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);
@@ -9597,9 +9620,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);
@@ -9928,6 +9951,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() {
@@ -10206,6 +10247,280 @@ 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, detail) {
+  const errors = {
+    unauthenticated: "Authentication is required.",
+    // The remedy is documented and single-step (local-agent-tools.md): a
+    // signed-in app visit creates or refreshes the caller's user row.
+    forbidden: "You are not allowed to use assistant tools. Sign in to the app once in a browser (a signed-in visit creates your user row), or ask the app owner for access.",
+    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."
+  };
+  const error = detail ? `${errors[code]} ${detail}` : errors[code];
+  return jsonResponse3({ ok: false, code, error }, status);
+}
+function validationDetail(error) {
+  const issues = error.issues;
+  if (Array.isArray(issues) && issues.length > 0) {
+    const shown = issues.slice(0, 5).map((issue) => {
+      const { path, message } = issue ?? {};
+      const at = Array.isArray(path) && path.length > 0 ? `${path.join(".")}: ` : "";
+      return `${at}${typeof message === "string" ? message : "invalid"}`;
+    });
+    const more = issues.length - shown.length;
+    return `${shown.join("; ")}${more > 0 ? ` (+${more} more)` : ""}`;
+  }
+  if (!(error instanceof Error) || !error.message) return void 0;
+  const line = error.message.replace(/\s+/g, " ").trim();
+  return line.length > 400 ? `${line.slice(0, 400)}\u2026` : line;
+}
+function droppedTopLevelKeys(schema, input, validated) {
+  if (input === null || typeof input !== "object" || Array.isArray(input) || validated === null || typeof validated !== "object" || Array.isArray(validated)) {
+    return [];
+  }
+  try {
+    const jsonSchema2 = schema.jsonSchema;
+    if (jsonSchema2?.type !== "object" || jsonSchema2.additionalProperties !== false) return [];
+  } catch {
+    return [];
+  }
+  return Object.keys(input).filter((key) => !Object.hasOwn(validated, key));
+}
+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) {
+      const names = Object.keys(tools).filter((name) => typeof tools[name]?.execute === "function").sort();
+      const listed = names.slice(0, 20).join(", ");
+      return errorResponse(
+        404,
+        "tool_not_found",
+        names.length > 0 ? `Available tools: ${listed}${names.length > 20 ? ", \u2026" : ""}.` : void 0
+      );
+    }
+    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;
+    const schema = asSchema(tool3.inputSchema);
+    try {
+      const validation = schema.validate;
+      if (validation) {
+        const result = await validation(input);
+        if (!result.success) {
+          return errorResponse(400, "invalid_tool_input", validationDetail(result.error));
+        }
+        const dropped = droppedTopLevelKeys(schema, input, result.value);
+        if (dropped.length > 0) {
+          return errorResponse(
+            400,
+            "invalid_tool_input",
+            `Unknown input field(s): ${dropped.join(", ")} \u2014 the tool's inputSchema lists the accepted fields.`
+          );
+        }
+        input = result.value;
+      }
+    } catch (error) {
+      return errorResponse(400, "invalid_tool_input", validationDetail(error));
+    }
+    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 = [
@@ -10223,6 +10538,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,
@@ -10274,6 +10592,7 @@ export {
   MSG_SYNC_UPDATE,
   MSG_YJS_AWARENESS,
   MSG_YJS_SYNC,
+  PRODUCTION_OFFICIAL_AGENT_ORIGINS,
   PresenceRoom,
   REACTIONS_SCHEMA,
   READ_RECEIPTS_SCHEMA,
@@ -10292,6 +10611,7 @@ export {
   RegistryClientError,
   SDK_RUN_WORKER_FIRST,
   SECURE_ROOM_BOUNDARIES_MIGRATION_ID,
+  SESSION_COOKIE,
   STRICT_APP_ID_RE,
   SYSTEM_ASSIGNED_COLUMNS,
   SYSTEM_COLLECTIONS,
@@ -10304,6 +10624,7 @@ export {
   USERS_COLUMNS,
   WORKER_OWNED_NOT_FOUND_MIGRATION_ID,
   YjsRoom,
+  agentTokenIssuer,
   apiWorkerFetch,
   appendMessage,
   applyAiToolDefaults,
@@ -10337,6 +10658,7 @@ export {
   createDeepSpaceAuth,
   createEncoder,
   createScopedR2Handler,
+  createUserToolExecutor,
   dataToColumnValues,
   decodeJwtPayload,
   deepSpaceAgentErrorSummary,
@@ -10382,6 +10704,7 @@ export {
   mintAppId,
   mintUlid,
   noopPermissionContext,
+  normalizeAgentTargetOrigin,
   normalizeKnowledgeFolder,
   parseQuotaLimit,
   platformCorsPatterns,
@@ -10390,10 +10713,12 @@ export {
   priceBindingUsageEvent,
   readVarUint,
   readVarUint8Array,
+  registerAgentToolRoutes,
   registerClientErrorRoute,
   registerDeepSpaceDocumentation,
   registryErrorJson,
   registryStub,
+  resolveAppMembership,
   resolveAppName,
   resolveAppRole,
   resolveColumn,
@@ -10417,6 +10742,7 @@ export {
   validateAppName,
   validateBindingManifest,
   validateDoManifest,
+  verifyAgentToken,
   verifyJwt,
   writeVarUint,
   writeVarUint8Array