@dexto/core 1.1.4 → 1.1.6

package/dist/llm/formatters/vercel.js

@@ -0,0 +1,387 @@
+import { getImageData, getFileData, filterMessagesByLLMCapabilities } from "../../context/utils.js";
+import { logger } from "../../logger/index.js";
+class VercelMessageFormatter {
+  /**
+   * Formats internal messages into Vercel AI SDK format
+   *
+   * @param history Array of internal messages to format
+   * @param systemPrompt System prompt to include at the beginning of messages
+   * @returns Array of messages formatted for Vercel's API
+   */
+  format(history, context, systemPrompt) {
+    const formatted = [];
+    let filteredHistory;
+    try {
+      filteredHistory = filterMessagesByLLMCapabilities([...history], context);
+      const modelInfo = `${context.provider}/${context.model}`;
+      logger.debug(`Applied Vercel filtering for ${modelInfo}`);
+    } catch (error) {
+      logger.warn(`Failed to apply capability filtering, using original history: ${error}`);
+      filteredHistory = [...history];
+    }
+    if (systemPrompt) {
+      formatted.push({
+        role: "system",
+        content: systemPrompt
+      });
+    }
+    for (const msg of filteredHistory) {
+      switch (msg.role) {
+        case "user":
+          if (msg.content !== null) {
+            const content = typeof msg.content === "string" ? msg.content : msg.content.map((part) => {
+              if (part.type === "file") {
+                return {
+                  type: "file",
+                  data: part.data,
+                  mediaType: part.mimeType,
+                  // Convert mimeType -> mediaType
+                  ...part.filename && { filename: part.filename }
+                };
+              } else if (part.type === "image") {
+                return {
+                  type: "image",
+                  image: part.image,
+                  ...part.mimeType && { mediaType: part.mimeType }
+                  // Convert mimeType -> mediaType
+                };
+              }
+              return part;
+            });
+            formatted.push({
+              role: "user",
+              content
+            });
+          }
+          break;
+        case "system":
+          if (msg.content !== null) {
+            formatted.push({
+              role: "system",
+              content: String(msg.content)
+            });
+          }
+          break;
+        case "assistant":
+          formatted.push({ role: "assistant", ...this.formatAssistantMessage(msg) });
+          break;
+        case "tool":
+          formatted.push({ role: "tool", ...this.formatToolMessage(msg) });
+          break;
+      }
+    }
+    return formatted;
+  }
+  /**
+   * Vercel handles system prompts in the messages array
+   * This method returns null since the system prompt is already
+   * included directly in the formatted messages.
+   *
+   * @returns null as Vercel doesn't need a separate system prompt
+   */
+  formatSystemPrompt() {
+    return null;
+  }
+  /**
+   * Parses raw Vercel SDK stream response into internal message objects.
+   * This handles StreamTextResult which has different structure than GenerateTextResult
+   */
+  async parseStreamResponse(response) {
+    const resolvedResponse = await response.response;
+    const adaptedResponse = {
+      response: {
+        messages: resolvedResponse?.messages || []
+      }
+    };
+    const internal = this.parseResponse(
+      adaptedResponse
+    );
+    const lastAssistant = [...internal].reverse().find((m) => m.role === "assistant");
+    if (lastAssistant) {
+      const usage = await response.totalUsage;
+      const reasoningText = await response.reasoningText;
+      if (reasoningText) {
+        lastAssistant.reasoning = reasoningText;
+      }
+      if (usage) {
+        lastAssistant.tokenUsage = {
+          ...usage.inputTokens !== void 0 && { inputTokens: usage.inputTokens },
+          ...usage.outputTokens !== void 0 && { outputTokens: usage.outputTokens },
+          ...usage.reasoningTokens !== void 0 && {
+            reasoningTokens: usage.reasoningTokens
+          },
+          ...usage.totalTokens !== void 0 && { totalTokens: usage.totalTokens }
+        };
+      }
+    }
+    return internal;
+  }
+  /**
+   * Parses raw Vercel SDK response into internal message objects.
+   * TODO: Break this into smaller functions
+   */
+  parseResponse(response) {
+    const internal = [];
+    if (!response.response.messages) return internal;
+    for (const msg of response.response.messages) {
+      const role = msg.role;
+      switch (role) {
+        case "user":
+          if (typeof msg.content === "string") {
+            internal.push({
+              role: "user",
+              content: [{ type: "text", text: msg.content }]
+            });
+          } else if (Array.isArray(msg.content)) {
+            const srcParts = msg.content;
+            const parts = srcParts.map((p) => {
+              if (p.type === "text") return { type: "text", text: p.text };
+              if (p.type === "image")
+                return {
+                  type: "image",
+                  image: p.image,
+                  mimeType: p.mediaType ?? "image/jpeg"
+                };
+              if (p.type === "file")
+                return {
+                  type: "file",
+                  data: p.data,
+                  mimeType: p.mediaType,
+                  filename: p.filename
+                };
+              return { type: "text", text: JSON.stringify(p) };
+            });
+            internal.push({
+              role: "user",
+              content: parts
+            });
+          }
+          break;
+        case "assistant": {
+          let text = null;
+          const calls = [];
+          if (typeof msg.content === "string") {
+            text = msg.content;
+          } else if (Array.isArray(msg.content)) {
+            let combined = "";
+            for (const part of msg.content) {
+              if (part.type === "text") {
+                combined += part.text;
+              } else if (part.type === "tool-call") {
+                calls.push({
+                  id: part.toolCallId,
+                  type: "function",
+                  function: {
+                    name: part.toolName,
+                    arguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input)
+                  }
+                });
+              }
+            }
+            text = combined || null;
+          }
+          const assistantMessage = {
+            role: "assistant",
+            content: text
+          };
+          if (calls.length > 0) {
+            assistantMessage.toolCalls = calls;
+          }
+          internal.push(assistantMessage);
+          break;
+        }
+        case "tool":
+          if (Array.isArray(msg.content)) {
+            for (const part of msg.content) {
+              if (part.type === "tool-result") {
+                let content;
+                const output = part.output;
+                if (output.type === "content") {
+                  content = output.value.map((item) => {
+                    if (item.type === "media") {
+                      return {
+                        type: "image",
+                        image: item.data,
+                        mimeType: item.mediaType
+                      };
+                    } else {
+                      return {
+                        type: "text",
+                        text: item.text
+                      };
+                    }
+                  });
+                } else if (output.type === "text" || output.type === "error-text") {
+                  content = output.value;
+                } else if (output.type === "json" || output.type === "error-json") {
+                  content = JSON.stringify(output.value);
+                } else {
+                  content = JSON.stringify(output);
+                }
+                internal.push({
+                  role: "tool",
+                  content,
+                  toolCallId: part.toolCallId,
+                  name: part.toolName
+                });
+              }
+            }
+          }
+          break;
+        default:
+          break;
+      }
+    }
+    const lastAssistant = [...internal].reverse().find((m) => m.role === "assistant");
+    const anyResp = response;
+    const usage = anyResp.totalUsage;
+    const reasoningText = anyResp.reasoningText;
+    const modelId = response.response?.modelId;
+    if (lastAssistant) {
+      if (typeof reasoningText === "string" && reasoningText.length > 0) {
+        lastAssistant.reasoning = reasoningText;
+      }
+      if (usage) {
+        lastAssistant.tokenUsage = {
+          ...usage.inputTokens !== void 0 && { inputTokens: usage.inputTokens },
+          ...usage.outputTokens !== void 0 && { outputTokens: usage.outputTokens },
+          ...usage.reasoningTokens !== void 0 && {
+            reasoningTokens: usage.reasoningTokens
+          },
+          ...usage.totalTokens !== void 0 && { totalTokens: usage.totalTokens }
+        };
+      }
+      if (modelId) {
+        lastAssistant.model = modelId;
+      }
+    }
+    return internal;
+  }
+  // Helper to format Assistant messages (with optional tool calls)
+  // TODO: improve typing when InternalMessage type is updated
+  formatAssistantMessage(msg) {
+    if (msg.toolCalls && msg.toolCalls.length > 0) {
+      const contentParts = [];
+      if (typeof msg.content === "string" && msg.content.length > 0) {
+        contentParts.push({ type: "text", text: msg.content });
+      } else if (Array.isArray(msg.content)) {
+        const combined = msg.content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n");
+        if (combined) {
+          contentParts.push({ type: "text", text: combined });
+        }
+      }
+      for (const toolCall of msg.toolCalls) {
+        const rawArgs = toolCall.function.arguments;
+        let parsed = {};
+        if (typeof rawArgs === "string") {
+          try {
+            parsed = JSON.parse(rawArgs);
+          } catch {
+            parsed = {};
+            logger.warn(
+              `Vercel formatter: invalid tool args JSON for ${toolCall.function.name}`
+            );
+          }
+        } else {
+          parsed = rawArgs ?? {};
+        }
+        contentParts.push({
+          type: "tool-call",
+          toolCallId: toolCall.id,
+          toolName: toolCall.function.name,
+          input: parsed
+        });
+      }
+      const firstToolCall = msg.toolCalls?.[0];
+      if (firstToolCall) {
+        const argString = (() => {
+          const raw = firstToolCall.function.arguments;
+          if (typeof raw === "string") return raw;
+          try {
+            return JSON.stringify(raw ?? {});
+          } catch {
+            return "{}";
+          }
+        })();
+        return {
+          content: contentParts,
+          function_call: {
+            name: firstToolCall.function.name,
+            arguments: argString
+          }
+        };
+      }
+    }
+    return {
+      content: typeof msg.content === "string" ? [{ type: "text", text: msg.content }] : msg.content
+    };
+  }
+  // Helper to format Tool result messages
+  formatToolMessage(msg) {
+    let toolResultPart;
+    if (Array.isArray(msg.content)) {
+      if (msg.content[0]?.type === "image") {
+        const imagePart = msg.content[0];
+        const imageDataBase64 = getImageData(imagePart);
+        toolResultPart = {
+          type: "tool-result",
+          toolCallId: msg.toolCallId,
+          toolName: msg.name,
+          output: {
+            type: "content",
+            value: [
+              {
+                type: "media",
+                data: imageDataBase64,
+                mediaType: imagePart.mimeType || "image/jpeg"
+              }
+            ]
+          }
+        };
+      } else if (msg.content[0]?.type === "file") {
+        const filePart = msg.content[0];
+        const fileDataBase64 = getFileData(filePart);
+        toolResultPart = {
+          type: "tool-result",
+          toolCallId: msg.toolCallId,
+          toolName: msg.name,
+          output: {
+            type: "content",
+            value: [
+              {
+                type: "media",
+                data: fileDataBase64,
+                mediaType: filePart.mimeType
+              }
+            ]
+          }
+        };
+      } else {
+        const textContent = Array.isArray(msg.content) ? msg.content.map((part) => part.type === "text" ? part.text : JSON.stringify(part)).join("\n") : String(msg.content);
+        toolResultPart = {
+          type: "tool-result",
+          toolCallId: msg.toolCallId,
+          toolName: msg.name,
+          output: {
+            type: "text",
+            value: textContent
+          }
+        };
+      }
+    } else {
+      toolResultPart = {
+        type: "tool-result",
+        toolCallId: msg.toolCallId,
+        toolName: msg.name,
+        output: {
+          type: "text",
+          value: String(msg.content || "")
+        }
+      };
+    }
+    return { content: [toolResultPart] };
+  }
+}
+export {
+  VercelMessageFormatter
+};

