@yourgpt/llm-sdk 0.1.0

package/dist/adapters/index.js

@@ -0,0 +1,1642 @@
+'use strict';
+
+var core = require('@yourgpt/copilot-sdk/core');
+
+// src/adapters/base.ts
+function formatMessages(messages, systemPrompt) {
+  const formatted = [];
+  if (systemPrompt) {
+    formatted.push({ role: "system", content: systemPrompt });
+  }
+  for (const msg of messages) {
+    formatted.push({
+      role: msg.role,
+      content: msg.content ?? ""
+    });
+  }
+  return formatted;
+}
+function parameterToJsonSchema(param) {
+  const schema = {
+    type: param.type
+  };
+  if (param.description) {
+    schema.description = param.description;
+  }
+  if (param.enum) {
+    schema.enum = param.enum;
+  }
+  if (param.type === "array" && param.items) {
+    schema.items = parameterToJsonSchema(
+      param.items
+    );
+  }
+  if (param.type === "object" && param.properties) {
+    schema.properties = Object.fromEntries(
+      Object.entries(param.properties).map(([key, prop]) => [
+        key,
+        parameterToJsonSchema(
+          prop
+        )
+      ])
+    );
+  }
+  return schema;
+}
+function formatTools(actions) {
+  return actions.map((action) => ({
+    type: "function",
+    function: {
+      name: action.name,
+      description: action.description,
+      parameters: {
+        type: "object",
+        properties: action.parameters ? Object.fromEntries(
+          Object.entries(action.parameters).map(([key, param]) => [
+            key,
+            parameterToJsonSchema(param)
+          ])
+        ) : {},
+        required: action.parameters ? Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key) : []
+      }
+    }
+  }));
+}
+function hasImageAttachments(message) {
+  const attachments = message.metadata?.attachments;
+  return attachments?.some((a) => a.type === "image") ?? false;
+}
+function hasMediaAttachments(message) {
+  const attachments = message.metadata?.attachments;
+  return attachments?.some(
+    (a) => a.type === "image" || a.type === "file" && a.mimeType === "application/pdf"
+  ) ?? false;
+}
+function attachmentToAnthropicImage(attachment) {
+  if (attachment.type !== "image") return null;
+  if (attachment.url) {
+    return {
+      type: "image",
+      source: {
+        type: "url",
+        url: attachment.url
+      }
+    };
+  }
+  if (!attachment.data) return null;
+  let base64Data = attachment.data;
+  if (base64Data.startsWith("data:")) {
+    const commaIndex = base64Data.indexOf(",");
+    if (commaIndex !== -1) {
+      base64Data = base64Data.slice(commaIndex + 1);
+    }
+  }
+  return {
+    type: "image",
+    source: {
+      type: "base64",
+      media_type: attachment.mimeType || "image/png",
+      data: base64Data
+    }
+  };
+}
+function attachmentToOpenAIImage(attachment) {
+  if (attachment.type !== "image") return null;
+  let imageUrl;
+  if (attachment.url) {
+    imageUrl = attachment.url;
+  } else if (attachment.data) {
+    imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+  } else {
+    return null;
+  }
+  return {
+    type: "image_url",
+    image_url: {
+      url: imageUrl,
+      detail: "auto"
+    }
+  };
+}
+function attachmentToAnthropicDocument(attachment) {
+  if (attachment.type !== "file" || attachment.mimeType !== "application/pdf") {
+    return null;
+  }
+  if (attachment.url) {
+    return {
+      type: "document",
+      source: {
+        type: "url",
+        url: attachment.url
+      }
+    };
+  }
+  if (!attachment.data) return null;
+  let base64Data = attachment.data;
+  if (base64Data.startsWith("data:")) {
+    const commaIndex = base64Data.indexOf(",");
+    if (commaIndex !== -1) {
+      base64Data = base64Data.slice(commaIndex + 1);
+    }
+  }
+  return {
+    type: "document",
+    source: {
+      type: "base64",
+      media_type: "application/pdf",
+      data: base64Data
+    }
+  };
+}
+function messageToAnthropicContent(message) {
+  const attachments = message.metadata?.attachments;
+  const content = message.content ?? "";
+  if (!hasMediaAttachments(message)) {
+    return content;
+  }
+  const blocks = [];
+  if (attachments) {
+    for (const attachment of attachments) {
+      const imageBlock = attachmentToAnthropicImage(attachment);
+      if (imageBlock) {
+        blocks.push(imageBlock);
+        continue;
+      }
+      const docBlock = attachmentToAnthropicDocument(attachment);
+      if (docBlock) {
+        blocks.push(docBlock);
+      }
+    }
+  }
+  if (content) {
+    blocks.push({ type: "text", text: content });
+  }
+  return blocks;
+}
+function messageToOpenAIContent(message) {
+  const attachments = message.metadata?.attachments;
+  const content = message.content ?? "";
+  if (!hasImageAttachments(message)) {
+    return content;
+  }
+  const blocks = [];
+  if (content) {
+    blocks.push({ type: "text", text: content });
+  }
+  if (attachments) {
+    for (const attachment of attachments) {
+      const imageBlock = attachmentToOpenAIImage(attachment);
+      if (imageBlock) {
+        blocks.push(imageBlock);
+      }
+    }
+  }
+  return blocks;
+}
+function formatMessagesForAnthropic(messages, systemPrompt) {
+  const formatted = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === "system") continue;
+    if (msg.role === "assistant") {
+      const content = [];
+      if (msg.content) {
+        content.push({ type: "text", text: msg.content });
+      }
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        for (const tc of msg.tool_calls) {
+          content.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.function.name,
+            input: JSON.parse(tc.function.arguments)
+          });
+        }
+      }
+      formatted.push({
+        role: "assistant",
+        content: content.length === 1 && content[0].type === "text" ? content[0].text : content
+      });
+    } else if (msg.role === "tool" && msg.tool_call_id) {
+      const toolResults = [
+        {
+          type: "tool_result",
+          tool_use_id: msg.tool_call_id,
+          content: msg.content ?? ""
+        }
+      ];
+      while (i + 1 < messages.length && messages[i + 1].role === "tool") {
+        i++;
+        const nextTool = messages[i];
+        if (nextTool.tool_call_id) {
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: nextTool.tool_call_id,
+            content: nextTool.content ?? ""
+          });
+        }
+      }
+      formatted.push({
+        role: "user",
+        content: toolResults
+      });
+    } else if (msg.role === "user") {
+      formatted.push({
+        role: "user",
+        content: messageToAnthropicContent(msg)
+      });
+    }
+  }
+  return {
+    system: systemPrompt || "",
+    messages: formatted
+  };
+}
+function formatMessagesForOpenAI(messages, systemPrompt) {
+  const formatted = [];
+  if (systemPrompt) {
+    formatted.push({ role: "system", content: systemPrompt });
+  }
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      formatted.push({ role: "system", content: msg.content ?? "" });
+    } else if (msg.role === "user") {
+      formatted.push({
+        role: "user",
+        content: messageToOpenAIContent(msg)
+      });
+    } else if (msg.role === "assistant") {
+      const assistantMsg = {
+        role: "assistant",
+        content: msg.content
+      };
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        assistantMsg.tool_calls = msg.tool_calls;
+      }
+      formatted.push(assistantMsg);
+    } else if (msg.role === "tool" && msg.tool_call_id) {
+      formatted.push({
+        role: "tool",
+        content: msg.content ?? "",
+        tool_call_id: msg.tool_call_id
+      });
+    }
+  }
+  return formatted;
+}
+var OpenAIAdapter = class {
+  constructor(config) {
+    this.provider = "openai";
+    this.config = config;
+    this.model = config.model || "gpt-4o";
+  }
+  async getClient() {
+    if (!this.client) {
+      const { default: OpenAI } = await import('openai');
+      this.client = new OpenAI({
+        apiKey: this.config.apiKey,
+        baseURL: this.config.baseUrl
+      });
+    }
+    return this.client;
+  }
+  async *stream(request) {
+    const client = await this.getClient();
+    let messages;
+    if (request.rawMessages && request.rawMessages.length > 0) {
+      const processedMessages = request.rawMessages.map((msg) => {
+        const hasAttachments = msg.attachments && Array.isArray(msg.attachments) && msg.attachments.length > 0;
+        if (hasAttachments) {
+          const content = [];
+          if (msg.content) {
+            content.push({ type: "text", text: msg.content });
+          }
+          for (const attachment of msg.attachments) {
+            if (attachment.type === "image") {
+              let imageUrl;
+              if (attachment.url) {
+                imageUrl = attachment.url;
+              } else if (attachment.data) {
+                imageUrl = attachment.data.startsWith("data:") ? attachment.data : `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+              } else {
+                continue;
+              }
+              content.push({
+                type: "image_url",
+                image_url: { url: imageUrl, detail: "auto" }
+              });
+            }
+          }
+          return { ...msg, content, attachments: void 0 };
+        }
+        return msg;
+      });
+      if (request.systemPrompt) {
+        const hasSystem = processedMessages.some((m) => m.role === "system");
+        if (!hasSystem) {
+          messages = [
+            { role: "system", content: request.systemPrompt },
+            ...processedMessages
+          ];
+        } else {
+          messages = processedMessages;
+        }
+      } else {
+        messages = processedMessages;
+      }
+    } else {
+      messages = formatMessagesForOpenAI(
+        request.messages,
+        request.systemPrompt
+      );
+    }
+    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
+    const messageId = core.generateMessageId();
+    yield { type: "message:start", id: messageId };
+    try {
+      const stream = await client.chat.completions.create({
+        model: request.config?.model || this.model,
+        messages,
+        tools,
+        temperature: request.config?.temperature ?? this.config.temperature,
+        max_tokens: request.config?.maxTokens ?? this.config.maxTokens,
+        stream: true
+      });
+      let currentToolCall = null;
+      for await (const chunk of stream) {
+        if (request.signal?.aborted) {
+          break;
+        }
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+          yield { type: "message:delta", content: delta.content };
+        }
+        if (delta?.tool_calls) {
+          for (const toolCall of delta.tool_calls) {
+            if (toolCall.id) {
+              if (currentToolCall) {
+                yield {
+                  type: "action:args",
+                  id: currentToolCall.id,
+                  args: currentToolCall.arguments
+                };
+              }
+              currentToolCall = {
+                id: toolCall.id,
+                name: toolCall.function?.name || "",
+                arguments: toolCall.function?.arguments || ""
+              };
+              yield {
+                type: "action:start",
+                id: currentToolCall.id,
+                name: currentToolCall.name
+              };
+            } else if (currentToolCall && toolCall.function?.arguments) {
+              currentToolCall.arguments += toolCall.function.arguments;
+            }
+          }
+        }
+        if (chunk.choices[0]?.finish_reason) {
+          if (currentToolCall) {
+            yield {
+              type: "action:args",
+              id: currentToolCall.id,
+              args: currentToolCall.arguments
+            };
+          }
+        }
+      }
+      yield { type: "message:end" };
+      yield { type: "done" };
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "OPENAI_ERROR"
+      };
+    }
+  }
+};
+function createOpenAIAdapter(config) {
+  return new OpenAIAdapter(config);
+}
+var AnthropicAdapter = class {
+  constructor(config) {
+    this.provider = "anthropic";
+    this.config = config;
+    this.model = config.model || "claude-3-5-sonnet-latest";
+  }
+  async getClient() {
+    if (!this.client) {
+      const { default: Anthropic } = await import('@anthropic-ai/sdk');
+      this.client = new Anthropic({
+        apiKey: this.config.apiKey
+      });
+    }
+    return this.client;
+  }
+  /**
+   * Convert OpenAI-style messages to Anthropic format
+   *
+   * OpenAI format:
+   * - { role: "assistant", content: "...", tool_calls: [...] }
+   * - { role: "tool", tool_call_id: "...", content: "..." }
+   *
+   * Anthropic format:
+   * - { role: "assistant", content: [{ type: "text", text: "..." }, { type: "tool_use", id: "...", name: "...", input: {...} }] }
+   * - { role: "user", content: [{ type: "tool_result", tool_use_id: "...", content: "..." }] }
+   */
+  convertToAnthropicMessages(rawMessages) {
+    const messages = [];
+    const pendingToolResults = [];
+    for (const msg of rawMessages) {
+      if (msg.role === "system") continue;
+      if (msg.role === "assistant") {
+        if (pendingToolResults.length > 0) {
+          messages.push({
+            role: "user",
+            content: pendingToolResults.map((tr) => ({
+              type: "tool_result",
+              tool_use_id: tr.tool_use_id,
+              content: tr.content
+            }))
+          });
+          pendingToolResults.length = 0;
+        }
+        const content = [];
+        if (msg.content && typeof msg.content === "string" && msg.content.trim()) {
+          content.push({ type: "text", text: msg.content });
+        }
+        const toolCalls = msg.tool_calls;
+        if (toolCalls && toolCalls.length > 0) {
+          for (const tc of toolCalls) {
+            let input = {};
+            try {
+              input = JSON.parse(tc.function.arguments);
+            } catch {
+            }
+            content.push({
+              type: "tool_use",
+              id: tc.id,
+              name: tc.function.name,
+              input
+            });
+          }
+        }
+        if (content.length > 0) {
+          messages.push({ role: "assistant", content });
+        }
+      } else if (msg.role === "tool") {
+        pendingToolResults.push({
+          tool_use_id: msg.tool_call_id,
+          content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+        });
+      } else if (msg.role === "user") {
+        if (pendingToolResults.length > 0) {
+          messages.push({
+            role: "user",
+            content: pendingToolResults.map((tr) => ({
+              type: "tool_result",
+              tool_use_id: tr.tool_use_id,
+              content: tr.content
+            }))
+          });
+          pendingToolResults.length = 0;
+        }
+        if (msg.attachments && Array.isArray(msg.attachments) && msg.attachments.length > 0) {
+          const content = [];
+          if (msg.content && typeof msg.content === "string") {
+            content.push({ type: "text", text: msg.content });
+          }
+          for (const attachment of msg.attachments) {
+            if (attachment.type === "image") {
+              if (attachment.url) {
+                content.push({
+                  type: "image",
+                  source: {
+                    type: "url",
+                    url: attachment.url
+                  }
+                });
+              } else if (attachment.data) {
+                let base64Data = attachment.data;
+                if (base64Data.startsWith("data:")) {
+                  const commaIndex = base64Data.indexOf(",");
+                  if (commaIndex !== -1) {
+                    base64Data = base64Data.slice(commaIndex + 1);
+                  }
+                }
+                content.push({
+                  type: "image",
+                  source: {
+                    type: "base64",
+                    media_type: attachment.mimeType || "image/png",
+                    data: base64Data
+                  }
+                });
+              }
+            } else if (attachment.type === "file" && attachment.mimeType === "application/pdf") {
+              if (attachment.url) {
+                content.push({
+                  type: "document",
+                  source: {
+                    type: "url",
+                    url: attachment.url
+                  }
+                });
+              } else if (attachment.data) {
+                let base64Data = attachment.data;
+                if (base64Data.startsWith("data:")) {
+                  const commaIndex = base64Data.indexOf(",");
+                  if (commaIndex !== -1) {
+                    base64Data = base64Data.slice(commaIndex + 1);
+                  }
+                }
+                content.push({
+                  type: "document",
+                  source: {
+                    type: "base64",
+                    media_type: "application/pdf",
+                    data: base64Data
+                  }
+                });
+              }
+            }
+          }
+          messages.push({ role: "user", content });
+        } else {
+          messages.push({
+            role: "user",
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+          });
+        }
+      }
+    }
+    if (pendingToolResults.length > 0) {
+      messages.push({
+        role: "user",
+        content: pendingToolResults.map((tr) => ({
+          type: "tool_result",
+          tool_use_id: tr.tool_use_id,
+          content: tr.content
+        }))
+      });
+    }
+    return messages;
+  }
+  /**
+   * Build common request options for both streaming and non-streaming
+   */
+  buildRequestOptions(request) {
+    const systemMessage = request.systemPrompt || "";
+    let messages;
+    if (request.rawMessages && request.rawMessages.length > 0) {
+      messages = this.convertToAnthropicMessages(request.rawMessages);
+    } else {
+      const formatted = formatMessagesForAnthropic(request.messages, void 0);
+      messages = formatted.messages;
+    }
+    const tools = request.actions?.map((action) => ({
+      name: action.name,
+      description: action.description,
+      input_schema: {
+        type: "object",
+        properties: action.parameters ? Object.fromEntries(
+          Object.entries(action.parameters).map(([key, param]) => [
+            key,
+            {
+              type: param.type,
+              description: param.description,
+              enum: param.enum
+            }
+          ])
+        ) : {},
+        required: action.parameters ? Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key) : []
+      }
+    }));
+    const options = {
+      model: request.config?.model || this.model,
+      max_tokens: request.config?.maxTokens || this.config.maxTokens || 4096,
+      system: systemMessage,
+      messages,
+      tools: tools?.length ? tools : void 0
+    };
+    if (this.config.thinking?.type === "enabled") {
+      options.thinking = {
+        type: "enabled",
+        budget_tokens: this.config.thinking.budgetTokens || 1e4
+      };
+    }
+    return { options, messages };
+  }
+  /**
+   * Non-streaming completion (for debugging/comparison with original studio-ai)
+   */
+  async complete(request) {
+    const client = await this.getClient();
+    const { options } = this.buildRequestOptions(request);
+    const nonStreamingOptions = {
+      ...options,
+      stream: false
+    };
+    try {
+      const response = await client.messages.create(nonStreamingOptions);
+      let content = "";
+      let thinking = "";
+      const toolCalls = [];
+      for (const block of response.content) {
+        if (block.type === "text") {
+          content += block.text;
+        } else if (block.type === "thinking") {
+          thinking += block.thinking;
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            name: block.name,
+            args: block.input
+          });
+        }
+      }
+      return {
+        content,
+        toolCalls,
+        thinking: thinking || void 0,
+        rawResponse: response
+      };
+    } catch (error) {
+      throw error;
+    }
+  }
+  async *stream(request) {
+    const client = await this.getClient();
+    const { options } = this.buildRequestOptions(request);
+    const messageId = core.generateMessageId();
+    yield { type: "message:start", id: messageId };
+    try {
+      const stream = await client.messages.stream(options);
+      let currentToolUse = null;
+      let isInThinkingBlock = false;
+      for await (const event of stream) {
+        if (request.signal?.aborted) {
+          break;
+        }
+        switch (event.type) {
+          case "content_block_start":
+            if (event.content_block.type === "tool_use") {
+              currentToolUse = {
+                id: event.content_block.id,
+                name: event.content_block.name,
+                input: ""
+              };
+              yield {
+                type: "action:start",
+                id: currentToolUse.id,
+                name: currentToolUse.name
+              };
+            } else if (event.content_block.type === "thinking") {
+              isInThinkingBlock = true;
+              yield { type: "thinking:start" };
+            }
+            break;
+          case "content_block_delta":
+            if (event.delta.type === "text_delta") {
+              yield { type: "message:delta", content: event.delta.text };
+            } else if (event.delta.type === "thinking_delta") {
+              yield { type: "thinking:delta", content: event.delta.thinking };
+            } else if (event.delta.type === "input_json_delta" && currentToolUse) {
+              currentToolUse.input += event.delta.partial_json;
+            }
+            break;
+          case "content_block_stop":
+            if (currentToolUse) {
+              yield {
+                type: "action:args",
+                id: currentToolUse.id,
+                args: currentToolUse.input
+              };
+              currentToolUse = null;
+            }
+            if (isInThinkingBlock) {
+              yield { type: "thinking:end" };
+              isInThinkingBlock = false;
+            }
+            break;
+          case "message_stop":
+            break;
+        }
+      }
+      yield { type: "message:end" };
+      yield { type: "done" };
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "ANTHROPIC_ERROR"
+      };
+    }
+  }
+};
+function createAnthropicAdapter(config) {
+  return new AnthropicAdapter(config);
+}
+var GroqAdapter = class {
+  constructor(config) {
+    this.provider = "groq";
+    this.config = config;
+    this.model = config.model || "llama-3.1-70b-versatile";
+  }
+  async *stream(request) {
+    const messages = formatMessages(request.messages, request.systemPrompt);
+    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
+    const messageId = core.generateMessageId();
+    yield { type: "message:start", id: messageId };
+    try {
+      const response = await fetch(
+        "https://api.groq.com/openai/v1/chat/completions",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.config.apiKey}`
+          },
+          body: JSON.stringify({
+            model: request.config?.model || this.model,
+            messages,
+            tools,
+            temperature: request.config?.temperature ?? this.config.temperature,
+            max_tokens: request.config?.maxTokens ?? this.config.maxTokens,
+            stream: true
+          }),
+          signal: request.signal
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`Groq API error: ${response.status}`);
+      }
+      if (!response.body) {
+        throw new Error("No response body");
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let currentToolCall = null;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") continue;
+          try {
+            const chunk = JSON.parse(data);
+            const delta = chunk.choices?.[0]?.delta;
+            if (delta?.content) {
+              yield { type: "message:delta", content: delta.content };
+            }
+            if (delta?.tool_calls) {
+              for (const toolCall of delta.tool_calls) {
+                if (toolCall.id) {
+                  if (currentToolCall) {
+                    yield {
+                      type: "action:args",
+                      id: currentToolCall.id,
+                      args: currentToolCall.arguments
+                    };
+                  }
+                  currentToolCall = {
+                    id: toolCall.id,
+                    name: toolCall.function?.name || "",
+                    arguments: toolCall.function?.arguments || ""
+                  };
+                  yield {
+                    type: "action:start",
+                    id: currentToolCall.id,
+                    name: currentToolCall.name
+                  };
+                } else if (currentToolCall && toolCall.function?.arguments) {
+                  currentToolCall.arguments += toolCall.function.arguments;
+                }
+              }
+            }
+            if (chunk.choices?.[0]?.finish_reason && currentToolCall) {
+              yield {
+                type: "action:args",
+                id: currentToolCall.id,
+                args: currentToolCall.arguments
+              };
+            }
+          } catch {
+          }
+        }
+      }
+      yield { type: "message:end" };
+      yield { type: "done" };
+    } catch (error) {
+      if (error.name === "AbortError") {
+        yield { type: "done" };
+      } else {
+        yield {
+          type: "error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          code: "GROQ_ERROR"
+        };
+      }
+    }
+  }
+};
+function createGroqAdapter(config) {
+  return new GroqAdapter(config);
+}
+var OllamaAdapter = class {
+  constructor(config = {}) {
+    this.provider = "ollama";
+    this.config = config;
+    this.model = config.model || "llama3";
+    this.baseUrl = config.baseUrl || "http://localhost:11434";
+  }
+  async *stream(request) {
+    const messages = formatMessages(request.messages, request.systemPrompt);
+    const messageId = core.generateMessageId();
+    yield { type: "message:start", id: messageId };
+    try {
+      const response = await fetch(`${this.baseUrl}/api/chat`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: request.config?.model || this.model,
+          messages,
+          stream: true,
+          options: {
+            temperature: request.config?.temperature ?? this.config.temperature,
+            num_predict: request.config?.maxTokens ?? this.config.maxTokens
+          }
+        }),
+        signal: request.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Ollama API error: ${response.status}`);
+      }
+      if (!response.body) {
+        throw new Error("No response body");
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const chunk = JSON.parse(line);
+            if (chunk.message?.content) {
+              yield { type: "message:delta", content: chunk.message.content };
+            }
+            if (chunk.done) {
+              break;
+            }
+          } catch {
+          }
+        }
+      }
+      yield { type: "message:end" };
+      yield { type: "done" };
+    } catch (error) {
+      if (error.name === "AbortError") {
+        yield { type: "done" };
+      } else {
+        yield {
+          type: "error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          code: "OLLAMA_ERROR"
+        };
+      }
+    }
+  }
+};
+function createOllamaAdapter(config) {
+  return new OllamaAdapter(config);
+}
+function attachmentToGeminiPart(attachment) {
+  if (!attachment.data) {
+    console.warn(
+      "Gemini adapter: URL-based attachments not supported, skipping"
+    );
+    return null;
+  }
+  if (attachment.type === "image") {
+    let base64Data = attachment.data;
+    if (base64Data.startsWith("data:")) {
+      const commaIndex = base64Data.indexOf(",");
+      if (commaIndex !== -1) {
+        base64Data = base64Data.slice(commaIndex + 1);
+      }
+    }
+    return {
+      inlineData: {
+        mimeType: attachment.mimeType || "image/png",
+        data: base64Data
+      }
+    };
+  }
+  if (attachment.type === "audio" || attachment.type === "video") {
+    let base64Data = attachment.data;
+    if (base64Data.startsWith("data:")) {
+      const commaIndex = base64Data.indexOf(",");
+      if (commaIndex !== -1) {
+        base64Data = base64Data.slice(commaIndex + 1);
+      }
+    }
+    return {
+      inlineData: {
+        mimeType: attachment.mimeType || (attachment.type === "audio" ? "audio/mp3" : "video/mp4"),
+        data: base64Data
+      }
+    };
+  }
+  return null;
+}
+function messageToGeminiContent(msg) {
+  if (msg.role === "system") return null;
+  const parts = [];
+  if (msg.role === "tool" && msg.tool_call_id) {
+    let responseData;
+    try {
+      responseData = JSON.parse(msg.content || "{}");
+    } catch {
+      responseData = { result: msg.content || "" };
+    }
+    const toolName = msg.metadata?.toolName || "tool";
+    parts.push({
+      functionResponse: {
+        name: toolName,
+        response: responseData
+      }
+    });
+    return { role: "user", parts };
+  }
+  if (msg.content) {
+    parts.push({ text: msg.content });
+  }
+  const attachments = msg.metadata?.attachments;
+  if (attachments && Array.isArray(attachments)) {
+    for (const attachment of attachments) {
+      const part = attachmentToGeminiPart(attachment);
+      if (part) {
+        parts.push(part);
+      }
+    }
+  }
+  if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
+    for (const tc of msg.tool_calls) {
+      let args = {};
+      try {
+        args = JSON.parse(tc.function.arguments);
+      } catch {
+      }
+      parts.push({
+        functionCall: {
+          name: tc.function.name,
+          args
+        }
+      });
+    }
+  }
+  if (parts.length === 0) return null;
+  return {
+    role: msg.role === "assistant" ? "model" : "user",
+    parts
+  };
+}
+function formatToolsForGemini(actions) {
+  if (!actions || actions.length === 0) return void 0;
+  return {
+    functionDeclarations: actions.map((action) => ({
+      name: action.name,
+      description: action.description,
+      parameters: action.parameters ? {
+        type: "object",
+        properties: Object.fromEntries(
+          Object.entries(action.parameters).map(([key, param]) => [
+            key,
+            {
+              type: param.type,
+              description: param.description,
+              enum: param.enum
+            }
+          ])
+        ),
+        required: Object.entries(action.parameters).filter(([, param]) => param.required).map(([key]) => key)
+      } : void 0
+    }))
+  };
+}
+var GoogleAdapter = class {
+  constructor(config) {
+    this.provider = "google";
+    this.config = config;
+    this.model = config.model || "gemini-2.0-flash";
+  }
+  async getClient() {
+    if (!this.client) {
+      const { GoogleGenerativeAI } = await import('@google/generative-ai');
+      this.client = new GoogleGenerativeAI(this.config.apiKey);
+    }
+    return this.client;
+  }
+  async *stream(request) {
+    const client = await this.getClient();
+    const modelId = request.config?.model || this.model;
+    const model = client.getGenerativeModel({
+      model: modelId,
+      safetySettings: this.config.safetySettings
+    });
+    let contents = [];
+    let systemInstruction;
+    if (request.rawMessages && request.rawMessages.length > 0) {
+      for (const msg of request.rawMessages) {
+        if (msg.role === "system") {
+          systemInstruction = (systemInstruction || "") + (msg.content || "");
+          continue;
+        }
+        const content = messageToGeminiContent(msg);
+        if (content) {
+          contents.push(content);
+        }
+      }
+      if (request.systemPrompt && !systemInstruction) {
+        systemInstruction = request.systemPrompt;
+      }
+    } else {
+      for (const msg of request.messages) {
+        if (msg.role === "system") {
+          systemInstruction = (systemInstruction || "") + (msg.content || "");
+          continue;
+        }
+        const content = messageToGeminiContent(msg);
+        if (content) {
+          contents.push(content);
+        }
+      }
+      if (request.systemPrompt) {
+        systemInstruction = request.systemPrompt;
+      }
+    }
+    if (contents.length === 0 || contents[0].role !== "user") {
+      contents = [{ role: "user", parts: [{ text: "" }] }, ...contents];
+    }
+    const mergedContents = [];
+    for (const content of contents) {
+      const last = mergedContents[mergedContents.length - 1];
+      if (last && last.role === content.role) {
+        last.parts.push(...content.parts);
+      } else {
+        mergedContents.push({ ...content, parts: [...content.parts] });
+      }
+    }
+    const tools = formatToolsForGemini(request.actions);
+    const messageId = core.generateMessageId();
+    yield { type: "message:start", id: messageId };
+    try {
+      const chat = model.startChat({
+        history: mergedContents.slice(0, -1),
+        // All but the last message
+        systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,
+        tools: tools ? [tools] : void 0,
+        generationConfig: {
+          temperature: request.config?.temperature ?? this.config.temperature,
+          maxOutputTokens: request.config?.maxTokens ?? this.config.maxTokens
+        }
+      });
+      const lastMessage = mergedContents[mergedContents.length - 1];
+      const result = await chat.sendMessageStream(lastMessage.parts);
+      let currentToolCall = null;
+      for await (const chunk of result.stream) {
+        if (request.signal?.aborted) {
+          break;
+        }
+        const candidate = chunk.candidates?.[0];
+        if (!candidate?.content?.parts) continue;
+        for (const part of candidate.content.parts) {
+          if ("text" in part && part.text) {
+            yield { type: "message:delta", content: part.text };
+          }
+          if ("functionCall" in part && part.functionCall) {
+            const fc = part.functionCall;
+            const toolId = core.generateToolCallId();
+            if (currentToolCall) {
+              yield {
+                type: "action:args",
+                id: currentToolCall.id,
+                args: JSON.stringify(currentToolCall.args)
+              };
+            }
+            currentToolCall = {
+              id: toolId,
+              name: fc.name,
+              args: fc.args || {}
+            };
+            yield {
+              type: "action:start",
+              id: toolId,
+              name: fc.name
+            };
+          }
+        }
+        if (candidate.finishReason) {
+          if (currentToolCall) {
+            yield {
+              type: "action:args",
+              id: currentToolCall.id,
+              args: JSON.stringify(currentToolCall.args)
+            };
+          }
+        }
+      }
+      yield { type: "message:end" };
+      yield { type: "done" };
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "GOOGLE_ERROR"
+      };
+    }
+  }
+  /**
+   * Non-streaming completion (optional, for debugging)
+   */
+  async complete(request) {
+    const client = await this.getClient();
+    const modelId = request.config?.model || this.model;
+    const model = client.getGenerativeModel({
+      model: modelId,
+      safetySettings: this.config.safetySettings
+    });
+    let contents = [];
+    let systemInstruction;
+    for (const msg of request.messages) {
+      if (msg.role === "system") {
+        systemInstruction = (systemInstruction || "") + (msg.content || "");
+        continue;
+      }
+      const content = messageToGeminiContent(msg);
+      if (content) {
+        contents.push(content);
+      }
+    }
+    if (request.systemPrompt) {
+      systemInstruction = request.systemPrompt;
+    }
+    if (contents.length === 0 || contents[0].role !== "user") {
+      contents = [{ role: "user", parts: [{ text: "" }] }, ...contents];
+    }
+    const mergedContents = [];
+    for (const content of contents) {
+      const last = mergedContents[mergedContents.length - 1];
+      if (last && last.role === content.role) {
+        last.parts.push(...content.parts);
+      } else {
+        mergedContents.push({ ...content, parts: [...content.parts] });
+      }
+    }
+    const tools = formatToolsForGemini(request.actions);
+    const chat = model.startChat({
+      history: mergedContents.slice(0, -1),
+      systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,
+      tools: tools ? [tools] : void 0,
+      generationConfig: {
+        temperature: request.config?.temperature ?? this.config.temperature,
+        maxOutputTokens: request.config?.maxTokens ?? this.config.maxTokens
+      }
+    });
+    const lastMessage = mergedContents[mergedContents.length - 1];
+    const result = await chat.sendMessage(lastMessage.parts);
+    const response = result.response;
+    let textContent = "";
+    const toolCalls = [];
+    const candidate = response.candidates?.[0];
+    if (candidate?.content?.parts) {
+      for (const part of candidate.content.parts) {
+        if ("text" in part && part.text) {
+          textContent += part.text;
+        }
+        if ("functionCall" in part && part.functionCall) {
+          toolCalls.push({
+            id: core.generateToolCallId(),
+            name: part.functionCall.name,
+            args: part.functionCall.args || {}
+          });
+        }
+      }
+    }
+    return {
+      content: textContent,
+      toolCalls,
+      rawResponse: response
+    };
+  }
+};
+function createGoogleAdapter(config) {
+  return new GoogleAdapter(config);
+}
+var XAI_BASE_URL = "https://api.x.ai/v1";
+var XAIAdapter = class {
+  constructor(config) {
+    this.provider = "xai";
+    this.config = config;
+    this.model = config.model || "grok-2";
+  }
+  async getClient() {
+    if (!this.client) {
+      const { default: OpenAI } = await import('openai');
+      this.client = new OpenAI({
+        apiKey: this.config.apiKey,
+        baseURL: this.config.baseUrl || XAI_BASE_URL
+      });
+    }
+    return this.client;
+  }
+  async *stream(request) {
+    const client = await this.getClient();
+    let messages;
+    if (request.rawMessages && request.rawMessages.length > 0) {
+      const processedMessages = request.rawMessages.map((msg) => {
+        const hasAttachments = msg.attachments && Array.isArray(msg.attachments) && msg.attachments.length > 0;
+        if (hasAttachments) {
+          const content = [];
+          if (msg.content) {
+            content.push({ type: "text", text: msg.content });
+          }
+          for (const attachment of msg.attachments) {
+            if (attachment.type === "image") {
+              let imageUrl = attachment.data;
+              if (!imageUrl.startsWith("data:")) {
+                imageUrl = `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+              }
+              content.push({
+                type: "image_url",
+                image_url: { url: imageUrl, detail: "auto" }
+              });
+            }
+          }
+          return { ...msg, content, attachments: void 0 };
+        }
+        return msg;
+      });
+      if (request.systemPrompt) {
+        const hasSystem = processedMessages.some((m) => m.role === "system");
+        if (!hasSystem) {
+          messages = [
+            { role: "system", content: request.systemPrompt },
+            ...processedMessages
+          ];
+        } else {
+          messages = processedMessages;
+        }
+      } else {
+        messages = processedMessages;
+      }
+    } else {
+      messages = formatMessagesForOpenAI(
+        request.messages,
+        request.systemPrompt
+      );
+    }
+    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
+    const messageId = core.generateMessageId();
+    yield { type: "message:start", id: messageId };
+    try {
+      const stream = await client.chat.completions.create({
+        model: request.config?.model || this.model,
+        messages,
+        tools,
+        temperature: request.config?.temperature ?? this.config.temperature,
+        max_tokens: request.config?.maxTokens ?? this.config.maxTokens,
+        stream: true
+      });
+      let currentToolCall = null;
+      for await (const chunk of stream) {
+        if (request.signal?.aborted) {
+          break;
+        }
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+          yield { type: "message:delta", content: delta.content };
+        }
+        if (delta?.tool_calls) {
+          for (const toolCall of delta.tool_calls) {
+            if (toolCall.id) {
+              if (currentToolCall) {
+                yield {
+                  type: "action:args",
+                  id: currentToolCall.id,
+                  args: currentToolCall.arguments
+                };
+              }
+              currentToolCall = {
+                id: toolCall.id,
+                name: toolCall.function?.name || "",
+                arguments: toolCall.function?.arguments || ""
+              };
+              yield {
+                type: "action:start",
+                id: currentToolCall.id,
+                name: currentToolCall.name
+              };
+            } else if (currentToolCall && toolCall.function?.arguments) {
+              currentToolCall.arguments += toolCall.function.arguments;
+            }
+          }
+        }
+        if (chunk.choices[0]?.finish_reason) {
+          if (currentToolCall) {
+            yield {
+              type: "action:args",
+              id: currentToolCall.id,
+              args: currentToolCall.arguments
+            };
+          }
+        }
+      }
+      yield { type: "message:end" };
+      yield { type: "done" };
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "XAI_ERROR"
+      };
+    }
+  }
+  /**
+   * Non-streaming completion (optional, for debugging)
+   */
+  async complete(request) {
+    const client = await this.getClient();
+    let messages;
+    if (request.rawMessages && request.rawMessages.length > 0) {
+      messages = request.rawMessages;
+      if (request.systemPrompt) {
+        const hasSystem = messages.some((m) => m.role === "system");
+        if (!hasSystem) {
+          messages = [
+            { role: "system", content: request.systemPrompt },
+            ...messages
+          ];
+        }
+      }
+    } else {
+      messages = formatMessagesForOpenAI(
+        request.messages,
+        request.systemPrompt
+      );
+    }
+    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
+    const response = await client.chat.completions.create({
+      model: request.config?.model || this.model,
+      messages,
+      tools,
+      temperature: request.config?.temperature ?? this.config.temperature,
+      max_tokens: request.config?.maxTokens ?? this.config.maxTokens
+    });
+    const choice = response.choices[0];
+    const message = choice?.message;
+    const toolCalls = (message?.tool_calls || []).map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      args: JSON.parse(tc.function.arguments || "{}")
+    }));
+    return {
+      content: message?.content || "",
+      toolCalls,
+      rawResponse: response
+    };
+  }
+};
+function createXAIAdapter(config) {
+  return new XAIAdapter(config);
+}
+var DEFAULT_API_VERSION = "2024-08-01-preview";
+function buildAzureEndpoint(resourceName, deploymentName, apiVersion) {
+  return `https://${resourceName}.openai.azure.com/openai/deployments/${deploymentName}`;
+}
+var AzureAdapter = class {
+  constructor(config) {
+    this.provider = "azure";
+    this.config = config;
+    this.model = config.deploymentName;
+  }
+  async getClient() {
+    if (!this.client) {
+      const { AzureOpenAI } = await import('openai');
+      const apiVersion = this.config.apiVersion || DEFAULT_API_VERSION;
+      const endpoint = this.config.baseUrl || buildAzureEndpoint(
+        this.config.resourceName,
+        this.config.deploymentName);
+      this.client = new AzureOpenAI({
+        apiKey: this.config.apiKey,
+        endpoint,
+        apiVersion,
+        deployment: this.config.deploymentName
+      });
+    }
+    return this.client;
+  }
+  async *stream(request) {
+    const client = await this.getClient();
+    let messages;
+    if (request.rawMessages && request.rawMessages.length > 0) {
+      const processedMessages = request.rawMessages.map((msg) => {
+        const hasAttachments = msg.attachments && Array.isArray(msg.attachments) && msg.attachments.length > 0;
+        if (hasAttachments) {
+          const content = [];
+          if (msg.content) {
+            content.push({ type: "text", text: msg.content });
+          }
+          for (const attachment of msg.attachments) {
+            if (attachment.type === "image") {
+              let imageUrl = attachment.data;
+              if (!imageUrl.startsWith("data:")) {
+                imageUrl = `data:${attachment.mimeType || "image/png"};base64,${attachment.data}`;
+              }
+              content.push({
+                type: "image_url",
+                image_url: { url: imageUrl, detail: "auto" }
+              });
+            }
+          }
+          return { ...msg, content, attachments: void 0 };
+        }
+        return msg;
+      });
+      if (request.systemPrompt) {
+        const hasSystem = processedMessages.some((m) => m.role === "system");
+        if (!hasSystem) {
+          messages = [
+            { role: "system", content: request.systemPrompt },
+            ...processedMessages
+          ];
+        } else {
+          messages = processedMessages;
+        }
+      } else {
+        messages = processedMessages;
+      }
+    } else {
+      messages = formatMessagesForOpenAI(
+        request.messages,
+        request.systemPrompt
+      );
+    }
+    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
+    const messageId = core.generateMessageId();
+    yield { type: "message:start", id: messageId };
+    try {
+      const stream = await client.chat.completions.create({
+        // Azure uses deployment name, not model name
+        model: this.config.deploymentName,
+        messages,
+        tools,
+        temperature: request.config?.temperature ?? this.config.temperature,
+        max_tokens: request.config?.maxTokens ?? this.config.maxTokens,
+        stream: true
+      });
+      let currentToolCall = null;
+      for await (const chunk of stream) {
+        if (request.signal?.aborted) {
+          break;
+        }
+        const delta = chunk.choices[0]?.delta;
+        if (delta?.content) {
+          yield { type: "message:delta", content: delta.content };
+        }
+        if (delta?.tool_calls) {
+          for (const toolCall of delta.tool_calls) {
+            if (toolCall.id) {
+              if (currentToolCall) {
+                yield {
+                  type: "action:args",
+                  id: currentToolCall.id,
+                  args: currentToolCall.arguments
+                };
+              }
+              currentToolCall = {
+                id: toolCall.id,
+                name: toolCall.function?.name || "",
+                arguments: toolCall.function?.arguments || ""
+              };
+              yield {
+                type: "action:start",
+                id: currentToolCall.id,
+                name: currentToolCall.name
+              };
+            } else if (currentToolCall && toolCall.function?.arguments) {
+              currentToolCall.arguments += toolCall.function.arguments;
+            }
+          }
+        }
+        if (chunk.choices[0]?.finish_reason) {
+          if (currentToolCall) {
+            yield {
+              type: "action:args",
+              id: currentToolCall.id,
+              args: currentToolCall.arguments
+            };
+          }
+        }
+      }
+      yield { type: "message:end" };
+      yield { type: "done" };
+    } catch (error) {
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "AZURE_ERROR"
+      };
+    }
+  }
+  /**
+   * Non-streaming completion (optional, for debugging)
+   */
+  async complete(request) {
+    const client = await this.getClient();
+    let messages;
+    if (request.rawMessages && request.rawMessages.length > 0) {
+      messages = request.rawMessages;
+      if (request.systemPrompt) {
+        const hasSystem = messages.some((m) => m.role === "system");
+        if (!hasSystem) {
+          messages = [
+            { role: "system", content: request.systemPrompt },
+            ...messages
+          ];
+        }
+      }
+    } else {
+      messages = formatMessagesForOpenAI(
+        request.messages,
+        request.systemPrompt
+      );
+    }
+    const tools = request.actions?.length ? formatTools(request.actions) : void 0;
+    const response = await client.chat.completions.create({
+      model: this.config.deploymentName,
+      messages,
+      tools,
+      temperature: request.config?.temperature ?? this.config.temperature,
+      max_tokens: request.config?.maxTokens ?? this.config.maxTokens
+    });
+    const choice = response.choices[0];
+    const message = choice?.message;
+    const toolCalls = (message?.tool_calls || []).map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      args: JSON.parse(tc.function.arguments || "{}")
+    }));
+    return {
+      content: message?.content || "",
+      toolCalls,
+      rawResponse: response
+    };
+  }
+};
+function createAzureAdapter(config) {
+  return new AzureAdapter(config);
+}
+
+exports.AnthropicAdapter = AnthropicAdapter;
+exports.AzureAdapter = AzureAdapter;
+exports.GoogleAdapter = GoogleAdapter;
+exports.GroqAdapter = GroqAdapter;
+exports.OllamaAdapter = OllamaAdapter;
+exports.OpenAIAdapter = OpenAIAdapter;
+exports.XAIAdapter = XAIAdapter;
+exports.attachmentToAnthropicDocument = attachmentToAnthropicDocument;
+exports.attachmentToAnthropicImage = attachmentToAnthropicImage;
+exports.attachmentToOpenAIImage = attachmentToOpenAIImage;
+exports.createAnthropicAdapter = createAnthropicAdapter;
+exports.createAzureAdapter = createAzureAdapter;
+exports.createGoogleAdapter = createGoogleAdapter;
+exports.createGroqAdapter = createGroqAdapter;
+exports.createOllamaAdapter = createOllamaAdapter;
+exports.createOpenAIAdapter = createOpenAIAdapter;
+exports.createXAIAdapter = createXAIAdapter;
+exports.formatMessages = formatMessages;
+exports.formatMessagesForAnthropic = formatMessagesForAnthropic;
+exports.formatMessagesForOpenAI = formatMessagesForOpenAI;
+exports.formatTools = formatTools;
+exports.hasImageAttachments = hasImageAttachments;
+exports.hasMediaAttachments = hasMediaAttachments;
+exports.messageToAnthropicContent = messageToAnthropicContent;
+exports.messageToOpenAIContent = messageToOpenAIContent;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map