deepspace 0.33.1 → 0.34.0

package/dist/worker.js

@@ -2374,6 +2374,7 @@ function getAllUserRecords(sql, schemaRegistry) {
 }
 async function registerUser(sql, userId, name, email, imageUrl, isAdmin, defaultRole = "viewer", schemaRegistry) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  const normalizedEmail = email.trim().toLowerCase();
   const existing = getUserRecord(sql, userId, schemaRegistry);
   let role;
   if (isAdmin) {
@@ -2384,7 +2385,7 @@ async function registerUser(sql, userId, name, email, imageUrl, isAdmin, default
     role = defaultRole;
   }
   if (existing) {
-    const updatedEmail = email || existing.data.email;
+    const updatedEmail = normalizedEmail || existing.data.email;
     const updatedName = name && name !== "Anonymous" ? name : existing.data.name;
     const updatedImageUrl = imageUrl ?? existing.data.imageUrl;
     sql.exec(
@@ -2413,14 +2414,14 @@ async function registerUser(sql, userId, name, email, imageUrl, isAdmin, default
     userId,
     now,
     now,
-    email,
+    normalizedEmail,
     name,
     imageUrl ?? null,
     role,
     now,
     now
   );
-  return { id: userId, email, name, imageUrl, role, createdAt: now, lastSeenAt: now };
+  return { id: userId, email: normalizedEmail, name, imageUrl, role, createdAt: now, lastSeenAt: now };
 }
 function rosterFor(ctx, schema, records, publicRoster, userId, role) {
   if (!userId || isAnonymousUserId(userId)) return [];
@@ -2475,16 +2476,19 @@ function broadcastUserList(ctx, except) {
     });
   }
 }