package/dist/llm/index.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var llm_exports = {};
+module.exports = __toCommonJS(llm_exports);
+__reExport(llm_exports, require("./errors.js"), module.exports);
+__reExport(llm_exports, require("./error-codes.js"), module.exports);
+__reExport(llm_exports, require("./registry.js"), module.exports);
+__reExport(llm_exports, require("./validation.js"), module.exports);
+__reExport(llm_exports, require("./types.js"), module.exports);
+__reExport(llm_exports, require("./services/index.js"), module.exports);
+__reExport(llm_exports, require("./schemas.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./errors.js"),
+  ...require("./error-codes.js"),
+  ...require("./registry.js"),
+  ...require("./validation.js"),
+  ...require("./types.js"),
+  ...require("./services/index.js"),
+  ...require("./schemas.js")
+});

package/dist/llm/index.d.cts

@@ -0,0 +1,39 @@
+export { LLMError } from './errors.cjs';
+export { LLMErrorCode } from './error-codes.cjs';
+export { DEFAULT_MAX_INPUT_TOKENS, LLM_REGISTRY, MIME_TYPE_TO_FILE_TYPE, ModelInfo, ProviderInfo, acceptsAnyModel, getAllSupportedModels, getAllowedMimeTypes, getDefaultModelForProvider, getEffectiveMaxInputTokens, getMaxInputTokensForModel, getProviderFromModel, getSupportedFileTypesForModel, getSupportedModels, getSupportedProviders, getSupportedRoutersForModel, getSupportedRoutersForProvider, isRouterSupportedForModel, isRouterSupportedForProvider, isValidProviderModel, modelSupportsFileType, requiresBaseURL, supportsBaseURL, validateModelFileSupport } from './registry.cjs';
+export { ValidationContext, ValidationData, ValidationInput, ValidationLLMConfig, validateInputForLLM } from './validation.cjs';
+export { LLMContext, LLMProvider, LLMRouter, LLMUpdateContext, LLM_PROVIDERS, LLM_ROUTERS, SUPPORTED_FILE_TYPES, SupportedFileType } from './types.cjs';
+export { ILLMService, LLMServiceConfig } from './services/types.cjs';
+export { LLMConfig, LLMConfigSchema, LLMUpdates, LLMUpdatesSchema, ValidatedLLMConfig } from './schemas.cjs';
+import '../errors/DextoRuntimeError.cjs';
+import '../errors/DextoBaseError.cjs';
+import '../errors/types.cjs';
+import '../agent/error-codes.cjs';
+import '../config/error-codes.cjs';
+import '../context/error-codes.cjs';
+import '../mcp/error-codes.cjs';
+import '../session/error-codes.cjs';
+import '../storage/error-codes.cjs';
+import '../systemPrompt/error-codes.cjs';
+import '../tools/error-codes.cjs';
+import '../preferences/error-codes.cjs';
+import '../agent/registry/error-codes.cjs';
+import '../context/types.cjs';
+import '../utils/result.cjs';
+import 'zod';
+import 'ai';
+import '../tools/types.cjs';
+import 'json-schema';
+import '../context/manager.cjs';
+import './formatters/types.cjs';
+import './tokenizer/types.cjs';
+import '../context/compression/types.cjs';
+import '../systemPrompt/types.cjs';
+import '../mcp/manager.cjs';
+import '../mcp/schemas.cjs';
+import '../mcp/types.cjs';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/types.js';
+import '../systemPrompt/manager.cjs';
+import '../systemPrompt/schemas.cjs';
+import '../session/history/types.cjs';

