deepspace 0.2.4 → 0.2.6

package/dist/worker.js

@@ -4130,6 +4130,40 @@ var DEFAULT_DO_MANIFEST = [
   { binding: "YJS_ROOMS", className: "AppYjsRoom", sqlite: true }
 ];
 
+// src/server/schemas/ai-chat.ts
+var AI_CHATS_SCHEMA = {
+  name: "ai-chats",
+  columns: [
+    { name: "userId", storage: "text", interpretation: "plain", userBound: true, immutable: true, required: true },
+    { name: "title", storage: "text", interpretation: "plain" },
+    { name: "model", storage: "text", interpretation: "plain" },
+    { name: "compactedSummary", storage: "text", interpretation: "plain" },
+    { name: "compactedThroughId", storage: "text", interpretation: "plain" }
+  ],
+  ownerField: "userId",
+  permissions: {
+    admin: { read: true, create: true, update: true, delete: true },
+    member: { read: "own", create: false, update: "own", delete: "own" },
+    viewer: { read: "own", create: false, update: false, delete: false }
+  }
+};
+var AI_MESSAGES_SCHEMA = {
+  name: "ai-messages",
+  columns: [
+    { name: "chatId", storage: "text", interpretation: "plain", immutable: true, required: true },
+    { name: "userId", storage: "text", interpretation: "plain", userBound: true, immutable: true, required: true },
+    { name: "role", storage: "text", interpretation: "plain", required: true },
+    { name: "content", storage: "text", interpretation: "plain" },
+    { name: "parts", storage: "text", interpretation: { kind: "json" } }
+  ],
+  ownerField: "userId",
+  permissions: {
+    admin: { read: true, create: true, update: true, delete: true },
+    member: { read: "own", create: false, update: "own", delete: "own" },
+    viewer: { read: "own", create: false, update: false, delete: false }
+  }
+};
+
 // src/server/schemas/messaging.ts
 var CHANNELS_SCHEMA = {
   name: "channels",
@@ -5073,7 +5107,7 @@ function buildCronContext(env, ownerUserId, roomId = "default") {
   const apiBase = env.API_BASE_URL || "https://api.deep.space";
   const roomIdObj = env.RECORD_ROOMS.idFromName(roomId);
   const room = env.RECORD_ROOMS.get(roomIdObj);
-  async function executeTool2(tool, params) {
+  async function executeTool3(tool, params) {
     const response = await room.fetch(new Request("https://internal/api/tools/execute", {
       method: "POST",
       headers: {
@@ -5094,17 +5128,17 @@ function buildCronContext(env, ownerUserId, roomId = "default") {
       const params = { collection };
       if (opts?.where) params.where = opts.where;
       if (opts?.limit) params.limit = opts.limit;
-      const data = await executeTool2("records.query", params);
+      const data = await executeTool3("records.query", params);
       return data.records || [];
     },
     async create(collection, data) {
-      return executeTool2("records.create", { collection, data });
+      return executeTool3("records.create", { collection, data });
     },
     async update(collection, recordId, data) {
-      return executeTool2("records.update", { collection, recordId, data });
+      return executeTool3("records.update", { collection, recordId, data });
     },
     async delete(collection, recordId) {
-      return executeTool2("records.delete", { collection, recordId });
+      return executeTool3("records.delete", { collection, recordId });
     }
   };
   const integrations = {
@@ -5221,6 +5255,21 @@ function authWorkerFetch(env, path, init) {
 }
 
 // src/server/utils/ai.ts
+var ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS = 4096;
+function withDefaultAnthropicMaxTokens(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
+    });
+  } catch {
+    return body;
+  }
+}
 function createDeepSpaceAI(env, provider, options = {}) {
   const transport = resolveApiTransport(env);
   const authToken = options.authToken ?? env.APP_OWNER_JWT;
@@ -5235,24 +5284,26 @@ function createDeepSpaceAI(env, provider, options = {}) {
     headers.delete("authorization");
     headers.delete("x-api-key");
     headers.set("X-Auth-Token", authToken);
+    const body = provider === "anthropic" ? withDefaultAnthropicMaxTokens(init?.body) : init?.body;
+    if (body !== init?.body) {
+      headers.delete("content-length");
+    }
+    const nextInit = { ...init, headers, body };
     if (transport.kind === "binding") {
-      return transport.fetcher.fetch(url, { ...init, headers });
+      return transport.fetcher.fetch(url, nextInit);
     }
     const original = new URL(url);
     const rewritten = `${transport.baseUrl}${original.pathname}${original.search}`;
-    return fetch(rewritten, { ...init, headers });
+    return fetch(rewritten, nextInit);
   };
   const baseURL = `https://api-worker.internal/api/proxy/${provider}/v1`;
   switch (provider) {
     case "anthropic":
       return createAnthropic({ baseURL, apiKey: "platform-managed", fetch: proxyFetch });
-    case "openai":
-      return createOpenAI({
-        baseURL,
-        apiKey: "platform-managed",
-        fetch: proxyFetch,
-        compatibility: "strict"
-      });
+    case "openai": {
+      const op = createOpenAI({ baseURL, apiKey: "platform-managed", fetch: proxyFetch });
+      return op.chat;
+    }
     case "cerebras":
       return createOpenAICompatible({
         name: "cerebras",
@@ -5267,7 +5318,407 @@ function createDeepSpaceAI(env, provider, options = {}) {
     }
   }
 }
+
+// src/server/utils/chat-context.ts
+import { generateText } from "ai";
+var DEFAULT_CONTEXT_CONFIG = {
+  contextBudget: 24e4,
+  toolResultCap: 3e4,
+  keepRecentToolResults: 5,
+  minKept: 10
+};
+function sizeOf(m) {
+  return (m.content ?? "").length + (m.parts ? JSON.stringify(m.parts).length : 0);
+}
+function totalChars(messages) {
+  return messages.reduce((acc, m) => acc + sizeOf(m), 0);
+}
+function truncateOldToolResults(messages, keepRecent) {
+  const assistantIdxs = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === "assistant") assistantIdxs.push(i);
+  }
+  const protectedStart = assistantIdxs.length > keepRecent ? assistantIdxs[assistantIdxs.length - keepRecent] : 0;
+  return messages.map((msg, idx) => {
+    if (msg.role !== "assistant" || idx >= protectedStart) return msg;
+    if (!Array.isArray(msg.parts) || msg.parts.length === 0) return msg;
+    const newParts = msg.parts.map((p) => {
+      if (!p || typeof p !== "object") return p;
+      const anyP = p;
+      if (anyP.type !== "tool-invocation") return p;
+      const inv = anyP.toolInvocation;
+      if (!inv || inv.state !== "result") return p;
+      const result = inv.result;
+      if (result && result.success === false) return p;
+      return {
+        ...anyP,
+        toolInvocation: {
+          ...inv,
+          result: {
+            _truncated: true,
+            note: "Result from an earlier turn omitted to save context. Call this tool again if you need the data."
+          }
+        }
+      };
+    });
+    return { ...msg, parts: newParts };
+  });
+}
+function applySlidingWindow(messages, charCap, minKept) {
+  let total = totalChars(messages);
+  if (total <= charCap) return messages;
+  const out = [...messages];
+  while (out.length > minKept && total > charCap) {
+    const idx = out.findIndex((m) => m.role !== "system");
+    if (idx < 0) break;
+    const dropped = out.splice(idx, 1)[0];
+    total -= sizeOf(dropped);
+  }
+  return out;
+}
+function capToolResultSize(result, byteCap) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(result);
+  } catch {
+    return { success: false, error: "Tool result could not be serialized." };
+  }
+  if (typeof serialized !== "string") return result;
+  if (serialized.length <= byteCap) return result;
+  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).`,
+    preview: serialized.slice(0, 2e3)
+  };
+}
+function turnsToCoreMessages(turns) {
+  const out = [];
+  for (const t of turns) {
+    if (t.role === "system") {
+      out.push({ role: "system", content: t.content });
+      continue;
+    }
+    if (t.role === "user") {
+      out.push({ role: "user", content: t.content });
+      continue;
+    }
+    if (!Array.isArray(t.parts) || t.parts.length === 0) {
+      if (t.content) out.push({ role: "assistant", content: t.content });
+      continue;
+    }
+    let pending = [];
+    let emittedAny = false;
+    const flushAssistant = () => {
+      if (pending.length === 0) return;
+      out.push({ role: "assistant", content: pending });
+      pending = [];
+      emittedAny = true;
+    };
+    for (const p of t.parts) {
+      if (!p || typeof p !== "object") continue;
+      const anyP = p;
+      if (anyP.type === "text" && typeof anyP.text === "string" && anyP.text) {
+        pending.push({ type: "text", text: anyP.text });
+        continue;
+      }
+      if (anyP.type !== "tool-invocation") continue;
+      const inv = anyP.toolInvocation;
+      const toolCallId = typeof anyP.toolCallId === "string" ? anyP.toolCallId : void 0;
+      const toolName = typeof inv?.toolName === "string" ? inv.toolName : void 0;
+      if (!toolCallId || !toolName) continue;
+      if (inv?.state !== "result") continue;
+      pending.push({ type: "tool-call", toolCallId, toolName, input: inv?.args });
+      flushAssistant();
+      const tr = {
+        type: "tool-result",
+        toolCallId,
+        toolName,
+        output: { type: "json", value: inv.result }
+      };
+      out.push({ role: "tool", content: [tr] });
+    }
+    flushAssistant();
+    if (!emittedAny && t.content) {
+      out.push({ role: "assistant", content: t.content });
+    }
+  }
+  return out;
+}
+function buildUiParts(responseMessages) {
+  const toolResults = /* @__PURE__ */ new Map();
+  for (const msg of responseMessages) {
+    if (msg.role !== "tool" || !Array.isArray(msg.content)) continue;
+    for (const c of msg.content) {
+      if (c.type === "tool-result") {
+        toolResults.set(c.toolCallId, unwrapToolOutput(c.output));
+      }
+    }
+  }
+  const parts = [];
+  for (const msg of responseMessages) {
+    if (msg.role !== "assistant") continue;
+    if (typeof msg.content === "string") {
+      if (msg.content) parts.push({ type: "text", text: msg.content });
+      continue;
+    }
+    if (!Array.isArray(msg.content)) continue;
+    for (const c of msg.content) {
+      if (c.type === "text" && typeof c.text === "string" && c.text) {
+        parts.push({ type: "text", text: c.text });
+      } else if (c.type === "tool-call") {
+        const result = toolResults.get(c.toolCallId);
+        if (result === void 0) {
+          continue;
+        }
+        parts.push({
+          type: "tool-invocation",
+          toolCallId: c.toolCallId,
+          toolInvocation: {
+            toolName: c.toolName,
+            state: "result",
+            args: c.input,
+            result
+          }
+        });
+      }
+    }
+  }
+  return parts;
+}
+function unwrapToolOutput(output) {
+  if (!output || typeof output !== "object") return output;
+  const o = output;
+  const tag = typeof o.type === "string" ? o.type : null;
+  if (tag === "json" || tag === "text") {
+    return "value" in o ? o.value : output;
+  }
+  if (tag === "error-text" || tag === "error-json") {
+    return { success: false, error: "value" in o ? o.value : "Tool execution failed" };
+  }
+  return output;
+}
+function buildSummaryMessage(text, throughId) {
+  return {
+    id: `summary-${throughId}`,
+    role: "system",
+    content: `Earlier conversation summary:
+${text}`
+  };
+}
+async function prepareMessagesWithCompaction(messages, config, options) {
+  const truncated = truncateOldToolResults(messages, config.keepRecentToolResults);
+  let working = truncated;
+  if (options.cachedSummary) {
+    const idx = truncated.findIndex((m) => m.id === options.cachedSummary.throughId);
+    if (idx >= 0) {
+      working = [
+        buildSummaryMessage(options.cachedSummary.text, options.cachedSummary.throughId),
+        ...truncated.slice(idx + 1)
+      ];
+    }
+  }
+  if (totalChars(working) <= config.contextBudget) {
+    return { messages: working };
+  }
+  const half = Math.max(1, Math.floor(working.length / 2));
+  const older = working.slice(0, half);
+  const newer = working.slice(half);
+  let throughId;
+  for (let i = older.length - 1; i >= 0; i--) {
+    const id = older[i].id;
+    if (id && !id.startsWith("summary-")) {
+      throughId = id;
+      break;
+    }
+  }
+  if (throughId) {
+    try {
+      const text = await options.summarizer(older);
+      return {
+        messages: [buildSummaryMessage(text, throughId), ...newer],
+        newSummary: { text, throughId }
+      };
+    } catch (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");
+  }
+  return {
+    messages: applySlidingWindow(working, config.contextBudget, config.minKept)
+  };
+}
+var SUMMARIZER_SYSTEM_PROMPT = `You are compressing a conversation between a user and an AI assistant into a
+concise memory summary. The summary will replace the original messages in the
+conversation history; the assistant will read it on subsequent turns to
+maintain continuity.
+
+Preserve in the summary:
+- User preferences and constraints the user stated (coding style, tone,
+  skill level, goals).
+- Decisions made and rejected alternatives ("we chose X over Y because Z").
+- Current task state (what's in progress, what's been completed).
+- Any facts the user might reasonably reference later.
+
+If the messages below contain a prior summary, incorporate its content into
+your new summary \u2014 do not drop information from earlier summaries.
+
+Keep the summary under 2000 tokens. Write as a factual note to future-you,
+not as a narrative. Use terse bullet points where possible.`;
+function formatTranscript(messages) {
+  return messages.map((m) => {
+    const label = m.role === "user" ? "User" : m.role === "assistant" ? "Assistant" : "System";
+    const tools = Array.isArray(m.parts) ? m.parts.filter((p) => p?.type === "tool-invocation").map((p) => {
+      const name = p.toolInvocation?.toolName;
+      return `  [tool: ${name ?? "unknown"}]`;
+    }).join("\n") : "";
+    return `${label}: ${m.content}${tools ? "\n" + tools : ""}`;
+  }).join("\n\n");
+}
+function makeDefaultSummarizer(env, options = {}) {
+  return async (messages) => {
+    const anthropic = 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"),
+      // 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,
+      messages: [{ role: "user", content: formatTranscript(messages) }]
+    });
+    return text;
+  };
+}
+
+// src/server/utils/chat-history.ts
+async function executeTool2(stub, userId, tool, params) {
+  const res = await stub.fetch(new Request("https://internal/api/tools/execute", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-User-Id": userId,
+      "X-App-Action": "true"
+    },
+    body: JSON.stringify({ tool, params })
+  }));
+  const body = await res.json();
+  if (!body.success) {
+    throw new Error(`chat-history ${tool} failed: ${body.error ?? "unknown error"}`);
+  }
+  return body.data;
+}
+function toChatRow(env) {
+  return {
+    id: env.recordId,
+    userId: env.data.userId,
+    title: env.data.title ?? "",
+    model: env.data.model,
+    compactedSummary: env.data.compactedSummary,
+    compactedThroughId: env.data.compactedThroughId,
+    createdAt: env.createdAt,
+    updatedAt: env.updatedAt
+  };
+}
+function toMessageRow(env) {
+  return {
+    id: env.recordId,
+    chatId: env.data.chatId,
+    userId: env.data.userId,
+    role: env.data.role,
+    content: env.data.content ?? "",
+    parts: env.data.parts,
+    createdAt: env.createdAt
+  };
+}
+async function getChat(stub, chatId, userId) {
+  try {
+    const result = await executeTool2(stub, userId, "records.get", {
+      collection: "ai-chats",
+      recordId: chatId
+    });
+    return result.record ? toChatRow(result.record) : null;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Record not found")) return null;
+    throw err;
+  }
+}
+async function createChat(stub, userId, opts = {}) {
+  const data = { userId };
+  if (opts.title !== void 0) data.title = opts.title;
+  if (opts.model !== void 0) data.model = opts.model;
+  const result = await executeTool2(stub, userId, "records.create", {
+    collection: "ai-chats",
+    data
+  });
+  return toChatRow(result.record);
+}
+async function updateChat(stub, chatId, userId, patch) {
+  await executeTool2(stub, userId, "records.update", {
+    collection: "ai-chats",
+    recordId: chatId,
+    data: patch
+  });
+}
+async function deleteChatCascade(stub, chatId, userId) {
+  const list = await executeTool2(stub, userId, "records.query", {
+    collection: "ai-messages",
+    where: { chatId }
+  });
+  const errors = [];
+  for (const env of list.records) {
+    try {
+      await executeTool2(stub, userId, "records.delete", {
+        collection: "ai-messages",
+        recordId: env.recordId
+      });
+    } catch (err) {
+      errors.push(err);
+    }
+  }
+  try {
+    await executeTool2(stub, userId, "records.delete", {
+      collection: "ai-chats",
+      recordId: chatId
+    });
+  } catch (err) {
+    errors.push(err);
+  }
+  if (errors.length > 0) {
+    const first = errors[0];
+    throw new Error(
+      `deleteChatCascade: ${errors.length} delete(s) failed; first: ${first instanceof Error ? first.message : String(first)}`,
+      { cause: errors }
+    );
+  }
+}
+async function loadMessages(stub, chatId, userId) {
+  const result = await executeTool2(stub, userId, "records.query", {
+    collection: "ai-messages",
+    where: { chatId, userId },
+    orderBy: "createdAt",
+    orderDir: "asc"
+  });
+  return result.records.map(toMessageRow);
+}
+async function appendMessage(stub, msg) {
+  const data = {
+    chatId: msg.chatId,
+    userId: msg.userId,
+    role: msg.role,
+    content: msg.content
+  };
+  if (msg.parts !== void 0) data.parts = msg.parts;
+  await executeTool2(stub, msg.userId, "records.create", {
+    collection: "ai-messages",
+    recordId: msg.id,
+    data
+  });
+}
 export {
+  AI_CHATS_SCHEMA,
+  AI_MESSAGES_SCHEMA,
   Awareness,
   BASE_USERS_SCHEMA,
   BUILT_IN_TOOLS,
@@ -5278,6 +5729,7 @@ export {
   CONVERSATION_SCHEMAS,
   CanvasRoom,
   CronRoom,
+  DEFAULT_CONTEXT_CONFIG,
   DEFAULT_DO_MANIFEST,
   DEFAULT_MAX_SKEW_MS,
   DIRECTORY_SCHEMAS,
@@ -5310,20 +5762,25 @@ export {
   YjsRoom,
   analyzePermissions,
   apiWorkerFetch,
+  appendMessage,
+  applySlidingWindow,
   authWorkerFetch,
   buildCronContext,
   buildInternalPayload,
   buildTableSelect,
+  buildUiParts,
   canCreate,
   canDelete,
   canRead,
   canUpdate,
+  capToolResultSize,
   checkFieldPermissions,
   clientBuild,
   coerceValue,
   collectionTableName,
   columnId,
   computeHmacHex,
+  createChat,
   createDecoder,
   createDeepSpaceAI,
   createDeepSpaceAuth,
@@ -5331,12 +5788,14 @@ export {
   createScopedR2Handler,
   dataToColumnValues,
   decodeJwtPayload,
+  deleteChatCascade,
   dispatch,
   encode,
   encodeAwarenessMessage,
   encodeSyncStep1,
   encodeSyncStep2,
   encodeUpdate,
+  getChat,
   getGlobalDOSchemas,
   getGlobalDOType,
   getMessageType,
@@ -5345,8 +5804,11 @@ export {
   handleSyncMessage,
   hasContent,
   isOwner,
+  loadMessages,
+  makeDefaultSummarizer,
   noopPermissionContext,
   platformWorkerFetch,
+  prepareMessagesWithCompaction,
   readVarUint,
   readVarUint8Array,
   resolveColumn,
@@ -5355,6 +5817,11 @@ export {
   signInternalPayload,
   timingSafeEqualHex,
   toUint8Array,
+  totalChars,
+  truncateOldToolResults,
+  turnsToCoreMessages,
+  unwrapToolOutput,
+  updateChat,
   verifyInternalSignature,
   verifyJwt,
   workspaceAccountsSchema,