dexto 1.1.2 → 1.1.3

package/dist/src/core/index.cjs

@@ -2195,10 +2195,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}]`;
           }
@@ -2730,7 +2739,17 @@ var init_mcp_client = __esm({
             { 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.";
           }
@@ -6310,16 +6329,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);
@@ -6361,7 +6390,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) {
@@ -6377,7 +6406,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) {
@@ -6412,11 +6441,237 @@ 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;
   }
 }
-var DEFAULT_OVERHEAD_PER_MESSAGE;
+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 ?? "");
+}
+var DEFAULT_OVERHEAD_PER_MESSAGE, MIN_BASE64_HEURISTIC_LENGTH, MAX_TOOL_TEXT_CHARS;
 var init_utils = __esm({
   "src/core/context/utils.ts"() {
     "use strict";
@@ -6424,7 +6679,10 @@ var init_utils = __esm({
     init_logger2();
     init_registry3();
     init_errors7();
+    init_safe_stringify();
     DEFAULT_OVERHEAD_PER_MESSAGE = 4;
+    MIN_BASE64_HEURISTIC_LENGTH = 512;
+    MAX_TOOL_TEXT_CHARS = 8e3;
   }
 });
 
@@ -6869,21 +7127,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 });
       }
@@ -7698,6 +7952,7 @@ var init_vercel2 = __esm({
     init_logger2();
     import_ai2 = require("ai");
     init_manager3();
+    init_utils();
     init_registry3();
     init_DextoRuntimeError();
     init_error_codes5();
@@ -7714,6 +7969,8 @@ var init_vercel2 = __esm({
       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)
        */
@@ -7752,13 +8009,20 @@ var init_vercel2 = __esm({
           if (tool) {
             acc[toolName] = {
               inputSchema: (0, import_ai2.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 };
@@ -7912,10 +8176,19 @@ var init_vercel2 = __esm({
               }
               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
                   });
                 }
@@ -8080,10 +8353,19 @@ var init_vercel2 = __esm({
             }
             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
                 });
               }
@@ -8229,7 +8511,7 @@ var init_openai2 = __esm({
             case "tool":
               formatted.push({
                 role: "tool",
-                content: String(msg.content || ""),
+                content: toTextForToolMessage(msg.content),
                 tool_call_id: msg.toolCallId || ""
               });
               break;
@@ -8818,13 +9100,14 @@ var init_anthropic2 = __esm({
                 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
                   }
                 ]
               };
@@ -8832,13 +9115,14 @@ var init_anthropic2 = __esm({
               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
                   }
                 ]
               };
@@ -13040,6 +13324,7 @@ var init_schemas7 = __esm({
     }).strict();
     AgentConfigSchema = import_zod10.z.object({
       agentCard: AgentCardSchema.describe("Configuration for the agent card").optional(),
+      greeting: import_zod10.z.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"
       ),

package/dist/src/core/index.d.cts

@@ -2448,6 +2448,7 @@ declare const AgentConfigSchema: z.ZodBranded<z.ZodObject<{
             outputModes?: string[] | undefined;
         }[] | undefined;
     }>>;
+    greeting: z.ZodOptional<z.ZodString>;
     systemPrompt: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.ZodString, {
         contributors: {
             id: string;
@@ -3497,6 +3498,7 @@ declare const AgentConfigSchema: z.ZodBranded<z.ZodObject<{
         } | undefined;
         documentationUrl?: string | undefined;
     } | undefined;
+    greeting?: string | undefined;
 }, {
     llm: {
         apiKey: string;
@@ -3650,6 +3652,7 @@ declare const AgentConfigSchema: z.ZodBranded<z.ZodObject<{
             outputModes?: string[] | undefined;
         }[] | undefined;
     } | undefined;
+    greeting?: string | undefined;
     mcpServers?: Record<string, {
         type: "stdio";
         command: string;

package/dist/src/core/index.d.ts

@@ -2448,6 +2448,7 @@ declare const AgentConfigSchema: z.ZodBranded<z.ZodObject<{
             outputModes?: string[] | undefined;
         }[] | undefined;
     }>>;
+    greeting: z.ZodOptional<z.ZodString>;
     systemPrompt: z.ZodBranded<z.ZodUnion<[z.ZodEffects<z.ZodString, {
         contributors: {
             id: string;
@@ -3497,6 +3498,7 @@ declare const AgentConfigSchema: z.ZodBranded<z.ZodObject<{
         } | undefined;
         documentationUrl?: string | undefined;
     } | undefined;
+    greeting?: string | undefined;
 }, {
     llm: {
         apiKey: string;
@@ -3650,6 +3652,7 @@ declare const AgentConfigSchema: z.ZodBranded<z.ZodObject<{
             outputModes?: string[] | undefined;
         }[] | undefined;
     } | undefined;
+    greeting?: string | undefined;
     mcpServers?: Record<string, {
         type: "stdio";
         command: string;

package/dist/src/core/index.js

@@ -97,7 +97,7 @@ import {
   writeLLMPreferences,
   writePreferencesToAgent,
   zodToIssues
-} from "./chunk-2O5JENNA.js";
+} from "./chunk-XABD32T2.js";
 import {
   DextoBaseError,
   DextoRuntimeError,

package/dist/src/core/{sqlite-backend-4KSJRUVL.js → sqlite-backend-3VNBKYIT.js}

@@ -1,7 +1,7 @@
 import {
   getDextoPath,
   logger
-} from "./chunk-2O5JENNA.js";
+} from "./chunk-XABD32T2.js";
 import {
   StorageError,
   init_esm_shims

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dexto",
-    "version": "1.1.2",
+    "version": "1.1.3",
     "engines": {
         "node": ">=20.0.0",
         "npm": ">=8.3.0"
@@ -72,6 +72,8 @@
         "agents/music-agent/",
         "agents/product-name-researcher/",
         "agents/triage-demo/",
+        "agents/nano-banana-agent/",
+        "agents/podcast-agent/",
         "public/"
     ],
     "dependencies": {