package/dist/llm/index.d.ts

@@ -0,0 +1,39 @@
+export { LLMError } from './errors.js';
+export { LLMErrorCode } from './error-codes.js';
+export { DEFAULT_MAX_INPUT_TOKENS, LLM_REGISTRY, MIME_TYPE_TO_FILE_TYPE, ModelInfo, ProviderInfo, acceptsAnyModel, getAllSupportedModels, getAllowedMimeTypes, getDefaultModelForProvider, getEffectiveMaxInputTokens, getMaxInputTokensForModel, getProviderFromModel, getSupportedFileTypesForModel, getSupportedModels, getSupportedProviders, getSupportedRoutersForModel, getSupportedRoutersForProvider, isRouterSupportedForModel, isRouterSupportedForProvider, isValidProviderModel, modelSupportsFileType, requiresBaseURL, supportsBaseURL, validateModelFileSupport } from './registry.js';
+export { ValidationContext, ValidationData, ValidationInput, ValidationLLMConfig, validateInputForLLM } from './validation.js';
+export { LLMContext, LLMProvider, LLMRouter, LLMUpdateContext, LLM_PROVIDERS, LLM_ROUTERS, SUPPORTED_FILE_TYPES, SupportedFileType } from './types.js';
+export { ILLMService, LLMServiceConfig } from './services/types.js';
+export { LLMConfig, LLMConfigSchema, LLMUpdates, LLMUpdatesSchema, ValidatedLLMConfig } from './schemas.js';
+import '../errors/DextoRuntimeError.js';
+import '../errors/DextoBaseError.js';
+import '../errors/types.js';
+import '../agent/error-codes.js';
+import '../config/error-codes.js';
+import '../context/error-codes.js';
+import '../mcp/error-codes.js';
+import '../session/error-codes.js';
+import '../storage/error-codes.js';
+import '../systemPrompt/error-codes.js';
+import '../tools/error-codes.js';
+import '../preferences/error-codes.js';
+import '../agent/registry/error-codes.js';
+import '../context/types.js';
+import '../utils/result.js';
+import 'zod';
+import 'ai';
+import '../tools/types.js';
+import 'json-schema';
+import '../context/manager.js';
+import './formatters/types.js';
+import './tokenizer/types.js';
+import '../context/compression/types.js';
+import '../systemPrompt/types.js';
+import '../mcp/manager.js';
+import '../mcp/schemas.js';
+import '../mcp/types.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/types.js';
+import '../systemPrompt/manager.js';
+import '../systemPrompt/schemas.js';
+import '../session/history/types.js';

package/dist/llm/index.js

@@ -0,0 +1,7 @@
+export * from "./errors.js";
+export * from "./error-codes.js";
+export * from "./registry.js";
+export * from "./validation.js";
+export * from "./types.js";
+export * from "./services/index.js";
+export * from "./schemas.js";