sparkecoder 0.1.45 → 0.1.46

package/README.md

@@ -139,7 +139,7 @@ Create a `sparkecoder.config.json` file:
 
 | Option | Description | Default |
 |--------|-------------|---------|
-| `defaultModel` | Vercel AI Gateway model string | `anthropic/claude-opus-4-5` |
+| `defaultModel` | Vercel AI Gateway model string | `anthropic/claude-opus-4-6` |
 | `workingDirectory` | Base directory for file operations | Current directory |
 | `toolApprovals` | Which tools require user approval | `{ bash: true }` |
 | `skills.directory` | Directory containing skill files | `./skills` |

package/dist/agent/index.d.ts

@@ -1,5 +1,5 @@
 import 'ai';
 import '../schema-NcQknWCg.js';
-export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, C as ContextManager, M as MessageAttachment, d as buildSystemPrompt } from '../index-D2eLXP9V.js';
-import '../search-D3Wtf7TJ.js';
+export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, C as ContextManager, M as MessageAttachment, d as buildSystemPrompt } from '../index-DJ5qNs1Z.js';
+import '../search-BOYIUmDp.js';
 import 'zod';

package/dist/agent/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
@@ -478,12 +478,16 @@ import { nanoid as nanoid3 } from "nanoid";
 var remoteServerUrl = null;
 var 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") {
@@ -516,7 +520,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) {
@@ -556,7 +564,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}`);
@@ -3870,6 +3878,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;
@@ -3886,9 +4030,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);