@dexto/core 1.1.4 → 1.1.6

package/dist/llm/formatters/vercel.cjs

@@ -0,0 +1,411 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vercel_exports = {};
+__export(vercel_exports, {
+  VercelMessageFormatter: () => VercelMessageFormatter
+});
+module.exports = __toCommonJS(vercel_exports);
+var import_utils = require("../../context/utils.cjs");
+var import_logger = require("../../logger/index.cjs");
+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 = (0, import_utils.filterMessagesByLLMCapabilities)([...history], context);
+      const modelInfo = `${context.provider}/${context.model}`;
+      import_logger.logger.debug(`Applied Vercel filtering for ${modelInfo}`);
+    } catch (error) {
+      import_logger.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 = {};
+            import_logger.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 = (0, import_utils.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 = (0, import_utils.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] };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VercelMessageFormatter
+});

package/dist/llm/formatters/vercel.d.cts

@@ -0,0 +1,48 @@
+import { ModelMessage, StreamTextResult, ToolSet, GenerateTextResult } from 'ai';
+import { IMessageFormatter } from './types.cjs';
+import { LLMContext } from '../types.cjs';
+import { InternalMessage } from '../../context/types.cjs';
+
+/**
+ * Message formatter for Vercel AI SDK.
+ *
+ * Converts the internal message format to Vercel's specific structure:
+ * - System prompt is included in the messages array
+ * - Tool calls use function_call property instead of tool_calls
+ * - Tool results use the 'tool' role (SDK v5)
+ *
+ * Note: Vercel's implementation is different from OpenAI's standard,
+ * particularly in its handling of function calls and responses.
+ */
+declare class VercelMessageFormatter implements IMessageFormatter {
+    /**
+     * 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: Readonly<InternalMessage[]>, context: LLMContext, systemPrompt: string | null): ModelMessage[];
+    /**
+     * 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(): null;
+    /**
+     * Parses raw Vercel SDK stream response into internal message objects.
+     * This handles StreamTextResult which has different structure than GenerateTextResult
+     */
+    parseStreamResponse(response: StreamTextResult<ToolSet, unknown>): Promise<InternalMessage[]>;
+    /**
+     * Parses raw Vercel SDK response into internal message objects.
+     * TODO: Break this into smaller functions
+     */
+    parseResponse(response: GenerateTextResult<ToolSet, unknown>): InternalMessage[];
+    private formatAssistantMessage;
+    private formatToolMessage;
+}
+
+export { VercelMessageFormatter };

package/dist/llm/formatters/vercel.d.ts

@@ -0,0 +1,48 @@
+import { ModelMessage, StreamTextResult, ToolSet, GenerateTextResult } from 'ai';
+import { IMessageFormatter } from './types.js';
+import { LLMContext } from '../types.js';
+import { InternalMessage } from '../../context/types.js';
+
+/**
+ * Message formatter for Vercel AI SDK.
+ *
+ * Converts the internal message format to Vercel's specific structure:
+ * - System prompt is included in the messages array
+ * - Tool calls use function_call property instead of tool_calls
+ * - Tool results use the 'tool' role (SDK v5)
+ *
+ * Note: Vercel's implementation is different from OpenAI's standard,
+ * particularly in its handling of function calls and responses.
+ */
+declare class VercelMessageFormatter implements IMessageFormatter {
+    /**
+     * 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: Readonly<InternalMessage[]>, context: LLMContext, systemPrompt: string | null): ModelMessage[];
+    /**
+     * 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(): null;
+    /**
+     * Parses raw Vercel SDK stream response into internal message objects.
+     * This handles StreamTextResult which has different structure than GenerateTextResult
+     */
+    parseStreamResponse(response: StreamTextResult<ToolSet, unknown>): Promise<InternalMessage[]>;
+    /**
+     * Parses raw Vercel SDK response into internal message objects.
+     * TODO: Break this into smaller functions
+     */
+    parseResponse(response: GenerateTextResult<ToolSet, unknown>): InternalMessage[];
+    private formatAssistantMessage;
+    private formatToolMessage;
+}
+
+export { VercelMessageFormatter };