-function handleUserUpdate(ctx, _ws, attachment, payload) {
+function handleUserUpdate(ctx, _ws, attachment) {
   const existing = getUserRecord(ctx.sql, attachment.userId, ctx.schemaRegistry);
   if (!existing) return;
-  const data = { lastSeenAt: (/* @__PURE__ */ new Date()).toISOString() };
-  if (payload.name && payload.name !== "Anonymous") data.name = payload.name;
-  if (payload.email) data.email = payload.email;
-  if (payload.imageUrl !== void 0) data.imageUrl = payload.imageUrl || void 0;
-  putRecord(ctx, "users", attachment.userId, data, attachment.userId, "admin", true, true);
-  const rosterChanged = data.name !== void 0 && data.name !== existing.data.name || data.imageUrl !== void 0 && data.imageUrl !== existing.data.imageUrl;
-  if (rosterChanged) broadcastUserList(ctx);
+  putRecord(
+    ctx,
+    "users",
+    attachment.userId,
+    { lastSeenAt: (/* @__PURE__ */ new Date()).toISOString() },
+    attachment.userId,
+    "admin",
+    true,
+    true
+  );
 }
 async function handleSetRole(ctx, ws, attachment, payload) {
   if (attachment.role !== "admin") {
@@ -3233,7 +3237,7 @@ var RecordRoom = class extends BaseRoom {
         this.schemaRegistry
       );
       const regMs = Date.now() - regStart;
-      if (!before || before.name !== registeredUser.name || before.imageUrl !== registeredUser.imageUrl || before.role !== registeredUser.role) {
+      if (!before || before.name !== registeredUser.name || before.email !== registeredUser.email || before.imageUrl !== registeredUser.imageUrl || before.role !== registeredUser.role) {
         broadcastUserList(this.createUserContext(), ws);
       }
       attachment = {
@@ -3360,12 +3364,7 @@ var RecordRoom = class extends BaseRoom {
         handleUserList(userCtx, ws, attachment);
         break;
       case MSG.USER_UPDATE:
-        handleUserUpdate(
-          recordCtx,
-          ws,
-          attachment,
-          payload
-        );
+        handleUserUpdate(recordCtx, ws, attachment);
         break;
       case MSG.SET_ROLE:
         await handleSetRole(userCtx, ws, attachment, payload);
@@ -4609,6 +4608,7 @@ function computeNextRunAt(task, from) {
 
 // src/server/rooms/job-room.ts
 var RUNNING_STALE_MS = 16 * 60 * 1e3;
+var BACKGROUND_ALARM_MS = 3e4;
 var DEFAULT_RETENTION_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_SNAPSHOT_LIMIT = 100;
 var JobRoom = class extends BaseRoom {
@@ -4617,6 +4617,7 @@ var JobRoom = class extends BaseRoom {
   retentionMs;
   snapshotLimit;
   retryBackoffMs;
+  backgroundJobTypes;
   authorizeWrite;
   authorizeRead;
   broadcastQueue = Promise.resolve();
@@ -4630,6 +4631,7 @@ var JobRoom = class extends BaseRoom {
     this.retentionMs = Math.max(0, config.retentionMs ?? DEFAULT_RETENTION_MS);
     this.snapshotLimit = Math.max(1, config.snapshotLimit ?? DEFAULT_SNAPSHOT_LIMIT);
     this.retryBackoffMs = Math.max(0, config.retryBackoffMs ?? 1e3);
+    this.backgroundJobTypes = new Set(config.backgroundJobTypes ?? []);
     this.authorizeWrite = config.authorizeWrite ?? ((user) => user.role === ROLES.MEMBER || user.role === ROLES.ADMIN);
     this.authorizeRead = config.authorizeRead ?? this.authorizeWrite;
   }
@@ -4877,11 +4879,8 @@ var JobRoom = class extends BaseRoom {
   // ==========================================================================
   // Alarm / execution
   // ==========================================================================
-  /**
-   * Drain due jobs in FIFO order. All due jobs share the alarm's
-   * 15-min wall budget (a CF property, not a per-job allocation).
-   */
   async drainDueJobs() {
+    if (this.inFlight.size > 0) return;
     const cutoff = (/* @__PURE__ */ new Date()).toISOString();
     while (true) {
       const row = this.sql.exec(
@@ -4893,7 +4892,16 @@ var JobRoom = class extends BaseRoom {
         cutoff
       ).toArray()[0];
       if (!row) return;
-      await this.executeJob(row);
+      const execution = this.executeJob(row);
+      if (this.backgroundJobTypes.has(row.type)) {
+        this.state.waitUntil(
+          execution.catch(
+            (error) => console.error(`[jobs] background execution failed: ${loggableError(error)}`)
+          ).finally(() => this.scheduleNextAlarm())
+        );
+        return;
+      }
+      await execution;
     }
   }
   async executeJob(row) {
@@ -4930,7 +4938,7 @@ var JobRoom = class extends BaseRoom {
       this.inFlight.delete(row.id);
     }
     const currentStatus = this.readStatus(row.id);
-    if (currentStatus === "canceled") {
+    if (currentStatus !== "running") {
       this.continueState = null;
       return;
     }
@@ -5062,6 +5070,10 @@ var JobRoom = class extends BaseRoom {
   // Scheduling / recovery / pruning
   // ==========================================================================
   scheduleNextAlarm() {
+    if (this.inFlight.size > 0) {
+      this.state.storage.setAlarm(Date.now() + BACKGROUND_ALARM_MS);
+      return;
+    }
     const queued = this.sql.exec(
       `SELECT next_run_at FROM jobs
           WHERE status = 'queued'
@@ -5095,6 +5107,7 @@ var JobRoom = class extends BaseRoom {
       cutoff
     ).toArray();
     for (const r of stuck) {
+      if (this.inFlight.has(r.id)) continue;
       if (r.attempts >= r.max_attempts) {
         this.sql.exec(
           `UPDATE jobs
@@ -5795,6 +5808,7 @@ var ACTION_TOOLS_DELETE_WHERE_MIGRATION_ID = "2026-08-action-tools-delete-where"
 var BUILD_INJECTED_APP_ID_MIGRATION_ID = "2026-08-build-injected-app-id";
 var ACTION_ROUTES_BEARER_GUARD_MIGRATION_ID = "2026-08-action-routes-bearer-guard";
 var FILES_SESSION_COOKIE_READS_MIGRATION_ID = "2026-09-files-session-cookie-reads";
+var AI_SDK_7_MIGRATION_ID = "2026-09-ai-sdk-7";
 function validateAppMigrationIds(value) {
   if (!Array.isArray(value)) {
     return { valid: false, reason: "app migrations must be a JSON string array" };
@@ -5822,8 +5836,8 @@ function validateAppMigrationIds(value) {
 
 // src/shared/ai-models.ts
 var DEEPSPACE_MODEL_CATALOG_PROVENANCE = {
-  version: "2026-08-04",
-  verifiedAt: "2026-08-04",
+  version: "2026-09-24",
+  verifiedAt: "2026-09-24",
   sources: {
     anthropic: "https://platform.claude.com/docs/en/api/beta/models/list",
     openai: "https://developers.openai.com/api/docs/models/all",
@@ -5849,16 +5863,17 @@ var openAIModel = createMultiStepModelFactory({
   providerLabel: "OpenAI",
   transport: "chat-completions"
 });
+var DIRECT_GENERATION_NOTE = "Available for direct generation; the current proxy adapter has not passed multi-step tool-result continuation.";
 var DEEPSPACE_AI_MODELS = [
   anthropicModel({
-    id: "claude-fable-5",
-    label: "Claude Fable 5",
+    id: "claude-opus-5-5",
+    label: "Claude Opus 5.5",
     family: "Claude 5",
     recommendation: "frontier"
   }),
   anthropicModel({
-    id: "claude-opus-5",
-    label: "Claude Opus 5",
+    id: "claude-fable-5-1",
+    label: "Claude Fable 5.1",
     family: "Claude 5",
     recommendation: "frontier"
   }),
@@ -5875,23 +5890,29 @@ var DEEPSPACE_AI_MODELS = [
     recommendation: "fast"
   }),
   openAIModel({
-    id: "gpt-5.6-sol",
-    label: "GPT-5.6 Sol",
-    family: "GPT-5.6",
-    recommendation: "frontier"
-  }),
-  openAIModel({
-    id: "gpt-5.6-terra",
-    label: "GPT-5.6 Terra",
-    family: "GPT-5.6",
+    id: "gpt-6-sol",
+    label: "GPT-6 Sol",
+    family: "GPT-6",
     recommendation: "balanced"
   }),
   openAIModel({
-    id: "gpt-5.6-luna",
-    label: "GPT-5.6 Luna",
-    family: "GPT-5.6",
+    id: "gpt-6-luna",
+    label: "GPT-6 Luna",
+    family: "GPT-6",
     recommendation: "fast"
   }),
+  {
+    id: "gpt-6-astra",
+    label: "GPT-6 Astra",
+    provider: "openai",
+    providerLabel: "OpenAI",
+    family: "GPT-6",
+    agentSupport: "none",
+    agentProfiles: [],
+    transport: "chat-completions",
+    recommendation: "limited",
+    note: "Available for direct generation; its tool calling requires the Responses API, which the DeepSpace proxy does not serve."
+  },
   {
     id: "gpt-oss-120b",
     label: "GPT-OSS 120B",
@@ -5902,12 +5923,30 @@ var DEEPSPACE_AI_MODELS = [
     agentProfiles: [],
     transport: "chat-completions",
     recommendation: "limited",
-    note: "Available for direct generation; the current proxy adapter has not passed multi-step tool-result continuation."
-  }
+    note: DIRECT_GENERATION_NOTE
+  },
+  {
+    id: "qwen-3.8-27b",
+    label: "Qwen 3.8 27B",
+    provider: "cerebras",
+    providerLabel: "Cerebras",
+    family: "Qwen 3.8",
+    agentSupport: "single-step",
+    agentProfiles: [],
+    transport: "chat-completions",
+    recommendation: "limited",
+    note: DIRECT_GENERATION_NOTE
+  },
+  // Superseded models: still resolvable for apps that saved them.
+  anthropicModel({ id: "claude-opus-5", label: "Claude Opus 5", family: "Claude 5", recommendation: "frontier", legacy: true }),
+  anthropicModel({ id: "claude-fable-5", label: "Claude Fable 5", family: "Claude 5", recommendation: "frontier", legacy: true }),
+  openAIModel({ id: "gpt-5.6-sol", label: "GPT-5.6 Sol", family: "GPT-5.6", recommendation: "frontier", legacy: true }),
+  openAIModel({ id: "gpt-5.6-terra", label: "GPT-5.6 Terra", family: "GPT-5.6", recommendation: "balanced", legacy: true }),
+  openAIModel({ id: "gpt-5.6-luna", label: "GPT-5.6 Luna", family: "GPT-5.6", recommendation: "fast", legacy: true })
 ];
 var DEEPSPACE_AI_DEFAULTS = {
-  agent: "claude-sonnet-5",
-  directGeneration: "claude-sonnet-5",
+  agent: "claude-opus-5-5",
+  directGeneration: "claude-opus-5-5",
   summarization: "claude-haiku-4-5"
 };
 var DEEPSPACE_AGENT_PROFILES = {
@@ -5935,7 +5974,7 @@ function getDeepSpaceAIModel(modelId) {
 function listDeepSpaceAgentModels(profileId = "application") {
   const defaultModel = DEEPSPACE_AGENT_PROFILES[profileId].defaultModel;
   return DEEPSPACE_AI_MODELS.filter(
-    (model) => model.agentProfiles.includes(profileId)
+    (model) => !model.legacy && model.agentProfiles.includes(profileId)
   ).sort((left, right) => Number(right.id === defaultModel) - Number(left.id === defaultModel));
 }
 function resolveDeepSpaceAgentModel(modelId, profileId = "application") {
@@ -6016,6 +6055,10 @@ var BROWSER_PROXY_ROUTES = [
   { method: "GET", path: "/_deepspace/charges/me" }
 ];
 
+// src/shared/sandbox.ts
+var SANDBOX_SCOPES = ["user", "app"];
+var SANDBOX_SCOPE_HEADER = "x-deepspace-sandbox-scope";
+
 // src/server/utils/cors.ts
 function matchOrigin(origin, patterns) {
   if (!origin) return null;
@@ -7664,36 +7707,57 @@ async function resolveAppRole(env, userId) {
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-var ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS = 4096;
-function withDefaultAnthropicMaxTokens(body) {
+
+// src/server/utils/app-identity.ts
+function appendAppIdentity(headers, env) {
+  headers.delete("x-app-identity-token");
+  headers.delete("x-app-id");
+  if (!env.APP_IDENTITY_TOKEN) return;
+  headers.set("x-app-identity-token", env.APP_IDENTITY_TOKEN);
+  headers.set("x-app-id", env.DEEPSPACE_APP_ID);
+}
+
+// src/server/utils/ai.ts
+import { defaultSettingsMiddleware, wrapLanguageModel } from "ai";
+function resolveProxyAuthToken(env, options) {
+  const authToken = options.authToken ?? env.APP_OWNER_JWT;
+  if (!authToken) {
+    throw new Error(
+      "DeepSpace AI proxy: no auth token available. Either pass `options.authToken` explicitly (for user-initiated calls), or ensure `env.APP_OWNER_JWT` is set (injected at deploy time or by `deepspace dev start`)."
+    );
+  }
+  return authToken;
+}
+function setProxyHeaders(headers, env, authToken, scope = "user") {
+  headers.set("X-Auth-Token", authToken);
+  appendAppIdentity(headers, {
+    DEEPSPACE_APP_ID: env.DEEPSPACE_APP_ID ?? "",
+    APP_IDENTITY_TOKEN: env.APP_IDENTITY_TOKEN
+  });
+  headers.set(SANDBOX_SCOPE_HEADER, scope);
+}
+var ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS = 64e3;
+var OPENAI_TOOLS_NEED_NO_REASONING = /^gpt-(5\.6|6)-(sol|terra|luna)(-|$)/;
+function withOpenAIToolReasoningEffort(body) {
   if (typeof body !== "string") return body;
   try {
     const parsed = JSON.parse(body);
-    const hasExplicitLimit = typeof parsed.max_tokens === "number" || typeof parsed.max_completion_tokens === "number" || typeof parsed.max_output_tokens === "number";
-    if (hasExplicitLimit) return body;
-    return JSON.stringify({
-      ...parsed,
-      max_tokens: ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
-    });
+    const needsEffort = typeof parsed.model === "string" && OPENAI_TOOLS_NEED_NO_REASONING.test(parsed.model) && Array.isArray(parsed.tools) && parsed.tools.length > 0 && parsed.reasoning_effort === void 0;
+    return needsEffort ? JSON.stringify({ ...parsed, reasoning_effort: "none" }) : body;
   } catch {
     return body;
   }
 }
 function createDeepSpaceAI(env, provider, options = {}) {
   const transport = resolveApiTransport(env);
-  const authToken = options.authToken ?? env.APP_OWNER_JWT;
-  if (!authToken) {
-    throw new Error(
-      "createDeepSpaceAI: no auth token available. Either pass `options.authToken` explicitly (for user-initiated calls), or ensure `env.APP_OWNER_JWT` is set (injected at deploy time or by `deepspace dev start`)."
-    );
-  }
+  const authToken = resolveProxyAuthToken(env, options);
   const proxyFetch = (input, init) => {
     const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
     const headers = new Headers(init?.headers);
     headers.delete("authorization");
     headers.delete("x-api-key");
-    headers.set("X-Auth-Token", authToken);
-    const body = provider === "anthropic" ? withDefaultAnthropicMaxTokens(init?.body) : init?.body;
+    setProxyHeaders(headers, env, authToken, options.sandboxScope);
+    const body = provider === "openai" ? withOpenAIToolReasoningEffort(init?.body) : init?.body;
     if (body !== init?.body) {
       headers.delete("content-length");
     }
@@ -7707,8 +7771,13 @@ function createDeepSpaceAI(env, provider, options = {}) {
   };
   const baseURL = `https://api-worker.internal/api/proxy/${provider}/v1`;
   switch (provider) {
-    case "anthropic":
-      return createAnthropic({ baseURL, apiKey: "platform-managed", fetch: proxyFetch });
+    case "anthropic": {
+      const anthropic2 = createAnthropic({ baseURL, apiKey: "platform-managed", fetch: proxyFetch });
+      const defaults = defaultSettingsMiddleware({
+        settings: { maxOutputTokens: ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS }
+      });
+      return (modelId) => wrapLanguageModel({ model: anthropic2(modelId), middleware: defaults });
+    }
     case "openai": {
       const op = createOpenAI({ baseURL, apiKey: "platform-managed", fetch: proxyFetch });
       return op.chat;
@@ -7729,10 +7798,7 @@ function createDeepSpaceAI(env, provider, options = {}) {
 }
 
 // src/server/utils/agent.ts
-import {
-  stepCountIs,
-  streamText
-} from "ai";
+import { isStepCount, streamText } from "ai";
 var DeepSpaceAgentModelError = class extends Error {
   constructor(modelId, profile) {
     super(
@@ -7754,7 +7820,7 @@ var DeepSpaceAgentProfileError = class extends Error {
   code = "agent_profile_violation";
 };
 function streamDeepSpaceAgent(env, options) {
-  const { profile, modelId, authToken, ...streamOptions } = options;
+  const { profile, modelId, authToken, sandboxScope, ...streamOptions } = options;
   const selection = resolveDeepSpaceAgentModel(modelId, profile);
   if (!selection) throw new DeepSpaceAgentModelError(modelId, profile);
   if (selection.profile.allowedTools !== "application-defined") {
@@ -7765,14 +7831,17 @@ function streamDeepSpaceAgent(env, options) {
       }
     }
   }
-  const provider = createDeepSpaceAI(env, selection.provider, authToken ? { authToken } : {});
+  const provider = createDeepSpaceAI(env, selection.provider, {
+    ...authToken ? { authToken } : {},
+    ...sandboxScope ? { sandboxScope } : {}
+  });
   const { prepareStep, tools, ...remainingStreamOptions } = streamOptions;
   const boundedTools = limitToolExecutions(tools, selection.profile.maxToolCalls);
   const result = streamText({
     ...remainingStreamOptions,
     ...boundedTools ? { tools: boundedTools } : {},
     model: provider(selection.modelId),
-    stopWhen: stepCountIs(selection.profile.maxSteps),
+    stopWhen: isStepCount(selection.profile.maxSteps),
     prepareStep: enforceToolCallLimit(prepareStep, selection.profile.maxToolCalls),
     ...selection.provider === "openai" ? { providerOptions: { openai: { reasoningEffort: "none" } } } : {}
   });
@@ -7884,6 +7953,115 @@ function safeLogText(value) {
   ).trim().slice(0, 300);
 }
 
+// src/server/utils/sandbox.ts
+import { anthropic, forwardAnthropicContainerIdFromLastStep } from "@ai-sdk/anthropic";
+var FILES_PATH = "/api/proxy/anthropic/v1/files";
+var CODE_EXECUTION_CALLER = "code_execution_20260120";
+function codeExecutionTool() {
+  return anthropic.tools.codeExecution_20260120();
+}
+function callableFromSandbox(tool3) {
+  const anthropicOptions = tool3.providerOptions?.anthropic;
+  return {
+    ...tool3,
+    providerOptions: {
+      ...tool3.providerOptions,
+      anthropic: { ...anthropicOptions, allowedCallers: ["direct", CODE_EXECUTION_CALLER] }
+    }
+  };
+}
+var forwardSandboxContainer = forwardAnthropicContainerIdFromLastStep;
+function reuseSandbox(containerId) {
+  return containerId ? { anthropic: { container: { id: containerId } } } : void 0;
+}
+function sandboxUpload(file) {
+  return {
+    type: "file",
+    mediaType: file.mime_type,
+    filename: file.filename,
+    data: { type: "reference", reference: { anthropic: file.id } },
+    providerOptions: { anthropic: { containerUpload: true } }
+  };
+}
+function collectFileIds(value, out) {
+  if (Array.isArray(value)) {
+    for (const item of value) collectFileIds(item, out);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "file_id" && typeof child === "string" && child) out.add(child);
+    else collectFileIds(child, out);
+  }
+}
+function sandboxOutputs(steps) {
+  let containerId = null;
+  const fileIds = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    const container = step.providerMetadata?.anthropic?.container;
+    if (typeof container?.id === "string") containerId = container.id;
+    for (const part of step.content) {
+      const result = part;
+      if (result.type === "tool-result" && result.providerExecuted) collectFileIds(result.output, fileIds);
+    }
+  }
+  return { containerId, fileIds: [...fileIds] };
+}
+var SandboxFileError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "SandboxFileError";
+  }
+};
+function sandboxFiles(env, options = {}) {
+  const authToken = resolveProxyAuthToken(env, options);
+  async function send(path, init = {}) {
+    const headers = new Headers(init.headers);
+    setProxyHeaders(headers, env, authToken, options.scope);
+    const response = await apiWorkerFetch(env, `${FILES_PATH}${path}`, { ...init, headers });
+    if (!response.ok) {
+      const text = await response.text();
+      let message = text || response.statusText;
+      try {
+        const body = JSON.parse(text);
+        if (typeof body.error === "string") message = body.error;
+        else if (body.error && typeof body.error === "object") message = JSON.stringify(body.error);
+      } catch {
+      }
+      throw new SandboxFileError(response.status, `Sandbox file request failed (${response.status}): ${message}`);
+    }
+    return response;
+  }
+  const fileUrl = (fileId) => `/${encodeURIComponent(fileId)}`;
+  return {
+    async upload(file, { filename, expiresInSeconds } = {}) {
+      const name = filename ?? (file instanceof File ? file.name : void 0);
+      if (!name) throw new SandboxFileError(400, "sandboxFiles.upload: a Blob needs options.filename");
+      const form = new FormData();
+      form.set("file", file, name);
+      if (expiresInSeconds !== void 0) form.set("expires_in_seconds", String(expiresInSeconds));
+      return (await send("", { method: "POST", body: form })).json();
+    },
+    async get(fileId) {
+      return (await send(fileUrl(fileId))).json();
+    },
+    download(fileId) {
+      return send(`${fileUrl(fileId)}/content`);
+    },
+    async list({ limit, page } = {}) {
+      const query = new URLSearchParams();
+      if (limit !== void 0) query.set("limit", String(limit));
+      if (page !== void 0) query.set("page", page);
+      const suffix = query.size > 0 ? `?${query}` : "";
+      return (await send(suffix)).json();
+    },
+    async delete(fileId) {
+      await send(fileUrl(fileId), { method: "DELETE" });
+    }
+  };
+}
+
 // src/server/utils/composio-tools.ts
 import { tool, jsonSchema } from "ai";
 var EMPTY_SCHEMA = { type: "object", properties: {} };
@@ -7966,15 +8144,6 @@ async function composioTools(env, options) {
   return tools;
 }
 
-// src/server/utils/app-identity.ts
-function appendAppIdentity(headers, env) {
-  headers.delete("x-app-identity-token");
-  headers.delete("x-app-id");
-  if (!env.APP_IDENTITY_TOKEN) return;
-  headers.set("x-app-identity-token", env.APP_IDENTITY_TOKEN);
-  headers.set("x-app-id", env.DEEPSPACE_APP_ID);
-}
-
 // src/server/utils/screenshot.ts
 async function captureScreenshot(env, url) {
   const headers = new Headers({ "content-type": "application/json" });
@@ -8327,14 +8496,14 @@ function formatTranscript(messages) {
 }
 function makeDefaultSummarizer(env, options = {}) {
   return async (messages) => {
-    const anthropic = createDeepSpaceAI(env, "anthropic", { authToken: options.authToken });
+    const anthropic2 = createDeepSpaceAI(env, "anthropic", { authToken: options.authToken });
     const { text } = await generateText({
       // Stable alias — provider bug-fix snapshots roll forward without code change.
-      model: anthropic("claude-haiku-4-5"),
+      model: anthropic2("claude-haiku-4-5"),
       // 2500 gives the model room to finish a sentence after hitting the
       // "under 2000 tokens" soft limit in the prompt.
       maxOutputTokens: 2500,
-      system: SUMMARIZER_SYSTEM_PROMPT,
+      instructions: SUMMARIZER_SYSTEM_PROMPT,
       messages: [{ role: "user", content: formatTranscript(messages) }]
     });
     return text;
@@ -8822,6 +8991,9 @@ function splitStatements(sql) {
 // src/documentation/worker/routes.ts
 import { Hono } from "hono";
 
+// src/documentation/worker/assistant-routes.ts
+import { createUIMessageStreamResponse, toUIMessageStream } from "ai";
+
 // src/documentation/resource-path.ts
 function canonicalNativeDocumentationRequestPath(pathname) {
   try {
@@ -9420,7 +9592,7 @@ function registerDocumentationAssistantRoutes(app, resolveAuth, publicBasePath =
         profile: "documentation",
         modelId: selectedModel.modelId,
         ...authToken ? { authToken } : {},
-        system: buildDocumentationAssistantPrompt(manifest.name || c.env.APP_NAME, route),
+        instructions: buildDocumentationAssistantPrompt(manifest.name || c.env.APP_NAME, route),
         messages: [...history, { role: "user", content: question }],
         tools: buildDocumentationAssistantTools(corpus, publicBasePath),
         abortSignal: c.req.raw.signal,
@@ -9436,14 +9608,17 @@ function registerDocumentationAssistantRoutes(app, resolveAuth, publicBasePath =
       );
       return c.json({ error: "Documentation assistant is not configured" }, 503);
     }
-    return result.toUIMessageStreamResponse({
-      sendReasoning: false,
-      onError: (error) => {
-        console.error(
-          `[documentation-assistant] response error: ${deepSpaceAgentErrorSummary(error, diagnosticContext)}`
-        );
-        return "The documentation assistant could not complete this response.";
-      }
+    return createUIMessageStreamResponse({
+      stream: toUIMessageStream({
+        stream: result.stream,
+        sendReasoning: false,
+        onError: (error) => {
+          console.error(
+            `[documentation-assistant] response error: ${deepSpaceAgentErrorSummary(error, diagnosticContext)}`
+          );
+          return "The documentation assistant could not complete this response.";
+        }
+      })
     });
   });
 }
@@ -10258,6 +10433,7 @@ function isTestAccountTier(tier) {
 
 // src/server/auth/betterAuth.ts
 import { betterAuth } from "better-auth";
+import { getOAuthState } from "better-auth/api";
 import { organization, twoFactor } from "better-auth/plugins";
 import { SignJWT, importPKCS8 } from "jose";
 function createDeepSpaceAuth(config) {
@@ -10301,6 +10477,7 @@ function createDeepSpaceAuth(config) {
     emailAndPassword: {
       enabled: config.emailAndPassword ?? true
     },
+    ...config.userAdditionalFields ? { user: { additionalFields: config.userAdditionalFields } } : {},
     socialProviders,
     trustedOrigins: config.trustedOrigins ?? [
       "https://deep.space",
@@ -10336,29 +10513,45 @@ function createDeepSpaceAuth(config) {
     //     keys) — that case is caught by the runtime assertions in
     //     __tests__/betterAuth-hooks.test.ts, which read the wired hook back
     //     off auth.options. Don't rename the key without running them.
-    databaseHooks: buildDatabaseHooks(config.onUserCreated),
+    databaseHooks: buildDatabaseHooks(config.beforeUserCreate, config.onUserCreated),
     plugins: [organization(), twoFactor()]
   });
 }
-function buildDatabaseHooks(onUserCreated) {
-  if (!onUserCreated) return void 0;
+function buildDatabaseHooks(beforeUserCreate, onUserCreated) {
+  if (!beforeUserCreate && !onUserCreated) return void 0;
   return {
     user: {
       create: {
-        after: async (user, ctx) => {
-          try {
-            await onUserCreated(
-              { id: user.id, email: user.email, name: user.name },
-              // Forward BOTH request and standalone headers — some better-auth
-              // entry points populate ctx.headers without a request.
-              ctx ? { request: ctx.request, headers: ctx.headers ?? void 0 } : null
-            );
-          } catch (err) {
-            console.error(
-              `[deepspace] onUserCreated hook failed (signup unaffected): ${loggableError(err)}`
-            );
+        ...beforeUserCreate ? {
+          before: async (user, ctx) => beforeUserCreate(
+            user,
+            ctx ? {
+              request: ctx.request,
+              headers: ctx.headers ?? void 0,
+              path: ctx.path,
+              // Read from this package's Better Auth instance. In a
+              // pnpm graph the consuming worker can have another
+              // physical copy whose request-state singleton differs.
+              oauthState: await getOAuthState()
+            } : null
+          )
+        } : {},
+        ...onUserCreated ? {
+          after: async (user, ctx) => {
+            try {
+              await onUserCreated(
+                { id: user.id, email: user.email, name: user.name },
+                // Forward BOTH request and standalone headers — some better-auth
+                // entry points populate ctx.headers without a request.
+                ctx ? { request: ctx.request, headers: ctx.headers ?? void 0 } : null
+              );
+            } catch (err) {
+              console.error(
+                `[deepspace] onUserCreated hook failed (signup unaffected): ${loggableError(err)}`
+              );
+            }
           }
-        }
+        } : {}
       }
     }
   };
@@ -10592,7 +10785,8 @@ function registerAgentToolRoutes(app, options) {
       output = await tool3.execute(input, {
         toolCallId: crypto.randomUUID(),
         messages: [],
-        abortSignal: c.req.raw.signal
+        abortSignal: c.req.raw.signal,
+        context: void 0
       });
     } catch {
       return errorResponse(500, "tool_execution_failed");
@@ -10651,6 +10845,184 @@ function normalizeAgentTargetOrigin(value, policy) {
   return !label.includes(".") && validateAppName(label).valid ? url.origin : null;
 }
 
+// src/server/expo-auth.ts
+var CODE_CHALLENGE_RE = /^[A-Za-z0-9_-]{43}$/;
+var CODE_VERIFIER_RE = /^[A-Za-z0-9._~-]{43,128}$/;
+function allowedRedirect(value, options = {}) {
+  try {
+    new URL(value);
+    return options.allowedRedirectUris?.includes(value) ?? false;
+  } catch {
+    return false;
+  }
+}
+function validState(value) {
+  return value === null || value.length >= 1 && value.length <= 1024;
+}
+function validPkce(challenge, method, required = false) {
+  if (!challenge && !method) return !required;
+  return method === "S256" && !!challenge && CODE_CHALLENGE_RE.test(challenge);
+}
+function authWorkerUnavailable() {
+  return Response.json({ error: "The authentication service is not configured." }, { status: 503 });
+}
+function nativeAuthStart(request2, env, options) {
+  const url = new URL(request2.url);
+  const provider = url.searchParams.get("provider");
+  const redirectUri = url.searchParams.get("redirect_uri");
+  const state = url.searchParams.get("state");
+  const codeChallenge = url.searchParams.get("code_challenge");
+  const codeChallengeMethod = url.searchParams.get("code_challenge_method");
+  if (!provider || !redirectUri || !validState(state) || !allowedRedirect(redirectUri, options) || !validPkce(codeChallenge, codeChallengeMethod, true)) {
+    return Response.json({ error: "A supported provider, PKCE challenge, and registered redirect URI are required." }, { status: 400 });
+  }
+  if (!env.AUTH_WORKER_URL) return authWorkerUnavailable();
+  const callback = new URL("/api/auth/oauth-complete", url.origin);
+  callback.searchParams.set("redirect_uri", redirectUri);
+  if (state) callback.searchParams.set("state", state);
+  if (codeChallenge) {
+    callback.searchParams.set("code_challenge", codeChallenge);
+    callback.searchParams.set("code_challenge_method", "S256");
+  }
+  const authUrl = new URL("/login/social", env.AUTH_WORKER_URL);
+  authUrl.searchParams.set("provider", provider);
+  authUrl.searchParams.set("returnTo", callback.toString());
+  return Response.redirect(authUrl.toString(), 302);
+}
+function nativeAuthCallback(request2, _env, options) {
+  const url = new URL(request2.url);
+  const redirectUri = url.searchParams.get("redirect_uri");
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  const codeChallenge = url.searchParams.get("code_challenge");
+  const codeChallengeMethod = url.searchParams.get("code_challenge_method");
+  if (!redirectUri || !code || code.length > 4096 || !validState(state) || !validPkce(codeChallenge, codeChallengeMethod, true) || !allowedRedirect(redirectUri, options)) {
+    return Response.json({ error: "The sign-in callback was incomplete." }, { status: 400 });
+  }
+  const destination = new URL(redirectUri);
+  destination.searchParams.set("code", code);
+  if (state) destination.searchParams.set("state", state);
+  return Response.redirect(destination.toString(), 302);
+}
+async function nativeAuthExchange(request2, env) {
+  const body = await request2.json().catch(() => null);
+  if (!body || typeof body.code !== "string" || body.code.length < 8 || body.code.length > 4096 || typeof body.code_verifier !== "string" || !CODE_VERIFIER_RE.test(body.code_verifier)) {
+    return Response.json({ error: "A valid one-time sign-in code and PKCE verifier are required." }, { status: 400 });
+  }
+  let exchange2;
+  try {
+    exchange2 = await authWorkerFetch(env, "/api/auth/exchange-code", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code: body.code, code_verifier: body.code_verifier })
+    });
+  } catch {
+    return Response.json({ error: "The authentication service is unavailable." }, { status: 502 });
+  }
+  if (!exchange2.ok) {
+    const definitiveFailure = exchange2.status === 400 || exchange2.status === 401;
+    return Response.json(
+      { error: definitiveFailure ? "The sign-in code expired. Please try again." : "The authentication service is unavailable." },
+      { status: definitiveFailure ? 401 : 502 }
+    );
+  }
+  const exchanged = await exchange2.json().catch(() => null);
+  if (!exchanged || typeof exchanged.sessionToken !== "string") {
+    return Response.json({ error: "The auth service did not issue a session." }, { status: 502 });
+  }
+  let tokenResponse = null;
+  let token = null;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      tokenResponse = await authWorkerFetch(env, "/api/auth/token", {
+        method: "POST",
+        headers: { Cookie: `${SESSION_COOKIE}=${encodeURIComponent(exchanged.sessionToken)}` }
+      });
+    } catch {
+      tokenResponse = null;
+    }
+    if (tokenResponse?.ok) {
+      token = await tokenResponse.json().catch(() => null);
+      if (token && typeof token.token === "string") break;
+    }
+    if (tokenResponse?.status === 401) break;
+  }
+  if (!tokenResponse) {
+    return Response.json({ error: "The authentication service is unavailable." }, { status: 502 });
+  }
+  if (!tokenResponse.ok) {
+    return Response.json(
+      tokenResponse.status === 401 ? { error: "The sign-in session expired. Please try again." } : { error: "The authentication service is unavailable." },
+      { status: tokenResponse.status === 401 ? 401 : 502 }
+    );
+  }
+  if (!token || typeof token.token !== "string") {
+    return Response.json({ error: "The auth service did not issue an access token." }, { status: 502 });
+  }
+  return Response.json(
+    { sessionToken: exchanged.sessionToken, accessToken: token.token },
+    { headers: { "Cache-Control": "no-store" } }
+  );
+}
+async function nativeAuthToken(request2, env) {
+  const input = await request2.json().catch(() => null);
+  if (!input || typeof input.sessionToken !== "string" || input.sessionToken.length < 16 || input.sessionToken.length > 4096) {
+    return Response.json({ error: "A valid DeepSpace session is required." }, { status: 401 });
+  }
+  let response;
+  try {
+    response = await authWorkerFetch(env, "/api/auth/token", {
+      method: "POST",
+      headers: { Cookie: `${SESSION_COOKIE}=${encodeURIComponent(input.sessionToken)}` }
+    });
+  } catch {
+    return Response.json({ error: "The authentication service is unavailable." }, { status: 502 });
+  }
+  if (!response.ok) {
+    return Response.json(
+      { error: response.status === 401 ? "The DeepSpace session expired." : "The authentication service is unavailable." },
+      { status: response.status === 401 ? 401 : 502 }
+    );
+  }
+  const body = await response.json().catch(() => null);
+  if (!body || typeof body.token !== "string") {
+    return Response.json({ error: "The auth service did not issue an access token." }, { status: 502 });
+  }
+  return Response.json(
+    { accessToken: body.token },
+    { headers: { "Cache-Control": "no-store" } }
+  );
+}
+async function nativeAuthMe(request2, env) {
+  if (!env.AUTH_JWT_PUBLIC_KEY || !env.AUTH_JWT_ISSUER) {
+    return Response.json({ error: "JWT verification is not configured." }, { status: 500 });
+  }
+  const header = request2.headers.get("Authorization");
+  const token = header?.startsWith("Bearer ") ? header.slice(7) : null;
+  const verified = await verifyJwt(
+    { publicKey: env.AUTH_JWT_PUBLIC_KEY, issuer: env.AUTH_JWT_ISSUER },
+    token
+  );
+  if (!verified.result) return Response.json({ error: "Sign in required." }, { status: 401 });
+  return Response.json(
+    { userId: verified.result.userId, claims: verified.result.claims },
+    { headers: { "Cache-Control": "no-store" } }
+  );
+}
+async function nativeAuthSignOut(request2, env) {
+  const body = await request2.json().catch(() => null);
+  if (body && typeof body.sessionToken === "string" && body.sessionToken.length >= 16 && body.sessionToken.length <= 4096) {
+    try {
+      await authWorkerFetch(env, "/api/auth/sign-out", {
+        method: "POST",
+        headers: { Cookie: `${SESSION_COOKIE}=${encodeURIComponent(body.sessionToken)}` }
+      });
+    } catch {
+    }
+  }
+  return Response.json({ ok: true });
+}
+
 // src/shared/api-error.ts
 var SLUG_RE = /^[a-z0-9]+(?:[_.-][a-z0-9]+)*$/;
 var HUMAN_MESSAGES = {
@@ -10716,6 +11088,7 @@ export {
   AGENT_TOOL_RESPONSE_BODY_CAP,
   AI_CHATS_SCHEMA,
   AI_MESSAGES_SCHEMA,
+  AI_SDK_7_MIGRATION_ID,
   ALLOWED_BINDING_TYPES,
   ANONYMOUS_USER_ID_PREFIX,
   APP_ID_RE,
@@ -10785,6 +11158,8 @@ export {
   ROLE_DEFAULT,
   RecordRoom,
   RegistryClientError,
+  SANDBOX_SCOPES,
+  SANDBOX_SCOPE_HEADER,
   SDK_RUN_WORKER_FIRST,
   SECRET_NAME_RE,
   SECURE_ROOM_BOUNDARIES_MIGRATION_ID,
@@ -10794,6 +11169,7 @@ export {
   SYSTEM_COLLECTIONS,
   SYSTEM_MAINTAINED_COLUMNS,
   SYSTEM_MANAGED_COLUMNS,
+  SandboxFileError,
   SchemaRegistry,
   TEST_ACCOUNT_EMAIL_SUFFIX,
   UNDECLARED_ASSET_NOT_FOUND_HANDLING,
@@ -10814,6 +11190,7 @@ export {
   buildTableSelect,
   buildUiParts,
   callRegistry,
+  callableFromSandbox,
   canCreate,
   canDelete,
   canRead,
@@ -10823,6 +11200,7 @@ export {
   checkFieldPermissions,
   checkUnclaimedOwnerTransition,
   clientBuild,
+  codeExecutionTool,
   coerceValue,
   collectionTableName,
   columnId,
@@ -10850,6 +11228,7 @@ export {
   epochSeconds,
   folderFilter,
   formatBytes,
+  forwardSandboxContainer,
   getChat,
   getDeepSpaceAIModel,
   getMessageType,
@@ -10881,6 +11260,12 @@ export {
   meterVectorize,
   mintAppId,
   mintUlid,
+  nativeAuthCallback,
+  nativeAuthExchange,
+  nativeAuthMe,
+  nativeAuthSignOut,
+  nativeAuthStart,
+  nativeAuthToken,
   noopPermissionContext,
   normalizeAgentTargetOrigin,
   normalizeApiError,
@@ -10904,8 +11289,12 @@ export {
   resolveCompatibilityFlags,
   resolveDeepSpaceAgentModel,
   resolveSessionReadAuth,
+  reuseSandbox,
   rowToData,
   runMigrations,
+  sandboxFiles,
+  sandboxOutputs,
+  sandboxUpload,
   serverBuild,
   storageLimitForTier,
   storageQuotaMessage,