dexto 1.1.2 → 1.1.3

package/dist/src/core/{chunk-2O5JENNA.js → chunk-XABD32T2.js}

@@ -2074,10 +2074,19 @@ ${source_default.white(JSON.stringify(args, null, 2))}`,
       borderColor = "red";
       title = "\u274C Tool Error";
     } else if (typeof result === "string") {
-      displayText = result;
+      if (result.length > 1e3) {
+        displayText = `${result.slice(0, 500)}... [${result.length - 500} chars omitted]`;
+      } else {
+        displayText = result;
+      }
     } else {
       try {
-        displayText = JSON.stringify(result, null, 2);
+        const resultStr = JSON.stringify(result, null, 2);
+        if (resultStr.length > 2e3) {
+          displayText = `${resultStr.slice(0, 1e3)}... [${resultStr.length - 1e3} chars omitted]`;
+        } else {
+          displayText = resultStr;
+        }
       } catch {
         displayText = `[Unparseable result: ${typeof result}]`;
       }
@@ -2506,7 +2515,17 @@ var MCPClient = class {
         { timeout: this.timeout }
         // Use server-specific timeout, default 1 minute
       );
-      logger.debug(`Tool '${name}' result: ${JSON.stringify(result, null, 2)}`);
+      const logResult = JSON.stringify(
+        result,
+        (key, value) => {
+          if (key === "data" && typeof value === "string" && value.length > 100) {
+            return `[Base64 data: ${value.length} chars]`;
+          }
+          return value;
+        },
+        2
+      );
+      logger.debug(`Tool '${name}' result: ${logResult}`);
       if (result === null || result === void 0) {
         return "Tool executed successfully with no result data.";
       }
@@ -5885,6 +5904,8 @@ var ContextError = class {
 
 // src/core/context/utils.ts
 var DEFAULT_OVERHEAD_PER_MESSAGE = 4;
+var MIN_BASE64_HEURISTIC_LENGTH = 512;
+var MAX_TOOL_TEXT_CHARS = 8e3;
 function countMessagesTokens(history, tokenizer, overheadPerMessage = DEFAULT_OVERHEAD_PER_MESSAGE) {
   let total = 0;
   logger.debug(`Counting tokens for ${history.length} messages`);
@@ -5899,16 +5920,26 @@ function countMessagesTokens(history, tokenizer, overheadPerMessage = DEFAULT_OV
               total += tokenizer.countTokens(part.text);
             } else if (part.type === "image") {
               if (typeof part.image === "string") {
-                const byteLength = Math.floor(part.image.length * 3 / 4);
-                total += Math.ceil(byteLength / 1024);
+                if (isDataUri(part.image)) {
+                  const base64Payload = extractBase64FromDataUri(part.image);
+                  const byteLength = base64LengthToBytes(base64Payload.length);
+                  total += Math.ceil(byteLength / 1024);
+                } else {
+                  total += estimateTextTokens(part.image);
+                }
               } else if (part.image instanceof Uint8Array || part.image instanceof Buffer || part.image instanceof ArrayBuffer) {
                 const bytes = part.image instanceof ArrayBuffer ? part.image.byteLength : part.image.length;
                 total += Math.ceil(bytes / 1024);
               }
             } else if (part.type === "file") {
               if (typeof part.data === "string") {
-                const byteLength = Math.floor(part.data.length * 3 / 4);
-                total += Math.ceil(byteLength / 1024);
+                if (isDataUri(part.data)) {
+                  const base64Payload = extractBase64FromDataUri(part.data);
+                  const byteLength = base64LengthToBytes(base64Payload.length);
+                  total += Math.ceil(byteLength / 1024);
+                } else {
+                  total += estimateTextTokens(part.data);
+                }
               } else if (part.data instanceof Uint8Array || part.data instanceof Buffer || part.data instanceof ArrayBuffer) {
                 const bytes = part.data instanceof ArrayBuffer ? part.data.byteLength : part.data.length;
                 total += Math.ceil(bytes / 1024);
@@ -5950,7 +5981,7 @@ function getImageData(imagePart) {
   } else if (image instanceof URL) {
     return image.toString();
   }
-  console.warn("Unexpected image data type in getImageData:", typeof image);
+  logger.warn(`Unexpected image data type in getImageData: ${typeof image}`);
   return "";
 }
 function getFileData(filePart) {
@@ -5966,7 +5997,7 @@ function getFileData(filePart) {
   } else if (data instanceof URL) {
     return data.toString();
   }
-  console.warn("Unexpected file data type in getFileData:", typeof data);
+  logger.warn(`Unexpected file data type in getFileData: ${typeof data}`);
   return "";
 }
 function filterMessagesByLLMCapabilities(messages, config) {
@@ -6001,10 +6032,236 @@ function filterMessagesByLLMCapabilities(messages, config) {
       };
     });
   } catch (error) {
-    console.warn("Failed to filter messages by LLM capabilities:", error);
+    logger.warn(`Failed to filter messages by LLM capabilities: ${String(error)}`);
     return messages;
   }
 }
+function isLikelyBase64String(value, minLength = MIN_BASE64_HEURISTIC_LENGTH) {
+  if (!value || value.length < minLength) return false;
+  if (value.startsWith("data:") && value.includes(";base64,")) return true;
+  const b64Regex = /^[A-Za-z0-9+/=\r\n]+$/;
+  if (!b64Regex.test(value)) return false;
+  const nonWordRatio = (value.match(/[^A-Za-z0-9+/=]/g)?.length || 0) / value.length;
+  return nonWordRatio < 0.01;
+}
+function parseDataUri(value) {
+  if (!value.startsWith("data:")) return null;
+  const commaIdx = value.indexOf(",");
+  if (commaIdx === -1) return null;
+  const meta = value.slice(5, commaIdx);
+  if (!/;base64$/i.test(meta)) return null;
+  const mediaType = meta.replace(/;base64$/i, "") || "application/octet-stream";
+  const base64 = value.slice(commaIdx + 1);
+  return { mediaType, base64 };
+}
+function sanitizeDeepObject(obj) {
+  if (obj == null) return obj;
+  if (typeof obj === "string") {
+    if (isLikelyBase64String(obj)) {
+      const approxBytes = Math.floor(obj.length * 3 / 4);
+      logger.debug(
+        `sanitizeDeepObject: replaced large base64 string (~${approxBytes} bytes) with placeholder`
+      );
+      return `[binary data omitted ~${approxBytes} bytes]`;
+    }
+    return obj;
+  }
+  if (Array.isArray(obj)) return obj.map((x) => sanitizeDeepObject(x));
+  if (typeof obj === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      out[k] = sanitizeDeepObject(v);
+    }
+    return out;
+  }
+  return obj;
+}
+function sanitizeToolResultToContent(result) {
+  try {
+    if (typeof result === "string") {
+      const dataUri = parseDataUri(result);
+      if (dataUri) {
+        const mediaType = dataUri.mediaType;
+        logger.debug(
+          `sanitizeToolResultToContent: detected data URI (${mediaType}), converting to media part`
+        );
+        if (mediaType.startsWith("image/")) {
+          return [{ type: "image", image: dataUri.base64, mimeType: mediaType }];
+        }
+        return [{ type: "file", data: dataUri.base64, mimeType: mediaType }];
+      }
+      if (isLikelyBase64String(result)) {
+        logger.debug(
+          "sanitizeToolResultToContent: detected base64-like string, converting to file part"
+        );
+        return [
+          {
+            type: "file",
+            data: result,
+            mimeType: "application/octet-stream",
+            filename: "tool-output.bin"
+          }
+        ];
+      }
+      if (result.length > MAX_TOOL_TEXT_CHARS) {
+        const head = result.slice(0, 4e3);
+        const tail = result.slice(-1e3);
+        logger.debug(
+          `sanitizeToolResultToContent: truncating long text tool output (len=${result.length})`
+        );
+        return `${head}
+... [${result.length - 5e3} chars omitted] ...
+${tail}`;
+      }
+      return result;
+    }
+    if (Array.isArray(result)) {
+      const parts = [];
+      for (const item of result) {
+        if (item == null) continue;
+        if (typeof item === "string") {
+          const dataUri = parseDataUri(item);
+          if (dataUri) {
+            const mt = dataUri.mediaType;
+            if (mt.startsWith("image/"))
+              parts.push({ type: "image", image: dataUri.base64, mimeType: mt });
+            else parts.push({ type: "file", data: dataUri.base64, mimeType: mt });
+            continue;
+          }
+          if (isLikelyBase64String(item)) {
+            parts.push({
+              type: "file",
+              data: item,
+              mimeType: "application/octet-stream",
+              filename: "tool-output.bin"
+            });
+            continue;
+          }
+          parts.push({ type: "text", text: item });
+          continue;
+        }
+        if (typeof item === "object") {
+          const obj = item;
+          if (obj.type === "text" && typeof obj.text === "string") {
+            parts.push({ type: "text", text: obj.text });
+            continue;
+          }
+          if (obj.type === "image" && obj.image !== void 0 || "image" in obj) {
+            parts.push({
+              type: "image",
+              image: getImageData({ image: obj.image }),
+              mimeType: obj.mimeType || "image/jpeg"
+            });
+            continue;
+          }
+          if (obj.type === "file" && obj.data !== void 0) {
+            parts.push({
+              type: "file",
+              data: getFileData({ data: obj.data }),
+              mimeType: obj.mimeType || "application/octet-stream",
+              filename: obj.filename
+            });
+            continue;
+          }
+          if ("data" in obj && (typeof obj.mimeType === "string" || obj.filename)) {
+            parts.push({
+              type: "file",
+              data: getFileData({ data: obj.data }),
+              mimeType: obj.mimeType || "application/octet-stream",
+              filename: obj.filename
+            });
+            continue;
+          }
+          const cleaned = sanitizeDeepObject(obj);
+          parts.push({ type: "text", text: safeStringify(cleaned) });
+          continue;
+        }
+        parts.push({ type: "text", text: String(item) });
+      }
+      return parts;
+    }
+    if (result && typeof result === "object") {
+      const anyObj = result;
+      if ("image" in anyObj) {
+        return [
+          {
+            type: "image",
+            image: getImageData({ image: anyObj.image }),
+            mimeType: anyObj.mimeType || "image/jpeg"
+          }
+        ];
+      }
+      if ("data" in anyObj && anyObj.mimeType) {
+        return [
+          {
+            type: "file",
+            data: getFileData({ data: anyObj.data }),
+            mimeType: anyObj.mimeType,
+            filename: anyObj.filename
+          }
+        ];
+      }
+      const cleaned = sanitizeDeepObject(anyObj);
+      return safeStringify(cleaned);
+    }
+    return safeStringify(result ?? "");
+  } catch (err) {
+    logger.warn(`sanitizeToolResultToContent failed, falling back to string: ${String(err)}`);
+    try {
+      return safeStringify(result ?? "");
+    } catch {
+      return String(result ?? "");
+    }
+  }
+}
+function summarizeToolContentForText(content) {
+  if (!Array.isArray(content)) return String(content || "");
+  const parts = [];
+  for (const p of content) {
+    if (p.type === "text") {
+      parts.push(p.text);
+    } else if (p.type === "image") {
+      let bytes = 0;
+      if (typeof p.image === "string") bytes = Math.floor(p.image.length * 3 / 4);
+      else if (p.image instanceof ArrayBuffer) bytes = p.image.byteLength;
+      else if (p.image instanceof Uint8Array) bytes = p.image.length;
+      else if (p.image instanceof Buffer) bytes = p.image.length;
+      parts.push(`[image ${p.mimeType || "image"} ~${Math.ceil(bytes / 1024)}KB]`);
+    } else if (p.type === "file") {
+      let bytes = 0;
+      if (typeof p.data === "string") bytes = Math.floor(p.data.length * 3 / 4);
+      else if (p.data instanceof ArrayBuffer) bytes = p.data.byteLength;
+      else if (p.data instanceof Uint8Array) bytes = p.data.length;
+      else if (p.data instanceof Buffer) bytes = p.data.length;
+      const label = p.filename ? `${p.filename}` : `${p.mimeType || "file"}`;
+      parts.push(`[file ${label} ~${Math.ceil(bytes / 1024)}KB]`);
+    }
+  }
+  const summary = parts.join("\n");
+  return summary.slice(0, 4e3);
+}
+function base64LengthToBytes(charLength) {
+  return Math.floor(charLength * 3 / 4);
+}
+function isDataUri(str) {
+  return str.startsWith("data:") && str.includes(";base64,");
+}
+function extractBase64FromDataUri(dataUri) {
+  const commaIndex = dataUri.indexOf(",");
+  return commaIndex !== -1 ? dataUri.substring(commaIndex + 1) : "";
+}
+function estimateTextTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function toTextForToolMessage(content) {
+  if (Array.isArray(content)) {
+    return summarizeToolContentForText(content);
+  }
+  if (typeof content === "string") {
+    return isLikelyBase64String(content) ? "[binary data omitted]" : content;
+  }
+  return String(content ?? "");
+}
 
 // src/core/context/compression/middle-removal.ts
 var MiddleRemovalStrategy = class {
@@ -6420,21 +6677,17 @@ ${prompt}`);
       throw ContextError.toolCallIdNameRequired();
     }
     let content;
