sparkecoder 0.1.44 → 0.1.46

package/dist/index.js

@@ -84,7 +84,7 @@ var init_types = __esm({
     }).optional();
     SparkcoderConfigSchema = z.object({
       // Default model to use (Vercel AI Gateway format)
-      defaultModel: z.string().default("anthropic/claude-opus-4-5"),
+      defaultModel: z.string().default("anthropic/claude-opus-4-6"),
       // Working directory for file operations
       workingDirectory: z.string().optional(),
       // Tool approval settings
@@ -486,12 +486,16 @@ function closeRemoteDatabase() {
   authKey = null;
 }
 var DATE_FIELDS = ["createdAt", "updatedAt", "startedAt", "completedAt", "stoppedAt", "finishedAt", "loadedAt", "indexedAt", "lastFullIndex", "lastIncrementalIndex"];
+var MODEL_MESSAGE_FIELDS = ["modelMessage", "modelMessages"];
 function parseDates(obj) {
   if (obj === null || obj === void 0) return obj;
   if (Array.isArray(obj)) return obj.map(parseDates);
-  if (typeof obj !== "object") return obj;
+  if (typeof obj !== "object" || obj instanceof Date) return obj;
   const result = { ...obj };
   for (const key of Object.keys(result)) {
+    if (MODEL_MESSAGE_FIELDS.includes(key)) {
+      continue;
+    }
     if (DATE_FIELDS.includes(key) && typeof result[key] === "string") {
       result[key] = new Date(result[key]);
     } else if (typeof result[key] === "object") {
@@ -524,7 +528,11 @@ async function api(path, options = {}) {
   if (!text || text === "null") {
     return null;
   }
-  return parseDates(JSON.parse(text));
+  const parsed = JSON.parse(text);
+  if (options.skipParseDates) {
+    return parsed;
+  }
+  return parseDates(parsed);
 }
 var remoteSessionQueries = {
   create(data) {
@@ -564,7 +572,7 @@ var remoteMessageQueries = {
     return api(`/messages/session/${sessionId}`);
   },
   getModelMessages(sessionId) {
-    return api(`/messages/session/${sessionId}/model-messages`);
+    return api(`/messages/session/${sessionId}/model-messages`, { skipParseDates: true });
   },
   async getRecentBySession(sessionId, limit = 50) {
     const messages = await api(`/messages/session/${sessionId}`);
@@ -4461,6 +4469,142 @@ ${conversationHistory}
 Summary:`;
 }
 
+// src/utils/sanitize-messages.ts
+import { modelMessageSchema } from "ai";
+function convertDatesToStrings(value) {
+  if (value === null || value === void 0) return value;
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) return value.map(convertDatesToStrings);
+  if (typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = convertDatesToStrings(v);
+    }
+    return result;
+  }
+  return value;
+}
+function sanitizeMessage(msg) {
+  if (msg === null || msg === void 0 || typeof msg !== "object") return msg;
+  const message = msg;
+  if (!message.role || typeof message.role !== "string") return msg;
+  return convertDatesToStrings(message);
+}
+function mergeUserContent(a, b) {
+  const aIsString = typeof a === "string";
+  const bIsString = typeof b === "string";
+  if (aIsString && bIsString) {
+    return `${a}
+
+${b}`;
+  }
+  const aParts = aIsString ? [{ type: "text", text: a }] : Array.isArray(a) ? a : [];
+  const bParts = bIsString ? [{ type: "text", text: b }] : Array.isArray(b) ? b : [];
+  return [...aParts, ...bParts];
+}
+function mergeConsecutiveSameRole(messages) {
+  if (messages.length <= 1) return messages;
+  const merged = [];
+  for (const msg of messages) {
+    const prev = merged[merged.length - 1];
+    if (!prev || prev.role !== msg.role) {
+      merged.push(msg);
+      continue;
+    }
+    const role = msg.role;
+    if (role === "user") {
+      const mergedContent = mergeUserContent(prev.content, msg.content);
+      merged[merged.length - 1] = { role: "user", content: mergedContent };
+      console.warn("[sanitize-messages] Merged consecutive user messages");
+    } else if (role === "assistant") {
+      const prevParts = typeof prev.content === "string" ? [{ type: "text", text: prev.content }] : Array.isArray(prev.content) ? prev.content : [];
+      const curParts = typeof msg.content === "string" ? [{ type: "text", text: msg.content }] : Array.isArray(msg.content) ? msg.content : [];
+      merged[merged.length - 1] = { role: "assistant", content: [...prevParts, ...curParts] };
+      console.warn("[sanitize-messages] Merged consecutive assistant messages");
+    } else if (role === "tool") {
+      const prevContent = Array.isArray(prev.content) ? prev.content : [];
+      const curContent = Array.isArray(msg.content) ? msg.content : [];
+      merged[merged.length - 1] = { role: "tool", content: [...prevContent, ...curContent] };
+      console.warn("[sanitize-messages] Merged consecutive tool messages");
+    } else {
+      merged.push(msg);
+    }
+  }
+  return merged;
+}
+function sanitizeModelMessages(messages) {
+  let allValid = true;
+  for (const msg of messages) {
+    try {
+      modelMessageSchema.parse(msg);
+    } catch {
+      allValid = false;
+      break;
+    }
+  }
+  let result;
+  if (allValid) {
+    result = messages;
+  } else {
+    console.warn("[sanitize-messages] Detected invalid messages, attempting self-repair...");
+    const sanitized = [];
+    let repairCount = 0;
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      try {
+        modelMessageSchema.parse(msg);
+        sanitized.push(msg);
+        continue;
+      } catch {
+      }
+      const fixed = sanitizeMessage(msg);
+      try {
+        modelMessageSchema.parse(fixed);
+        sanitized.push(fixed);
+        repairCount++;
+        console.warn(`[sanitize-messages] Repaired message ${i} (role=${msg.role}) - converted Date objects to strings`);
+        continue;
+      } catch {
+      }
+      if (msg.role === "tool" && Array.isArray(msg.content)) {
+        const fixedContent = msg.content.map((part) => {
+          if (part.type === "tool-result" && part.output !== void 0) {
+            const output = convertDatesToStrings(part.output);
+            if (output && typeof output === "object" && !output.type) {
+              return { ...part, output: { type: "json", value: output } };
+            }
+            const knownTypes = ["text", "json", "execution-denied", "error-text", "error-json", "content"];
+            if (output && typeof output === "object" && !knownTypes.includes(output.type)) {
+              return { ...part, output: { type: "json", value: output } };
+            }
+            return { ...part, output };
+          }
+          return convertDatesToStrings(part);
+        });
+        const wrappedMsg = { ...msg, content: fixedContent };
+        try {
+          modelMessageSchema.parse(wrappedMsg);
+          sanitized.push(wrappedMsg);
+          repairCount++;
+          console.warn(`[sanitize-messages] Repaired message ${i} (role=tool) - wrapped raw output in json type`);
+          continue;
+        } catch {
+        }
+      }
+      console.error(
+        `[sanitize-messages] Could not repair message ${i} (role=${msg.role}). Message will be included as-is. Content keys: ${JSON.stringify(Object.keys(msg))}`
+      );
+      sanitized.push(msg);
+    }
+    if (repairCount > 0) {
+      console.warn(`[sanitize-messages] Self-repair complete: fixed ${repairCount}/${messages.length} messages`);
+    }
+    result = sanitized;
+  }
+  result = mergeConsecutiveSameRole(result);
+  return result;
+}
+
 // src/agent/context.ts
 var ContextManager = class {
   sessionId;
@@ -4477,9 +4621,14 @@ var ContextManager = class {
   /**
    * Get messages for the current context
    * Returns ModelMessage[] that can be passed directly to streamText/generateText
+   * 
+   * Includes self-repair: if messages from the database have been corrupted
+   * (e.g., Date objects in tool outputs from parseDates), they are automatically
+   * sanitized to conform to the AI SDK's ModelMessage schema.
    */
   async getMessages() {
     let modelMessages = await messageQueries.getModelMessages(this.sessionId);
+    modelMessages = sanitizeModelMessages(modelMessages);
     const contextSize = calculateContextSize(modelMessages);
     if (this.autoSummarize && contextSize > this.maxContextChars) {
       modelMessages = await this.summarizeContext(modelMessages);
@@ -4926,9 +5075,28 @@ import { existsSync as existsSync12, mkdirSync as mkdirSync3, writeFileSync as w
 import { readdir as readdir4 } from "fs/promises";
 import { join as join6, basename as basename3, extname as extname7, relative as relative8 } from "path";
 import { nanoid as nanoid4 } from "nanoid";
+
+// src/server/devtools-store.ts
+var devtoolsContextStore = /* @__PURE__ */ new Map();
+function setDevtoolsContext(sessionId, context) {
+  devtoolsContextStore.set(sessionId, context);
+}
+function getDevtoolsContext(sessionId) {
+  cleanupStaleContexts();
+  return devtoolsContextStore.get(sessionId) || null;
+}
+function cleanupStaleContexts() {
+  const now = Date.now();
+  for (const [sessionId, ctx] of devtoolsContextStore) {
+    if (now - ctx.lastHeartbeat.getTime() > 30 * 1e3) {
+      devtoolsContextStore.delete(sessionId);
+    }
+  }
+}
+
+// src/server/routes/sessions.ts
 var sessions = new Hono();
 var pendingInputStore = /* @__PURE__ */ new Map();
-var devtoolsContextStore = /* @__PURE__ */ new Map();
 function cleanupPendingInputs() {
   const now = Date.now();
   for (const [sessionId, entry] of pendingInputStore) {
@@ -4937,14 +5105,6 @@ function cleanupPendingInputs() {
     }
   }
 }
-function cleanupDevtoolsContexts() {
-  const now = Date.now();
-  for (const [sessionId, ctx] of devtoolsContextStore) {
-    if (now - ctx.lastHeartbeat.getTime() > 30 * 1e3) {
-      devtoolsContextStore.delete(sessionId);
-    }
-  }
-}
 var createSessionSchema = z12.object({
   name: z12.string().optional(),
   workingDirectory: z12.string().optional(),
@@ -5203,7 +5363,10 @@ sessions.get("/:id/pending-input", async (c) => {
 var devtoolsContextSchema = z12.object({
   url: z12.string(),
   path: z12.string(),
-  pageName: z12.string().optional()
+  pageName: z12.string().optional(),
+  screenWidth: z12.number().optional(),
+  screenHeight: z12.number().optional(),
+  devicePixelRatio: z12.number().optional()
 });
 sessions.post(
   "/:id/devtools-context",
@@ -5211,20 +5374,21 @@ sessions.post(
   async (c) => {
     const id = c.req.param("id");
     const body = c.req.valid("json");
-    devtoolsContextStore.set(id, {
+    setDevtoolsContext(id, {
       url: body.url,
       path: body.path,
       pageName: body.pageName || body.path,
+      screenWidth: body.screenWidth,
+      screenHeight: body.screenHeight,
+      devicePixelRatio: body.devicePixelRatio,
       lastHeartbeat: /* @__PURE__ */ new Date()
     });
-    cleanupDevtoolsContexts();
     return c.json({ success: true, sessionId: id });
   }
 );
 sessions.get("/:id/devtools-context", async (c) => {
   const id = c.req.param("id");
-  cleanupDevtoolsContexts();
-  const ctx = devtoolsContextStore.get(id);
+  const ctx = getDevtoolsContext(id);
   if (!ctx) {
     return c.json({ connected: false, context: null });
   }
@@ -5234,6 +5398,9 @@ sessions.get("/:id/devtools-context", async (c) => {
       url: ctx.url,
       path: ctx.path,
       pageName: ctx.pageName,
+      screenWidth: ctx.screenWidth,
+      screenHeight: ctx.screenHeight,
+      devicePixelRatio: ctx.devicePixelRatio,
       lastHeartbeat: ctx.lastHeartbeat.toISOString()
     }
   });
@@ -5814,6 +5981,25 @@ async function emitSyntheticToolStreaming(writeSSE, toolCallStarts, toolCallId,
     await new Promise((resolve10) => setTimeout(resolve10, 0));
   }
 }
+function buildDevtoolsContextXml(sessionId) {
+  const ctx = getDevtoolsContext(sessionId);
+  if (!ctx) return "";
+  const parts = [];
+  parts.push(`<devtools-context>`);
+  parts.push(`  <page url="${ctx.url}" path="${ctx.path}" name="${ctx.pageName}" />`);
+  if (ctx.screenWidth && ctx.screenHeight) {
+    parts.push(`  <viewport width="${ctx.screenWidth}" height="${ctx.screenHeight}"${ctx.devicePixelRatio ? ` dpr="${ctx.devicePixelRatio}"` : ""} />`);
+  }
+  parts.push(`</devtools-context>`);
+  return parts.join("\n");
+}
+function enrichPromptWithDevtoolsContext(sessionId, prompt) {
+  const xml = buildDevtoolsContextXml(sessionId);
+  if (!xml) return prompt;
+  return `${xml}
+
+${prompt}`;
+}
 var agents = new Hono2();
 var attachmentSchema = z13.object({
   type: z13.enum(["image", "file"]),
@@ -6149,7 +6335,8 @@ agents.post(
   zValidator2("json", runPromptSchema),
   async (c) => {
     const id = c.req.param("id");
-    const { prompt, attachments } = c.req.valid("json");
+    const { prompt: rawPrompt, attachments } = c.req.valid("json");
+    const prompt = enrichPromptWithDevtoolsContext(id, rawPrompt);
     const session = await sessionQueries.getById(id);
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
@@ -6294,7 +6481,8 @@ agents.post(
   zValidator2("json", runPromptSchema),
   async (c) => {
     const id = c.req.param("id");
-    const { prompt } = c.req.valid("json");
+    const { prompt: rawPrompt } = c.req.valid("json");
+    const prompt = enrichPromptWithDevtoolsContext(id, rawPrompt);
     const session = await sessionQueries.getById(id);
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
@@ -6409,6 +6597,7 @@ agents.post(
       sessionConfig: body.toolApprovals ? { toolApprovals: body.toolApprovals } : void 0
     });
     const session = agent.getSession();
+    const enrichedPrompt = enrichPromptWithDevtoolsContext(session.id, body.prompt);
     const streamId = `stream_${session.id}_${nanoid5(10)}`;
     await createCheckpoint(session.id, session.workingDirectory, 0);
     await activeStreamQueries.create(session.id, streamId);
@@ -6458,7 +6647,7 @@ agents.post(
           let textId = `text_${Date.now()}`;
           let textStarted = false;
           const result = await agent.stream({
-            prompt: body.prompt,
+            prompt: enrichedPrompt,
             abortSignal: abortController.signal,
             // Use our managed abort controller, NOT client signal
             onToolProgress: async (progress) => {