-    if (result && typeof result === "object" && "image" in result) {
-      const imagePart = result;
-      content = [
-        {
-          type: "image",
-          image: getImageData(imagePart),
-          mimeType: imagePart.mimeType || "image/jpeg"
-        }
-      ];
-    } else if (typeof result === "string") {
-      content = result;
-    } else if (Array.isArray(result)) {
-      content = result;
-    } else {
-      content = JSON.stringify(result ?? "");
+    content = sanitizeToolResultToContent(result);
+    if (typeof content === "string") {
+      const preview = content.slice(0, 200);
+      logger.debug(
+        `ContextManager: Storing tool result (text) for ${name} (len=${content.length}): ${preview}${content.length > 200 ? "..." : ""}`
+      );
+    } else if (Array.isArray(content)) {
+      const summary = content.map(
+        (p) => p.type === "text" ? `text(${p.text.length})` : p.type === "image" ? `image(${p.mimeType || "image"})` : `file(${p.mimeType || "file"})`
+      ).join(", ");
+      logger.debug(`ContextManager: Storing tool result (parts) for ${name}: [${summary}]`);
     }
     await this.addMessage({ role: "tool", content, toolCallId, name });
   }
@@ -7195,6 +7448,8 @@ var VercelLLMService = class {
   sessionEventBus;
   sessionId;
   toolSupportCache = /* @__PURE__ */ new Map();
+  // Map of toolCallId -> queue of raw results to emit with that callId
+  rawResultsByCallId = /* @__PURE__ */ new Map();
   /**
    * Helper to extract model ID from LanguageModel union type (string | LanguageModelV2)
    */
@@ -7233,13 +7488,20 @@ var VercelLLMService = class {
       if (tool) {
         acc[toolName] = {
           inputSchema: jsonSchema(tool.parameters),
-          execute: async (args) => {
+          execute: async (args, options) => {
             try {
-              return await this.toolManager.executeTool(
+              const rawResult = await this.toolManager.executeTool(
                 toolName,
                 args,
                 this.sessionId
               );
+              const callId = options.toolCallId;
+              const queue = this.rawResultsByCallId.get(callId) ?? [];
+              queue.push(rawResult);
+              this.rawResultsByCallId.set(callId, queue);
+              const safeContent = sanitizeToolResultToContent(rawResult);
+              const summaryText = summarizeToolContentForText(safeContent);
+              return summaryText;
             } catch (err) {
               if (err instanceof DextoRuntimeError && err.code === "tools_execution_denied" /* EXECUTION_DENIED */) {
                 return { error: err.message, denied: true };
@@ -7393,10 +7655,19 @@ var VercelLLMService = class {
           }
           if (step.toolResults && step.toolResults.length > 0) {
             for (const toolResult of step.toolResults) {
+              const callId = toolResult.toolCallId;
+              const sanitized = toolResult.output;
+              let raw;
+              if (callId) {
+                const q = this.rawResultsByCallId.get(callId) ?? [];
+                raw = q.shift();
+                if (q.length > 0) this.rawResultsByCallId.set(callId, q);
+                else this.rawResultsByCallId.delete(callId);
+              }
               this.sessionEventBus.emit("llmservice:toolResult", {
                 toolName: toolResult.toolName,
-                result: toolResult.output,
-                callId: toolResult.toolCallId,
+                result: raw ?? sanitized,
+                callId,
                 success: true
               });
             }
@@ -7561,10 +7832,19 @@ var VercelLLMService = class {
         }
         if (step.toolResults && step.toolResults.length > 0) {
           for (const toolResult of step.toolResults) {
+            const callId = toolResult.toolCallId;
+            const sanitized = toolResult.output;
+            let raw;
+            if (callId) {
+              const q = this.rawResultsByCallId.get(callId) ?? [];
+              raw = q.shift();
+              if (q.length > 0) this.rawResultsByCallId.set(callId, q);
+              else this.rawResultsByCallId.delete(callId);
+            }
             this.sessionEventBus.emit("llmservice:toolResult", {
               toolName: toolResult.toolName,
-              result: toolResult.output,
-              callId: toolResult.toolCallId,
+              result: raw ?? sanitized,
+              callId,
               success: true
             });
           }
@@ -7705,7 +7985,7 @@ var OpenAIMessageFormatter = class {
         case "tool":
           formatted.push({
             role: "tool",
-            content: String(msg.content || ""),
+            content: toTextForToolMessage(msg.content),
             tool_call_id: msg.toolCallId || ""
           });
           break;
@@ -8275,13 +8555,14 @@ var AnthropicMessageFormatter = class {
             formatted.push(pendingCall.assistantMsg);
             pendingCall.assistantMsg = null;
           }
+          const safeContent = toTextForToolMessage(msg.content);
           const toolResultMsg = {
             role: "user",
             content: [
               {
                 type: "tool_result",
                 tool_use_id: msg.toolCallId,
-                content: String(msg.content || "")
+                content: safeContent
               }
             ]
           };
@@ -8289,13 +8570,14 @@ var AnthropicMessageFormatter = class {
           pendingToolCalls.delete(msg.toolCallId);
         } else {
           logger.warn(`Tool result found without matching tool call: ${msg.toolCallId}`);
+          const orphanSafe = toTextForToolMessage(msg.content);
           const orphanToolResult = {
             role: "user",
             content: [
               {
                 type: "tool_result",
                 tool_use_id: msg.toolCallId,
-                content: String(msg.content || "")
+                content: orphanSafe
               }
             ]
           };
@@ -10288,7 +10570,7 @@ var StorageManager = class {
   async createSQLiteBackend(config) {
     try {
       if (!SQLiteBackend) {
-        const module = await import("./sqlite-backend-4KSJRUVL.js");
+        const module = await import("./sqlite-backend-3VNBKYIT.js");
         SQLiteBackend = module.SQLiteBackend;
       }
       logger.info(`Using SQLite database at ${config.path}`);
@@ -11518,6 +11800,7 @@ var AgentCardSchema = z10.object({
 }).strict();
 var AgentConfigSchema = z10.object({
   agentCard: AgentCardSchema.describe("Configuration for the agent card").optional(),
+  greeting: z10.string().max(500).optional().describe("Default greeting text to show when a chat starts (for UI consumption)"),
   systemPrompt: SystemPromptConfigSchema.describe(
     "System prompt: string shorthand or structured config"
   ),