@yourgpt/llm-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,4216 @@
+'use strict';
+
+var core = require('@yourgpt/copilot-sdk/core');
+var hono = require('hono');
+var cors = require('hono/cors');
+
+// src/server/runtime.ts
+
+// 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: "",
+    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);
+      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);
+}
+
+// src/server/streaming.ts
+function createSSEHeaders() {
+  return {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache, no-transform",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no"
+  };
+}
+function formatSSEData(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+function createEventStream(generator) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const event of generator) {
+          const data = formatSSEData(event);
+          controller.enqueue(encoder.encode(data));
+        }
+      } catch (error) {
+        const errorEvent = {
+          type: "error",
+          message: error instanceof Error ? error.message : "Unknown error"
+        };
+        controller.enqueue(encoder.encode(formatSSEData(errorEvent)));
+      } finally {
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.close();
+      }
+    }
+  });
+}
+function createSSEResponse(generator) {
+  return new Response(createEventStream(generator), {
+    headers: createSSEHeaders()
+  });
+}
+
+// src/server/runtime.ts
+function buildToolResultForAI(tool, result, args) {
+  const typedResult = result;
+  const responseMode = typedResult?._aiResponseMode ?? tool?.aiResponseMode ?? "full";
+  if (typedResult?._aiContent && typedResult._aiContent.length > 0) {
+    return typedResult._aiContent;
+  }
+  let aiContext;
+  if (typedResult?._aiContext) {
+    aiContext = typedResult._aiContext;
+  } else if (tool?.aiContext) {
+    aiContext = typeof tool.aiContext === "function" ? tool.aiContext(typedResult, args) : tool.aiContext;
+  }
+  switch (responseMode) {
+    case "none":
+      return aiContext ?? "[Result displayed to user]";
+    case "brief":
+      return aiContext ?? `[Tool ${tool?.name ?? "unknown"} executed successfully]`;
+    case "full":
+    default:
+      const fullData = JSON.stringify(result);
+      return aiContext ? `${aiContext}
+
+Full data: ${fullData}` : fullData;
+  }
+}
+function serializeToolResultContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((item) => {
+    if (item.type === "image") {
+      return {
+        type: "image_url",
+        image_url: {
+          url: `data:${item.mediaType};base64,${item.data}`
+        }
+      };
+    }
+    return {
+      type: "text",
+      text: item.text
+    };
+  });
+}
+function extractHeaders(request) {
+  if (!request) return {};
+  const headers = {};
+  request.headers.forEach((value, key) => {
+    headers[key.toLowerCase()] = value;
+  });
+  return headers;
+}
+function buildToolContext(toolCallId, signal, threadId, httpRequest, toolContextData) {
+  const headers = extractHeaders(httpRequest);
+  return {
+    signal,
+    threadId,
+    toolCallId,
+    headers,
+    request: httpRequest ? {
+      method: httpRequest.method,
+      url: httpRequest.url,
+      headers
+    } : void 0,
+    data: toolContextData
+  };
+}
+var Runtime = class {
+  constructor(config) {
+    this.actions = /* @__PURE__ */ new Map();
+    this.tools = /* @__PURE__ */ new Map();
+    this.config = config;
+    if ("provider" in config && config.provider) {
+      this.adapter = config.provider.languageModel(config.model);
+    } else if ("adapter" in config && config.adapter) {
+      this.adapter = config.adapter;
+    } else {
+      this.adapter = this.createAdapter(config);
+    }
+    if (config.actions) {
+      for (const action of config.actions) {
+        this.actions.set(action.name, action);
+      }
+    }
+    if (config.tools) {
+      for (const tool of config.tools) {
+        this.tools.set(tool.name, tool);
+      }
+    }
+  }
+  /**
+   * Create LLM adapter based on config
+   */
+  createAdapter(config) {
+    if (!("llm" in config) || !config.llm) {
+      throw new Error(
+        "LLM configuration is required when adapter is not provided"
+      );
+    }
+    const { llm } = config;
+    switch (llm.provider) {
+      case "openai":
+        return createOpenAIAdapter({
+          apiKey: llm.apiKey,
+          model: llm.model,
+          baseUrl: llm.baseUrl,
+          temperature: llm.temperature,
+          maxTokens: llm.maxTokens
+        });
+      case "anthropic":
+        return createAnthropicAdapter({
+          apiKey: llm.apiKey,
+          model: llm.model,
+          temperature: llm.temperature,
+          maxTokens: llm.maxTokens
+        });
+      case "groq":
+        return createGroqAdapter({
+          apiKey: llm.apiKey,
+          model: llm.model,
+          temperature: llm.temperature,
+          maxTokens: llm.maxTokens
+        });
+      case "ollama":
+        return createOllamaAdapter({
+          model: llm.model,
+          baseUrl: llm.baseUrl,
+          temperature: llm.temperature,
+          maxTokens: llm.maxTokens
+        });
+      default:
+        return createOpenAIAdapter({
+          apiKey: llm.apiKey,
+          model: llm.model,
+          baseUrl: llm.baseUrl,
+          temperature: llm.temperature,
+          maxTokens: llm.maxTokens
+        });
+    }
+  }
+  /**
+   * Process a chat request and return streaming response
+   */
+  async *processChat(request, signal) {
+    const messages = request.messages.map(
+      (m, i) => core.createMessage({
+        id: `msg_${i}`,
+        role: m.role,
+        content: m.content
+      })
+    );
+    const allActions = [...this.actions.values()];
+    if (request.actions) {
+      for (const action of request.actions) {
+        if (!this.actions.has(action.name)) {
+          allActions.push({
+            name: action.name,
+            description: action.description,
+            parameters: action.parameters,
+            handler: async () => {
+              return { handled: false };
+            }
+          });
+        }
+      }
+    }
+    const completionRequest = {
+      messages,
+      actions: allActions.length > 0 ? allActions : void 0,
+      systemPrompt: request.systemPrompt || this.config.systemPrompt,
+      config: request.config,
+      signal
+    };
+    const stream = this.adapter.stream(completionRequest);
+    for await (const event of stream) {
+      if (event.type === "action:args") {
+        const action = this.actions.get(event.id);
+        if (action) {
+          try {
+            const args = JSON.parse(event.args);
+            const result = await action.handler(args);
+            yield {
+              type: "action:end",
+              id: event.id,
+              result
+            };
+          } catch (error) {
+            yield {
+              type: "action:end",
+              id: event.id,
+              error: error instanceof Error ? error.message : "Action failed"
+            };
+          }
+        } else {
+          yield event;
+        }
+      } else {
+        yield event;
+      }
+    }
+  }
+  /**
+   * Handle HTTP request (for use with any framework)
+   */
+  async handleRequest(request) {
+    try {
+      const body = await request.json();
+      if (this.config.debug) {
+        console.log("[Copilot SDK] Request:", JSON.stringify(body, null, 2));
+      }
+      const signal = request.signal;
+      const hasTools = body.tools && body.tools.length > 0 || this.tools.size > 0;
+      const useAgentLoop = hasTools || this.config.agentLoop?.enabled;
+      if (body.streaming === false) {
+        return this.handleNonStreamingRequest(
+          body,
+          signal,
+          useAgentLoop || false,
+          request
+        );
+      }
+      const generator = useAgentLoop ? this.processChatWithLoop(body, signal, void 0, void 0, request) : this.processChat(body, signal);
+      return createSSEResponse(generator);
+    } catch (error) {
+      console.error("[Copilot SDK] Error:", error);
+      return new Response(
+        JSON.stringify({
+          error: error instanceof Error ? error.message : "Unknown error"
+        }),
+        {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+  }
+  /**
+   * Handle non-streaming request - returns JSON instead of SSE
+   */
+  async handleNonStreamingRequest(body, signal, useAgentLoop, httpRequest) {
+    try {
+      const generator = useAgentLoop ? this.processChatWithLoop(
+        body,
+        signal,
+        void 0,
+        void 0,
+        httpRequest
+      ) : this.processChat(body, signal);
+      const events = [];
+      let content = "";
+      const toolCalls = [];
+      const toolResults = [];
+      let messages;
+      let requiresAction = false;
+      let error;
+      for await (const event of generator) {
+        events.push(event);
+        switch (event.type) {
+          case "message:delta":
+            content += event.content;
+            break;
+          case "action:start":
+            toolCalls.push({ id: event.id, name: event.name, args: {} });
+            break;
+          case "action:args":
+            const tc = toolCalls.find((t) => t.id === event.id);
+            if (tc) {
+              try {
+                tc.args = JSON.parse(event.args || "{}");
+              } catch {
+                tc.args = {};
+              }
+            }
+            break;
+          case "action:end":
+            toolResults.push({
+              id: event.id,
+              result: event.result || event.error
+            });
+            break;
+          case "tool_calls":
+            break;
+          case "done":
+            messages = event.messages;
+            requiresAction = event.requiresAction || false;
+            break;
+          case "error":
+            error = { message: event.message, code: event.code };
+            break;
+        }
+      }
+      const response = {
+        success: !error,
+        content,
+        toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+        toolResults: toolResults.length > 0 ? toolResults : void 0,
+        messages,
+        requiresAction,
+        error,
+        // Include raw events for debugging
+        _events: this.config.debug ? events : void 0
+      };
+      console.log("[Copilot SDK] Non-streaming response:", {
+        contentLength: content.length,
+        toolCalls: toolCalls.length,
+        toolResults: toolResults.length,
+        messagesCount: messages?.length,
+        requiresAction,
+        hasError: !!error
+      });
+      return new Response(JSON.stringify(response), {
+        status: error ? 500 : 200,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*"
+        }
+      });
+    } catch (err) {
+      console.error("[Copilot SDK] Non-streaming error:", err);
+      return new Response(
+        JSON.stringify({
+          success: false,
+          error: {
+            message: err instanceof Error ? err.message : "Unknown error"
+          }
+        }),
+        {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+  }
+  /**
+   * Get registered actions
+   */
+  getActions() {
+    return [...this.actions.values()];
+  }
+  /**
+   * Register a new action
+   */
+  registerAction(action) {
+    this.actions.set(action.name, action);
+  }
+  /**
+   * Unregister an action
+   */
+  unregisterAction(name) {
+    this.actions.delete(name);
+  }
+  /**
+   * Register a new tool
+   */
+  registerTool(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  /**
+   * Unregister a tool
+   */
+  unregisterTool(name) {
+    this.tools.delete(name);
+  }
+  /**
+   * Get registered tools
+   */
+  getTools() {
+    return [...this.tools.values()];
+  }
+  /**
+   * Get the AI provider name from config
+   */
+  getProviderName() {
+    if ("provider" in this.config && this.config.provider) {
+      return this.config.provider.name;
+    }
+    if ("llm" in this.config && this.config.llm) {
+      return this.config.llm.provider;
+    }
+    return "openai";
+  }
+  /**
+   * Get the AI provider instance (if using provider config)
+   */
+  getProvider() {
+    if ("provider" in this.config && this.config.provider) {
+      return this.config.provider;
+    }
+    return null;
+  }
+  /**
+   * Get the current model ID
+   */
+  getModel() {
+    if ("provider" in this.config && this.config.provider) {
+      return this.config.model;
+    }
+    if ("llm" in this.config && this.config.llm) {
+      return this.config.llm.model || "unknown";
+    }
+    return this.adapter.model;
+  }
+  /**
+   * Process a chat request with tool support (Vercel AI SDK pattern)
+   *
+   * This method:
+   * 1. Streams response from adapter
+   * 2. Detects tool calls from streaming events
+   * 3. Server-side tools are executed immediately
+   * 4. Client-side tool calls are yielded for client to execute
+   * 5. Loop continues until no more tool calls or max iterations reached
+   * 6. Returns all new messages in the done event for client to append
+   */
+  async *processChatWithLoop(request, signal, _accumulatedMessages, _isRecursive, _httpRequest) {
+    const debug = this.config.debug || this.config.agentLoop?.debug;
+    if (request.streaming === false) {
+      if (debug) {
+        console.log("[Copilot SDK] Using non-streaming mode");
+      }
+      for await (const event of this.processChatWithLoopNonStreaming(
+        request,
+        signal,
+        _accumulatedMessages,
+        _isRecursive,
+        _httpRequest
+      )) {
+        yield event;
+      }
+      return;
+    }
+    const newMessages = _accumulatedMessages || [];
+    this.config.agentLoop?.maxIterations || 20;
+    const allTools = [...this.tools.values()];
+    if (request.tools) {
+      for (const tool of request.tools) {
+        allTools.push({
+          name: tool.name,
+          description: tool.description,
+          location: "client",
+          inputSchema: tool.inputSchema
+        });
+      }
+    }
+    if (debug) {
+      console.log(
+        `[Copilot SDK] Processing chat with ${allTools.length} tools`
+      );
+      for (let i = 0; i < request.messages.length; i++) {
+        const msg = request.messages[i];
+        const hasAttachments = msg.attachments && msg.attachments.length > 0;
+        if (hasAttachments) {
+          console.log(
+            `[Copilot SDK] Message ${i} (${msg.role}) has ${msg.attachments.length} attachments:`,
+            msg.attachments.map((a) => ({
+              type: a.type,
+              mimeType: a.mimeType,
+              dataLength: a.data?.length || 0
+            }))
+          );
+        }
+      }
+    }
+    const systemPrompt = request.systemPrompt || this.config.systemPrompt || "";
+    let accumulatedText = "";
+    const toolCalls = [];
+    let currentToolCall = null;
+    const completionRequest = {
+      messages: [],
+      // Not used when rawMessages is provided
+      rawMessages: request.messages,
+      actions: this.convertToolsToActions(allTools),
+      systemPrompt,
+      config: request.config,
+      signal
+    };
+    const stream = this.adapter.stream(completionRequest);
+    for await (const event of stream) {
+      switch (event.type) {
+        case "message:start":
+        case "message:end":
+          yield event;
+          break;
+        case "message:delta":
+          accumulatedText += event.content;
+          yield event;
+          break;
+        case "action:start":
+          currentToolCall = { id: event.id, name: event.name, args: "" };
+          if (debug) {
+            console.log(`[Copilot SDK] Tool call started: ${event.name}`);
+          }
+          yield event;
+          break;
+        case "action:args":
+          if (currentToolCall) {
+            try {
+              const parsedArgs = JSON.parse(event.args || "{}");
+              if (debug) {
+                console.log(
+                  `[Copilot SDK] Tool args for ${currentToolCall.name}:`,
+                  parsedArgs
+                );
+              }
+              toolCalls.push({
+                id: currentToolCall.id,
+                name: currentToolCall.name,
+                args: parsedArgs
+              });
+            } catch (e) {
+              console.error(
+                "[Copilot SDK] Failed to parse tool args:",
+                event.args,
+                e
+              );
+              toolCalls.push({
+                id: currentToolCall.id,
+                name: currentToolCall.name,
+                args: {}
+              });
+            }
+            currentToolCall = null;
+          }
+          yield event;
+          break;
+        case "error":
+          yield event;
+          return;
+        // Exit on error
+        case "done":
+          break;
+        default:
+          yield event;
+      }
+    }
+    if (toolCalls.length > 0) {
+      if (debug) {
+        console.log(
+          `[Copilot SDK] Detected ${toolCalls.length} tool calls:`,
+          toolCalls.map((t) => t.name)
+        );
+      }
+      const serverToolCalls = [];
+      const clientToolCalls = [];
+      for (const tc of toolCalls) {
+        const tool = allTools.find((t) => t.name === tc.name);
+        if (tool?.location === "server" && tool.handler) {
+          serverToolCalls.push(tc);
+        } else {
+          clientToolCalls.push(tc);
+        }
+      }
+      const serverToolResults = [];
+      const toolContextData = "toolContext" in this.config ? this.config.toolContext : void 0;
+      for (const tc of serverToolCalls) {
+        const tool = allTools.find((t) => t.name === tc.name);
+        if (tool?.handler) {
+          if (debug) {
+            console.log(`[Copilot SDK] Executing server-side tool: ${tc.name}`);
+          }
+          const toolContext = buildToolContext(
+            tc.id,
+            signal,
+            request.threadId,
+            _httpRequest,
+            toolContextData
+          );
+          try {
+            const result = await tool.handler(tc.args, toolContext);
+            serverToolResults.push({
+              id: tc.id,
+              name: tc.name,
+              args: tc.args,
+              result,
+              tool
+            });
+            yield {
+              type: "action:end",
+              id: tc.id,
+              result
+            };
+          } catch (error) {
+            const errorResult = {
+              success: false,
+              error: error instanceof Error ? error.message : "Tool execution failed"
+            };
+            serverToolResults.push({
+              id: tc.id,
+              name: tc.name,
+              args: tc.args,
+              result: errorResult,
+              tool
+            });
+            yield {
+              type: "action:end",
+              id: tc.id,
+              error: error instanceof Error ? error.message : "Tool execution failed"
+            };
+          }
+        }
+      }
+      if (serverToolResults.length > 0) {
+        if (debug) {
+          console.log(
+            `[Copilot SDK] Server tools executed, continuing conversation...`
+          );
+        }
+        const assistantWithToolCalls = {
+          role: "assistant",
+          content: accumulatedText || null,
+          tool_calls: serverToolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.args)
+            }
+          }))
+        };
+        const toolResultMessages = serverToolResults.map(
+          (tr) => {
+            const aiContent = buildToolResultForAI(tr.tool, tr.result, tr.args);
+            const content = typeof aiContent === "string" ? aiContent : JSON.stringify(serializeToolResultContent(aiContent));
+            return {
+              role: "tool",
+              content,
+              tool_call_id: tr.id
+            };
+          }
+        );
+        newMessages.push(assistantWithToolCalls);
+        newMessages.push(...toolResultMessages);
+        const messagesWithResults = [
+          ...request.messages,
+          assistantWithToolCalls,
+          ...toolResultMessages
+        ];
+        const nextRequest = {
+          ...request,
+          messages: messagesWithResults
+        };
+        for await (const event of this.processChatWithLoop(
+          nextRequest,
+          signal,
+          newMessages,
+          true,
+          // Mark as recursive
+          _httpRequest
+        )) {
+          yield event;
+        }
+        return;
+      }
+      if (clientToolCalls.length > 0) {
+        const assistantMessage = {
+          role: "assistant",
+          content: accumulatedText || null,
+          tool_calls: clientToolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.args)
+            }
+          }))
+        };
+        newMessages.push(assistantMessage);
+        yield {
+          type: "tool_calls",
+          toolCalls: clientToolCalls,
+          assistantMessage
+        };
+        yield {
+          type: "done",
+          requiresAction: true,
+          messages: newMessages
+        };
+        return;
+      }
+    }
+    if (accumulatedText) {
+      newMessages.push({
+        role: "assistant",
+        content: accumulatedText
+      });
+    }
+    if (debug) {
+      console.log(
+        `[Copilot SDK] Stream complete, returning ${newMessages.length} new messages`
+      );
+    }
+    yield {
+      type: "done",
+      messages: newMessages.length > 0 ? newMessages : void 0
+    };
+  }
+  /**
+   * Non-streaming agent loop implementation
+   *
+   * Uses adapter.complete() instead of stream() for:
+   * - Better comparison with original studio-ai behavior
+   * - Easier debugging (full response at once)
+   * - More predictable retry behavior
+   */
+  async *processChatWithLoopNonStreaming(request, signal, _accumulatedMessages, _isRecursive, _httpRequest) {
+    const newMessages = _accumulatedMessages || [];
+    const debug = this.config.debug || this.config.agentLoop?.debug;
+    const maxIterations = this.config.agentLoop?.maxIterations || 20;
+    const allTools = [...this.tools.values()];
+    if (request.tools) {
+      for (const tool of request.tools) {
+        allTools.push({
+          name: tool.name,
+          description: tool.description,
+          location: "client",
+          inputSchema: tool.inputSchema
+        });
+      }
+    }
+    const systemPrompt = request.systemPrompt || this.config.systemPrompt || "";
+    let iteration = 0;
+    let conversationMessages = request.messages;
+    while (iteration < maxIterations) {
+      iteration++;
+      if (debug) {
+        console.log(`[Copilot SDK] Iteration ${iteration}/${maxIterations}`);
+      }
+      if (signal?.aborted) {
+        yield {
+          type: "error",
+          message: "Aborted",
+          code: "ABORTED"
+        };
+        return;
+      }
+      if (!this.adapter.complete) {
+        if (debug) {
+          console.log(
+            "[Copilot SDK] Adapter does not support non-streaming, falling back to streaming"
+          );
+        }
+        const streamingRequest = { ...request, streaming: true };
+        for await (const event of this.processChatWithLoop(
+          streamingRequest,
+          signal,
+          _accumulatedMessages,
+          _isRecursive,
+          _httpRequest
+        )) {
+          yield event;
+        }
+        return;
+      }
+      const completionRequest = {
+        messages: [],
+        rawMessages: conversationMessages,
+        actions: this.convertToolsToActions(allTools),
+        systemPrompt,
+        config: request.config,
+        signal
+      };
+      try {
+        const result = await this.adapter.complete(completionRequest);
+        if (debug) {
+          console.log(
+            `[Copilot SDK] Got response: ${result.content.length} chars, ${result.toolCalls.length} tool calls`
+          );
+        }
+        yield { type: "message:start", id: `msg_${Date.now()}` };
+        if (result.content) {
+          yield {
+            type: "message:delta",
+            content: result.content
+          };
+        }
+        yield { type: "message:end" };
+        if (result.toolCalls.length > 0) {
+          const serverToolCalls = [];
+          const clientToolCalls = [];
+          for (const tc of result.toolCalls) {
+            const tool = allTools.find((t) => t.name === tc.name);
+            if (tool?.location === "server" && tool.handler) {
+              serverToolCalls.push(tc);
+            } else {
+              clientToolCalls.push({
+                id: tc.id,
+                name: tc.name,
+                args: tc.args
+              });
+            }
+          }
+          for (const tc of result.toolCalls) {
+            yield {
+              type: "action:start",
+              id: tc.id,
+              name: tc.name
+            };
+            yield {
+              type: "action:args",
+              id: tc.id,
+              args: JSON.stringify(tc.args)
+            };
+          }
+          const serverToolResults = [];
+          const toolContextData = "toolContext" in this.config ? this.config.toolContext : void 0;
+          for (const tc of serverToolCalls) {
+            const tool = allTools.find((t) => t.name === tc.name);
+            if (tool?.handler) {
+              if (debug) {
+                console.log(`[Copilot SDK] Executing tool: ${tc.name}`);
+              }
+              const toolContext = buildToolContext(
+                tc.id,
+                signal,
+                request.threadId,
+                _httpRequest,
+                toolContextData
+              );
+              try {
+                const toolResult = await tool.handler(tc.args, toolContext);
+                serverToolResults.push({
+                  id: tc.id,
+                  name: tc.name,
+                  args: tc.args,
+                  result: toolResult,
+                  tool
+                });
+                yield {
+                  type: "action:end",
+                  id: tc.id,
+                  result: toolResult
+                };
+              } catch (error) {
+                const errorResult = {
+                  success: false,
+                  error: error instanceof Error ? error.message : "Tool execution failed"
+                };
+                serverToolResults.push({
+                  id: tc.id,
+                  name: tc.name,
+                  args: tc.args,
+                  result: errorResult,
+                  tool
+                });
+                yield {
+                  type: "action:end",
+                  id: tc.id,
+                  error: error instanceof Error ? error.message : "Tool execution failed"
+                };
+              }
+            }
+          }
+          if (serverToolResults.length > 0) {
+            const assistantWithToolCalls = {
+              role: "assistant",
+              content: result.content || null,
+              tool_calls: result.toolCalls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: {
+                  name: tc.name,
+                  arguments: JSON.stringify(tc.args)
+                }
+              }))
+            };
+            const toolResultMessages = serverToolResults.map((tr) => {
+              const aiContent = buildToolResultForAI(
+                tr.tool,
+                tr.result,
+                tr.args
+              );
+              const content = typeof aiContent === "string" ? aiContent : JSON.stringify(serializeToolResultContent(aiContent));
+              return {
+                role: "tool",
+                content,
+                tool_call_id: tr.id
+              };
+            });
+            newMessages.push(assistantWithToolCalls);
+            newMessages.push(...toolResultMessages);
+            conversationMessages = [
+              ...conversationMessages,
+              assistantWithToolCalls,
+              ...toolResultMessages
+            ];
+            continue;
+          }
+          if (clientToolCalls.length > 0) {
+            const assistantMessage = {
+              role: "assistant",
+              content: result.content || null,
+              tool_calls: clientToolCalls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: {
+                  name: tc.name,
+                  arguments: JSON.stringify(tc.args)
+                }
+              }))
+            };
+            newMessages.push(assistantMessage);
+            yield {
+              type: "tool_calls",
+              toolCalls: clientToolCalls,
+              assistantMessage
+            };
+            yield {
+              type: "done",
+              requiresAction: true,
+              messages: newMessages
+            };
+            return;
+          }
+        }
+        if (result.content) {
+          newMessages.push({
+            role: "assistant",
+            content: result.content
+          });
+        }
+        if (debug) {
+          console.log(`[Copilot SDK] Complete after ${iteration} iterations`);
+        }
+        yield {
+          type: "done",
+          messages: newMessages.length > 0 ? newMessages : void 0
+        };
+        return;
+      } catch (error) {
+        yield {
+          type: "error",
+          message: error instanceof Error ? error.message : "Unknown error",
+          code: "COMPLETION_ERROR"
+        };
+        return;
+      }
+    }
+    if (debug) {
+      console.log(`[Copilot SDK] Max iterations (${maxIterations}) reached`);
+    }
+    yield {
+      type: "done",
+      messages: newMessages.length > 0 ? newMessages : void 0
+    };
+  }
+  /**
+   * Convert tools to legacy action format (for adapter compatibility)
+   */
+  convertToolsToActions(tools) {
+    return tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: this.convertInputSchemaToParameters(tool.inputSchema),
+      handler: tool.handler || (async () => ({ handled: false }))
+    }));
+  }
+  /**
+   * Convert JSON Schema property to ActionParameter format recursively
+   */
+  convertSchemaProperty(prop) {
+    const p = prop;
+    const typeMap = {
+      string: "string",
+      number: "number",
+      integer: "number",
+      boolean: "boolean",
+      object: "object",
+      array: "array"
+    };
+    const result = {
+      type: typeMap[p.type || "string"] || "string"
+    };
+    if (p.description) {
+      result.description = p.description;
+    }
+    if (p.enum) {
+      result.enum = p.enum;
+    }
+    if (p.type === "array" && p.items) {
+      result.items = this.convertSchemaProperty(p.items);
+    }
+    if (p.type === "object" && p.properties) {
+      result.properties = Object.fromEntries(
+        Object.entries(p.properties).map(([key, val]) => [
+          key,
+          this.convertSchemaProperty(val)
+        ])
+      );
+    }
+    return result;
+  }
+  /**
+   * Convert JSON Schema to legacy parameters format
+   */
+  convertInputSchemaToParameters(schema) {
+    const parameters = {};
+    for (const [name, prop] of Object.entries(schema.properties)) {
+      const converted = this.convertSchemaProperty(prop);
+      parameters[name] = {
+        ...converted,
+        required: schema.required?.includes(name)
+      };
+    }
+    return parameters;
+  }
+};
+function createRuntime(config) {
+  return new Runtime(config);
+}
+function createHonoApp(runtime) {
+  const app = new hono.Hono();
+  app.use("*", cors.cors());
+  app.get("/", (c) => {
+    return c.json({ status: "ok", provider: "yourgpt-copilot" });
+  });
+  app.post("/", async (c) => {
+    const request = c.req.raw;
+    return runtime.handleRequest(request);
+  });
+  app.post("/chat", async (c) => {
+    const request = c.req.raw;
+    return runtime.handleRequest(request);
+  });
+  app.post("/chat/loop", async (c) => {
+    try {
+      const body = await c.req.json();
+      const signal = c.req.raw.signal;
+      const generator = runtime.processChatWithLoop(body, signal);
+      return createSSEResponse(generator);
+    } catch (error) {
+      return c.json(
+        { error: error instanceof Error ? error.message : "Unknown error" },
+        500
+      );
+    }
+  });
+  app.get("/actions", (c) => {
+    const actions = runtime.getActions().map((a) => ({
+      name: a.name,
+      description: a.description,
+      parameters: a.parameters
+    }));
+    return c.json({ actions });
+  });
+  app.get("/tools", (c) => {
+    const tools = runtime.getTools().map((t) => ({
+      name: t.name,
+      description: t.description,
+      location: t.location,
+      inputSchema: t.inputSchema
+    }));
+    return c.json({ tools });
+  });
+  app.get("/capabilities", (c) => {
+    const provider = runtime.getProvider();
+    const model = runtime.getModel();
+    if (provider) {
+      const capabilities = provider.getCapabilities(model);
+      return c.json({
+        provider: provider.name,
+        model,
+        capabilities,
+        supportedModels: provider.supportedModels
+      });
+    }
+    return c.json({
+      provider: "unknown",
+      model,
+      capabilities: {
+        supportsVision: false,
+        supportsTools: true,
+        supportsThinking: false,
+        supportsStreaming: true,
+        supportsPDF: false,
+        supportsAudio: false,
+        supportsVideo: false,
+        maxTokens: 8192,
+        supportedImageTypes: [],
+        supportsJsonMode: false,
+        supportsSystemMessages: true
+      },
+      supportedModels: []
+    });
+  });
+  return app;
+}
+function createNextHandler(config) {
+  const runtime = createRuntime(config);
+  return async function handler(request) {
+    return runtime.handleRequest(request);
+  };
+}
+function createExpressMiddleware(config) {
+  const runtime = createRuntime(config);
+  createHonoApp(runtime);
+  return async (req, res) => {
+    try {
+      const url = new URL(req.url, "http://localhost");
+      const request = new Request(url, {
+        method: req.method,
+        headers: req.headers,
+        body: req.method !== "GET" ? JSON.stringify(req.body) : void 0
+      });
+      const response = await runtime.handleRequest(request);
+      response.headers.forEach((value, key) => {
+        res.setHeader(key, value);
+      });
+      if (response.body) {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          res.write(decoder.decode(value));
+        }
+      }
+      res.end();
+    } catch (error) {
+      res.status(500).json({
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  };
+}
+function createNodeHandler(config) {
+  const runtime = createRuntime(config);
+  const app = createHonoApp(runtime);
+  return app.fetch;
+}
+
+// src/providers/registry.ts
+var providerFactories = /* @__PURE__ */ new Map();
+function registerProvider(name, factory) {
+  providerFactories.set(name, factory);
+}
+function getProvider(name, config) {
+  const factory = providerFactories.get(name);
+  if (!factory) {
+    return void 0;
+  }
+  return factory(config);
+}
+function hasProvider(name) {
+  return providerFactories.has(name);
+}
+function listProviders() {
+  return Array.from(providerFactories.keys());
+}
+function getAvailableProviders() {
+  const result = [];
+  for (const [name, factory] of providerFactories) {
+    try {
+      const provider = factory();
+      result.push({
+        name,
+        models: provider.supportedModels
+      });
+    } catch {
+      result.push({
+        name,
+        models: []
+      });
+    }
+  }
+  return result;
+}
+function getModelCapabilities(providerName, modelId) {
+  const provider = getProvider(providerName);
+  if (!provider) {
+    return void 0;
+  }
+  return provider.getCapabilities(modelId);
+}
+
+// src/providers/openai/index.ts
+var OPENAI_MODELS = {
+  // GPT-4o series
+  "gpt-4o": {
+    vision: true,
+    tools: true,
+    audio: true,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  "gpt-4o-mini": {
+    vision: true,
+    tools: true,
+    audio: false,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  "gpt-4o-2024-11-20": {
+    vision: true,
+    tools: true,
+    audio: true,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  "gpt-4o-2024-08-06": {
+    vision: true,
+    tools: true,
+    audio: false,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  // GPT-4 Turbo series
+  "gpt-4-turbo": {
+    vision: true,
+    tools: true,
+    audio: false,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  "gpt-4-turbo-preview": {
+    vision: false,
+    tools: true,
+    audio: false,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  // GPT-4 series
+  "gpt-4": {
+    vision: false,
+    tools: true,
+    audio: false,
+    jsonMode: false,
+    maxTokens: 8192
+  },
+  "gpt-4-32k": {
+    vision: false,
+    tools: true,
+    audio: false,
+    jsonMode: false,
+    maxTokens: 32768
+  },
+  // GPT-3.5 series
+  "gpt-3.5-turbo": {
+    vision: false,
+    tools: true,
+    audio: false,
+    jsonMode: true,
+    maxTokens: 16385
+  },
+  "gpt-3.5-turbo-16k": {
+    vision: false,
+    tools: true,
+    audio: false,
+    jsonMode: true,
+    maxTokens: 16385
+  },
+  // O1 reasoning series
+  o1: {
+    vision: true,
+    tools: false,
+    // O1 doesn't support tools yet
+    audio: false,
+    jsonMode: false,
+    maxTokens: 128e3
+  },
+  "o1-mini": {
+    vision: true,
+    tools: false,
+    audio: false,
+    jsonMode: false,
+    maxTokens: 128e3
+  },
+  "o1-preview": {
+    vision: true,
+    tools: false,
+    audio: false,
+    jsonMode: false,
+    maxTokens: 128e3
+  },
+  // O3 reasoning series
+  "o3-mini": {
+    vision: true,
+    tools: false,
+    audio: false,
+    jsonMode: false,
+    maxTokens: 128e3
+  }
+};
+function createOpenAI(config = {}) {
+  const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY ?? "";
+  return {
+    name: "openai",
+    supportedModels: Object.keys(OPENAI_MODELS),
+    languageModel(modelId) {
+      return createOpenAIAdapter({
+        apiKey,
+        model: modelId,
+        baseUrl: config.baseUrl
+      });
+    },
+    getCapabilities(modelId) {
+      const model = OPENAI_MODELS[modelId] ?? OPENAI_MODELS["gpt-4o"];
+      return {
+        supportsVision: model.vision,
+        supportsTools: model.tools,
+        supportsThinking: false,
+        // OpenAI doesn't have extended thinking
+        supportsStreaming: true,
+        supportsPDF: false,
+        // OpenAI doesn't support PDFs directly
+        supportsAudio: model.audio,
+        supportsVideo: false,
+        maxTokens: model.maxTokens,
+        supportedImageTypes: model.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : [],
+        supportedAudioTypes: model.audio ? ["audio/mp3", "audio/wav", "audio/webm"] : [],
+        supportsJsonMode: model.jsonMode,
+        supportsSystemMessages: true
+      };
+    }
+  };
+}
+
+// src/providers/anthropic/index.ts
+var ANTHROPIC_MODELS = {
+  // Claude 4 series (latest)
+  "claude-sonnet-4-20250514": {
+    vision: true,
+    tools: true,
+    thinking: true,
+    maxTokens: 64e3
+  },
+  "claude-opus-4-20250514": {
+    vision: true,
+    tools: true,
+    thinking: true,
+    maxTokens: 32e3
+  },
+  // Claude 3.5 series
+  "claude-3-5-sonnet-latest": {
+    vision: true,
+    tools: true,
+    thinking: true,
+    maxTokens: 2e5
+  },
+  "claude-3-5-sonnet-20241022": {
+    vision: true,
+    tools: true,
+    thinking: true,
+    maxTokens: 2e5
+  },
+  "claude-3-5-haiku-latest": {
+    vision: true,
+    tools: true,
+    thinking: false,
+    maxTokens: 2e5
+  },
+  "claude-3-5-haiku-20241022": {
+    vision: true,
+    tools: true,
+    thinking: false,
+    maxTokens: 2e5
+  },
+  // Claude 3 series
+  "claude-3-opus-latest": {
+    vision: true,
+    tools: true,
+    thinking: true,
+    maxTokens: 2e5
+  },
+  "claude-3-opus-20240229": {
+    vision: true,
+    tools: true,
+    thinking: true,
+    maxTokens: 2e5
+  },
+  "claude-3-sonnet-20240229": {
+    vision: true,
+    tools: true,
+    thinking: false,
+    maxTokens: 2e5
+  },
+  "claude-3-haiku-20240307": {
+    vision: true,
+    tools: true,
+    thinking: false,
+    maxTokens: 2e5
+  }
+};
+function createAnthropic(config = {}) {
+  const apiKey = config.apiKey ?? process.env.ANTHROPIC_API_KEY ?? "";
+  return {
+    name: "anthropic",
+    supportedModels: Object.keys(ANTHROPIC_MODELS),
+    languageModel(modelId) {
+      return createAnthropicAdapter({
+        apiKey,
+        model: modelId,
+        baseUrl: config.baseUrl,
+        thinking: config.thinkingBudget ? { type: "enabled", budgetTokens: config.thinkingBudget } : void 0
+      });
+    },
+    getCapabilities(modelId) {
+      const model = ANTHROPIC_MODELS[modelId] ?? ANTHROPIC_MODELS["claude-3-5-sonnet-latest"];
+      return {
+        supportsVision: model.vision,
+        supportsTools: model.tools,
+        supportsThinking: model.thinking,
+        supportsStreaming: true,
+        supportsPDF: true,
+        // Claude supports PDFs
+        supportsAudio: false,
+        supportsVideo: false,
+        maxTokens: model.maxTokens,
+        supportedImageTypes: [
+          "image/png",
+          "image/jpeg",
+          "image/gif",
+          "image/webp"
+        ],
+        supportsJsonMode: false,
+        // Anthropic doesn't have JSON mode
+        supportsSystemMessages: true
+      };
+    }
+  };
+}
+
+// src/providers/groq/index.ts
+var GROQ_MODELS = {
+  // Llama 3.3 series
+  "llama-3.3-70b-versatile": {
+    vision: false,
+    tools: true,
+    maxTokens: 32768
+  },
+  "llama-3.3-70b-specdec": {
+    vision: false,
+    tools: true,
+    maxTokens: 8192
+  },
+  // Llama 3.2 Vision series
+  "llama-3.2-90b-vision-preview": {
+    vision: true,
+    tools: true,
+    maxTokens: 8192
+  },
+  "llama-3.2-11b-vision-preview": {
+    vision: true,
+    tools: true,
+    maxTokens: 8192
+  },
+  // Llama 3.1 series
+  "llama-3.1-70b-versatile": {
+    vision: false,
+    tools: true,
+    maxTokens: 32768
+  },
+  "llama-3.1-8b-instant": {
+    vision: false,
+    tools: true,
+    maxTokens: 8192
+  },
+  // Mixtral series
+  "mixtral-8x7b-32768": {
+    vision: false,
+    tools: true,
+    maxTokens: 32768
+  },
+  // Gemma series
+  "gemma2-9b-it": {
+    vision: false,
+    tools: false,
+    maxTokens: 8192
+  },
+  // DeepSeek
+  "deepseek-r1-distill-llama-70b": {
+    vision: false,
+    tools: true,
+    maxTokens: 8192
+  }
+};
+function createGroq(config = {}) {
+  const apiKey = config.apiKey ?? process.env.GROQ_API_KEY ?? "";
+  return {
+    name: "groq",
+    supportedModels: Object.keys(GROQ_MODELS),
+    languageModel(modelId) {
+      return createGroqAdapter({
+        apiKey,
+        model: modelId
+      });
+    },
+    getCapabilities(modelId) {
+      const model = GROQ_MODELS[modelId] ?? GROQ_MODELS["llama-3.3-70b-versatile"];
+      return {
+        supportsVision: model.vision,
+        supportsTools: model.tools,
+        supportsThinking: false,
+        supportsStreaming: true,
+        supportsPDF: false,
+        supportsAudio: false,
+        supportsVideo: false,
+        maxTokens: model.maxTokens,
+        supportedImageTypes: model.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : [],
+        supportsJsonMode: true,
+        supportsSystemMessages: true
+      };
+    }
+  };
+}
+
+// src/providers/ollama/index.ts
+var OLLAMA_MODELS = {
+  // Llama series
+  llama3: {
+    vision: false,
+    tools: true,
+    maxTokens: 8192
+  },
+  "llama3:70b": {
+    vision: false,
+    tools: true,
+    maxTokens: 8192
+  },
+  "llama3.2": {
+    vision: false,
+    tools: true,
+    maxTokens: 8192
+  },
+  "llama3.2-vision": {
+    vision: true,
+    tools: true,
+    maxTokens: 8192
+  },
+  // Mistral series
+  mistral: {
+    vision: false,
+    tools: true,
+    maxTokens: 8192
+  },
+  "mistral-nemo": {
+    vision: false,
+    tools: true,
+    maxTokens: 128e3
+  },
+  mixtral: {
+    vision: false,
+    tools: true,
+    maxTokens: 32768
+  },
+  // CodeLlama
+  codellama: {
+    vision: false,
+    tools: false,
+    maxTokens: 16384
+  },
+  // Phi series
+  phi3: {
+    vision: false,
+    tools: true,
+    maxTokens: 4096
+  },
+  "phi3:medium": {
+    vision: false,
+    tools: true,
+    maxTokens: 4096
+  },
+  // Gemma series
+  gemma2: {
+    vision: false,
+    tools: false,
+    maxTokens: 8192
+  },
+  "gemma2:27b": {
+    vision: false,
+    tools: false,
+    maxTokens: 8192
+  },
+  // Qwen series
+  qwen2: {
+    vision: false,
+    tools: true,
+    maxTokens: 32768
+  },
+  "qwen2.5-coder": {
+    vision: false,
+    tools: true,
+    maxTokens: 32768
+  },
+  // LLaVA (vision)
+  llava: {
+    vision: true,
+    tools: false,
+    maxTokens: 4096
+  },
+  // DeepSeek
+  deepseek: {
+    vision: false,
+    tools: true,
+    maxTokens: 16384
+  },
+  "deepseek-coder": {
+    vision: false,
+    tools: false,
+    maxTokens: 16384
+  }
+};
+var DEFAULT_MODEL_CAPS = {
+  vision: false,
+  tools: false,
+  maxTokens: 4096
+};
+function createOllama(config = {}) {
+  const baseUrl = config.baseUrl ?? "http://localhost:11434";
+  return {
+    name: "ollama",
+    supportedModels: Object.keys(OLLAMA_MODELS),
+    languageModel(modelId) {
+      return createOllamaAdapter({
+        model: modelId,
+        baseUrl
+      });
+    },
+    getCapabilities(modelId) {
+      const baseModelName = modelId.split(":")[0];
+      const model = OLLAMA_MODELS[modelId] ?? OLLAMA_MODELS[baseModelName] ?? DEFAULT_MODEL_CAPS;
+      return {
+        supportsVision: model.vision,
+        supportsTools: model.tools,
+        supportsThinking: false,
+        supportsStreaming: true,
+        supportsPDF: false,
+        supportsAudio: false,
+        supportsVideo: false,
+        maxTokens: model.maxTokens,
+        supportedImageTypes: model.vision ? ["image/png", "image/jpeg", "image/gif"] : [],
+        supportsJsonMode: false,
+        supportsSystemMessages: true
+      };
+    }
+  };
+}
+
+// src/providers/google/index.ts
+var GOOGLE_MODELS = {
+  // Gemini 2.0 series (latest)
+  "gemini-2.0-flash": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 8192
+  },
+  "gemini-2.0-flash-lite": {
+    vision: true,
+    tools: true,
+    audio: false,
+    video: false,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 8192
+  },
+  // Gemini 2.5 series (experimental)
+  "gemini-2.5-pro-preview-05-06": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 65536
+  },
+  "gemini-2.5-flash-preview-05-20": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 65536
+  },
+  // Gemini 1.5 series
+  "gemini-1.5-pro": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 2e6,
+    outputTokens: 8192
+  },
+  "gemini-1.5-pro-latest": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 2e6,
+    outputTokens: 8192
+  },
+  "gemini-1.5-flash": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 8192
+  },
+  "gemini-1.5-flash-latest": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 8192
+  },
+  "gemini-1.5-flash-8b": {
+    vision: true,
+    tools: true,
+    audio: false,
+    video: false,
+    pdf: true,
+    maxTokens: 1e6,
+    outputTokens: 8192
+  },
+  // Gemini 1.0 series (legacy)
+  "gemini-1.0-pro": {
+    vision: false,
+    tools: true,
+    audio: false,
+    video: false,
+    pdf: false,
+    maxTokens: 30720,
+    outputTokens: 2048
+  }
+};
+function createGoogle(config = {}) {
+  const apiKey = config.apiKey ?? process.env.GOOGLE_API_KEY ?? "";
+  return {
+    name: "google",
+    supportedModels: Object.keys(GOOGLE_MODELS),
+    languageModel(modelId) {
+      return createGoogleAdapter({
+        apiKey,
+        model: modelId,
+        baseUrl: config.baseUrl,
+        safetySettings: config.safetySettings
+      });
+    },
+    getCapabilities(modelId) {
+      const model = GOOGLE_MODELS[modelId] ?? GOOGLE_MODELS["gemini-2.0-flash"];
+      return {
+        supportsVision: model.vision,
+        supportsTools: model.tools,
+        supportsThinking: false,
+        // Gemini doesn't have extended thinking like Claude
+        supportsStreaming: true,
+        supportsPDF: model.pdf,
+        supportsAudio: model.audio,
+        supportsVideo: model.video,
+        maxTokens: model.maxTokens,
+        supportedImageTypes: model.vision ? [
+          "image/png",
+          "image/jpeg",
+          "image/gif",
+          "image/webp",
+          "image/heic",
+          "image/heif"
+        ] : [],
+        supportedAudioTypes: model.audio ? [
+          "audio/mp3",
+          "audio/wav",
+          "audio/aiff",
+          "audio/aac",
+          "audio/ogg",
+          "audio/flac"
+        ] : [],
+        supportedVideoTypes: model.video ? [
+          "video/mp4",
+          "video/mpeg",
+          "video/mov",
+          "video/avi",
+          "video/webm",
+          "video/mkv"
+        ] : [],
+        supportsJsonMode: true,
+        // Gemini supports JSON mode
+        supportsSystemMessages: true
+      };
+    }
+  };
+}
+
+// src/providers/xai/index.ts
+var XAI_MODELS = {
+  // Grok 2 series (latest)
+  "grok-2": {
+    vision: true,
+    tools: true,
+    maxTokens: 131072,
+    outputTokens: 4096
+  },
+  "grok-2-latest": {
+    vision: true,
+    tools: true,
+    maxTokens: 131072,
+    outputTokens: 4096
+  },
+  "grok-2-mini": {
+    vision: false,
+    tools: true,
+    maxTokens: 131072,
+    outputTokens: 4096
+  },
+  "grok-2-mini-latest": {
+    vision: false,
+    tools: true,
+    maxTokens: 131072,
+    outputTokens: 4096
+  },
+  // Grok Vision
+  "grok-2-vision": {
+    vision: true,
+    tools: true,
+    maxTokens: 32768,
+    outputTokens: 4096
+  },
+  "grok-2-vision-latest": {
+    vision: true,
+    tools: true,
+    maxTokens: 32768,
+    outputTokens: 4096
+  },
+  // Grok Beta (legacy)
+  "grok-beta": {
+    vision: false,
+    tools: true,
+    maxTokens: 131072,
+    outputTokens: 4096
+  },
+  "grok-vision-beta": {
+    vision: true,
+    tools: true,
+    maxTokens: 8192,
+    outputTokens: 4096
+  }
+};
+function createXAI(config = {}) {
+  const apiKey = config.apiKey ?? process.env.XAI_API_KEY ?? "";
+  return {
+    name: "xai",
+    supportedModels: Object.keys(XAI_MODELS),
+    languageModel(modelId) {
+      return createXAIAdapter({
+        apiKey,
+        model: modelId,
+        baseUrl: config.baseUrl
+      });
+    },
+    getCapabilities(modelId) {
+      const model = XAI_MODELS[modelId] ?? XAI_MODELS["grok-2"];
+      return {
+        supportsVision: model.vision,
+        supportsTools: model.tools,
+        supportsThinking: false,
+        supportsStreaming: true,
+        supportsPDF: false,
+        supportsAudio: false,
+        supportsVideo: false,
+        maxTokens: model.maxTokens,
+        supportedImageTypes: model.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : [],
+        supportsJsonMode: false,
+        // xAI doesn't support JSON mode yet
+        supportsSystemMessages: true
+      };
+    }
+  };
+}
+
+// src/providers/azure/index.ts
+function detectCapabilitiesFromDeployment(deploymentName) {
+  const name = deploymentName.toLowerCase();
+  if (name.includes("gpt-4o") || name.includes("gpt4o")) {
+    return { vision: true, tools: true, maxTokens: 128e3 };
+  }
+  if ((name.includes("gpt-4") || name.includes("gpt4")) && (name.includes("turbo") || name.includes("vision"))) {
+    return { vision: true, tools: true, maxTokens: 128e3 };
+  }
+  if (name.includes("gpt-4") || name.includes("gpt4")) {
+    return { vision: false, tools: true, maxTokens: 8192 };
+  }
+  if (name.includes("gpt-35") || name.includes("gpt-3.5") || name.includes("gpt35")) {
+    return { vision: false, tools: true, maxTokens: 16385 };
+  }
+  if (name.includes("o1")) {
+    return { vision: true, tools: false, maxTokens: 128e3 };
+  }
+  return { vision: false, tools: true, maxTokens: 8192 };
+}
+function createAzure(config) {
+  const apiKey = config.apiKey ?? process.env.AZURE_OPENAI_API_KEY ?? "";
+  const resourceName = config.resourceName ?? process.env.AZURE_OPENAI_RESOURCE ?? "";
+  const defaultDeployment = config.deploymentName ?? process.env.AZURE_OPENAI_DEPLOYMENT ?? "";
+  const supportedModels = defaultDeployment ? [defaultDeployment] : [];
+  return {
+    name: "azure",
+    supportedModels,
+    languageModel(deploymentName) {
+      return createAzureAdapter({
+        apiKey,
+        resourceName,
+        deploymentName: deploymentName || defaultDeployment,
+        apiVersion: config.apiVersion,
+        baseUrl: config.baseUrl
+      });
+    },
+    getCapabilities(deploymentName) {
+      const detected = detectCapabilitiesFromDeployment(
+        deploymentName || defaultDeployment
+      );
+      return {
+        supportsVision: detected.vision,
+        supportsTools: detected.tools,
+        supportsThinking: false,
+        supportsStreaming: true,
+        supportsPDF: false,
+        supportsAudio: false,
+        supportsVideo: false,
+        maxTokens: detected.maxTokens,
+        supportedImageTypes: detected.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : [],
+        supportsJsonMode: true,
+        supportsSystemMessages: true
+      };
+    }
+  };
+}
+
+// src/providers/openai.ts
+function transformTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }
+  }));
+}
+function parseToolCalls(response) {
+  const resp = response;
+  const choices = resp?.choices;
+  const message = choices?.[0]?.message;
+  const toolCalls = message?.tool_calls || [];
+  return toolCalls.map((tc) => {
+    let input = {};
+    try {
+      input = JSON.parse(tc.function.arguments);
+    } catch (e) {
+      console.error(
+        "Failed to parse tool arguments:",
+        tc.function.arguments,
+        e
+      );
+    }
+    return {
+      id: tc.id,
+      name: tc.function.name,
+      input
+    };
+  });
+}
+function extractTextContent(response) {
+  const resp = response;
+  const choices = resp?.choices;
+  const message = choices?.[0]?.message;
+  return message?.content || "";
+}
+function formatToolResults(results) {
+  return results.map((r) => ({
+    role: "tool",
+    tool_call_id: r.toolCallId,
+    content: r.content
+  }));
+}
+function isToolUseStop(response) {
+  const resp = response;
+  const choices = resp?.choices;
+  return choices?.[0]?.finish_reason === "tool_calls";
+}
+function isEndTurnStop(response) {
+  const resp = response;
+  const choices = resp?.choices;
+  return choices?.[0]?.finish_reason === "stop";
+}
+function getStopReason(response) {
+  const resp = response;
+  const choices = resp?.choices;
+  return choices?.[0]?.finish_reason || "unknown";
+}
+function buildAssistantToolMessage(toolCalls, textContent) {
+  return {
+    role: "assistant",
+    content: textContent || null,
+    tool_calls: toolCalls.map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: {
+        name: tc.name,
+        arguments: JSON.stringify(tc.input)
+      }
+    }))
+  };
+}
+function buildToolResultMessage(results) {
+  return formatToolResults(results);
+}
+var openaiFormatter = {
+  transformTools,
+  parseToolCalls,
+  formatToolResults,
+  isToolUseStop,
+  isEndTurnStop,
+  getStopReason,
+  extractTextContent,
+  buildAssistantToolMessage,
+  buildToolResultMessage
+};
+
+// src/providers/anthropic.ts
+function transformTools2(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.inputSchema
+  }));
+}
+function parseToolCalls2(response) {
+  const content = Array.isArray(response) ? response : response?.content;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content.filter((block) => block?.type === "tool_use").map((block) => ({
+    id: block.id,
+    name: block.name,
+    input: block.input || {}
+  }));
+}
+function extractTextContent2(response) {
+  const content = Array.isArray(response) ? response : response?.content;
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.filter((block) => block?.type === "text").map((block) => block.text || "").join("\n");
+}
+function formatToolResults2(results) {
+  return results.map((r) => ({
+    type: "tool_result",
+    tool_use_id: r.toolCallId,
+    content: r.content
+  }));
+}
+function isToolUseStop2(response) {
+  const resp = response;
+  return resp?.stop_reason === "tool_use";
+}
+function isEndTurnStop2(response) {
+  const resp = response;
+  const stopReason = resp?.stop_reason;
+  return stopReason === "end_turn" || stopReason === "stop";
+}
+function getStopReason2(response) {
+  const resp = response;
+  return resp?.stop_reason || "unknown";
+}
+function buildAssistantToolMessage2(toolCalls, textContent) {
+  const content = [];
+  if (textContent) {
+    content.push({ type: "text", text: textContent });
+  }
+  toolCalls.forEach((tc) => {
+    content.push({
+      type: "tool_use",
+      id: tc.id,
+      name: tc.name,
+      input: tc.input
+    });
+  });
+  return { role: "assistant", content };
+}
+function buildToolResultMessage2(results) {
+  return {
+    role: "user",
+    content: formatToolResults2(results)
+  };
+}
+var anthropicFormatter = {
+  transformTools: transformTools2,
+  parseToolCalls: parseToolCalls2,
+  formatToolResults: formatToolResults2,
+  isToolUseStop: isToolUseStop2,
+  isEndTurnStop: isEndTurnStop2,
+  getStopReason: getStopReason2,
+  extractTextContent: extractTextContent2,
+  buildAssistantToolMessage: buildAssistantToolMessage2,
+  buildToolResultMessage: buildToolResultMessage2
+};
+
+// src/providers/gemini.ts
+function transformTools3(tools) {
+  return [
+    {
+      functionDeclarations: tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema
+      }))
+    }
+  ];
+}
+function parseToolCalls3(response) {
+  const resp = response;
+  const candidates = resp?.candidates;
+  const content = candidates?.[0]?.content;
+  const parts = content?.parts;
+  if (!parts) return [];
+  const functionCalls = [];
+  for (const part of parts) {
+    const functionCall = part.functionCall;
+    if (functionCall) {
+      functionCalls.push({
+        id: `gemini_${Date.now()}_${functionCalls.length}`,
+        // Gemini doesn't provide IDs
+        name: functionCall.name,
+        input: functionCall.args || {}
+      });
+    }
+  }
+  return functionCalls;
+}
+function extractTextContent3(response) {
+  const resp = response;
+  const candidates = resp?.candidates;
+  const content = candidates?.[0]?.content;
+  const parts = content?.parts;
+  if (!parts) return "";
+  return parts.filter((part) => typeof part.text === "string").map((part) => part.text).join("\n");
+}
+function formatToolResults3(results) {
+  return results.map((r) => {
+    let response;
+    try {
+      response = JSON.parse(r.content);
+    } catch {
+      response = { result: r.content };
+    }
+    return {
+      name: r.toolCallId.split("_").slice(2).join("_") || "unknown",
+      // Extract name from ID
+      response
+    };
+  });
+}
+function isToolUseStop3(response) {
+  const resp = response;
+  const candidates = resp?.candidates;
+  const content = candidates?.[0]?.content;
+  const parts = content?.parts;
+  if (!parts) return false;
+  return parts.some((part) => part.functionCall !== void 0);
+}
+function isEndTurnStop3(response) {
+  const resp = response;
+  const candidates = resp?.candidates;
+  const finishReason = candidates?.[0]?.finishReason;
+  return finishReason === "STOP" || finishReason === "END_TURN";
+}
+function getStopReason3(response) {
+  const resp = response;
+  const candidates = resp?.candidates;
+  return candidates?.[0]?.finishReason || "unknown";
+}
+function buildAssistantToolMessage3(toolCalls, textContent) {
+  const parts = [];
+  if (textContent) {
+    parts.push({ text: textContent });
+  }
+  toolCalls.forEach((tc) => {
+    parts.push({
+      functionCall: {
+        name: tc.name,
+        args: tc.input
+      }
+    });
+  });
+  return {
+    role: "model",
+    parts
+  };
+}
+function buildToolResultMessage3(results) {
+  const parts = results.map((r) => {
+    let response;
+    try {
+      response = JSON.parse(r.content);
+    } catch {
+      response = { result: r.content };
+    }
+    return {
+      functionResponse: {
+        name: "tool",
+        // This should be the actual tool name
+        response
+      }
+    };
+  });
+  return {
+    role: "user",
+    parts
+  };
+}
+var geminiFormatter = {
+  transformTools: transformTools3,
+  parseToolCalls: parseToolCalls3,
+  formatToolResults: formatToolResults3,
+  isToolUseStop: isToolUseStop3,
+  isEndTurnStop: isEndTurnStop3,
+  getStopReason: getStopReason3,
+  extractTextContent: extractTextContent3,
+  buildAssistantToolMessage: buildAssistantToolMessage3,
+  buildToolResultMessage: buildToolResultMessage3
+};
+
+// src/providers/formatter-registry.ts
+var formatters = {
+  openai: openaiFormatter,
+  anthropic: anthropicFormatter,
+  google: geminiFormatter,
+  gemini: geminiFormatter,
+  // Alias
+  // OpenAI-compatible providers use openaiFormatter
+  groq: openaiFormatter,
+  ollama: openaiFormatter,
+  xai: openaiFormatter,
+  azure: openaiFormatter
+};
+function getFormatter(provider) {
+  const formatter = formatters[provider.toLowerCase()];
+  if (!formatter) {
+    throw new Error(
+      `Unsupported provider: ${provider}. Supported providers: ${Object.keys(formatters).join(", ")}`
+    );
+  }
+  return formatter;
+}
+function isProviderSupported(provider) {
+  return provider.toLowerCase() in formatters;
+}
+function getSupportedProviders() {
+  return Object.keys(formatters);
+}
+
+// src/providers/index.ts
+registerProvider("openai", (config) => createOpenAI(config));
+registerProvider("anthropic", (config) => createAnthropic(config));
+registerProvider("groq", (config) => createGroq(config));
+registerProvider("ollama", (config) => createOllama(config));
+registerProvider("google", (config) => createGoogle(config));
+registerProvider("xai", (config) => createXAI(config));
+registerProvider("azure", (config) => createAzure(config));
+
+// src/server/agent-loop.ts
+var DEFAULT_MAX_ITERATIONS = 20;
+async function* runAgentLoop(options) {
+  const {
+    messages,
+    tools,
+    systemPrompt,
+    provider,
+    signal,
+    config,
+    callLLM,
+    executeServerTool,
+    waitForClientToolResult
+  } = options;
+  const maxIterations = config?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const debug = config?.debug ?? false;
+  const formatter = getFormatter(provider);
+  const serverTools = tools.filter((t) => t.location === "server");
+  const clientTools = tools.filter((t) => t.location === "client");
+  const allTools = [...serverTools, ...clientTools];
+  const providerTools = formatter.transformTools(allTools);
+  const conversation = buildConversation(
+    messages,
+    systemPrompt
+  );
+  let iteration = 0;
+  if (debug) {
+    console.log("[AgentLoop] Starting with", {
+      messageCount: messages.length,
+      toolCount: allTools.length,
+      serverToolCount: serverTools.length,
+      clientToolCount: clientTools.length,
+      maxIterations
+    });
+  }
+  while (iteration < maxIterations) {
+    if (signal?.aborted) {
+      yield {
+        type: "loop:complete",
+        iterations: iteration,
+        aborted: true
+      };
+      return;
+    }
+    iteration++;
+    yield {
+      type: "loop:iteration",
+      iteration,
+      maxIterations
+    };
+    if (debug) {
+      console.log(`[AgentLoop] Iteration ${iteration}/${maxIterations}`);
+    }
+    try {
+      const response = await callLLM(conversation, providerTools);
+      const toolCalls = formatter.parseToolCalls(response);
+      const textContent = formatter.extractTextContent(response);
+      if (textContent) {
+        const messageId = core.generateMessageId();
+        yield { type: "message:start", id: messageId };
+        yield { type: "message:delta", content: textContent };
+        yield { type: "message:end" };
+      }
+      if (formatter.isToolUseStop(response) && toolCalls.length > 0) {
+        if (debug) {
+          console.log(
+            "[AgentLoop] Tool calls:",
+            toolCalls.map((tc) => tc.name)
+          );
+        }
+        const results = await executeToolCalls(
+          toolCalls,
+          tools,
+          executeServerTool,
+          waitForClientToolResult,
+          function* (event) {
+            yield event;
+          },
+          debug
+        );
+        for (const result of results) {
+          const toolCall = toolCalls.find((tc) => tc.id === result.toolCallId);
+          if (toolCall) {
+            yield {
+              type: "tool:result",
+              id: result.toolCallId,
+              name: toolCall.name,
+              result: JSON.parse(result.content)
+            };
+          }
+        }
+        const assistantMessage = formatter.buildAssistantToolMessage(
+          toolCalls,
+          textContent
+        );
+        conversation.push(assistantMessage);
+        const toolResultMessage = formatter.buildToolResultMessage(results);
+        if (Array.isArray(toolResultMessage)) {
+          conversation.push(...toolResultMessage);
+        } else {
+          conversation.push(toolResultMessage);
+        }
+        continue;
+      }
+      if (formatter.isEndTurnStop(response)) {
+        if (debug) {
+          console.log("[AgentLoop] End turn detected");
+        }
+        break;
+      }
+      const stopReason = formatter.getStopReason(response);
+      if (debug) {
+        console.log("[AgentLoop] Unknown stop reason:", stopReason);
+      }
+      break;
+    } catch (error) {
+      if (debug) {
+        console.error("[AgentLoop] Error:", error);
+      }
+      yield {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "AGENT_LOOP_ERROR"
+      };
+      break;
+    }
+  }
+  yield {
+    type: "loop:complete",
+    iterations: iteration,
+    maxIterationsReached: iteration >= maxIterations
+  };
+  yield { type: "done" };
+}
+function buildConversation(messages, systemPrompt) {
+  const conversation = [];
+  if (systemPrompt) {
+    conversation.push({
+      role: "system",
+      content: systemPrompt
+    });
+  }
+  for (const msg of messages) {
+    conversation.push({
+      role: msg.role,
+      content: msg.content
+    });
+  }
+  return conversation;
+}
+async function executeToolCalls(toolCalls, tools, executeServerTool, waitForClientToolResult, emitEvent, debug) {
+  const results = [];
+  for (const toolCall of toolCalls) {
+    const tool = tools.find((t) => t.name === toolCall.name);
+    if (!tool) {
+      if (debug) {
+        console.warn(`[AgentLoop] Unknown tool: ${toolCall.name}`);
+      }
+      results.push({
+        toolCallId: toolCall.id,
+        content: JSON.stringify({
+          success: false,
+          error: `Unknown tool: ${toolCall.name}`
+        }),
+        success: false,
+        error: `Unknown tool: ${toolCall.name}`
+      });
+      continue;
+    }
+    emitEvent?.({
+      type: "action:start",
+      id: toolCall.id,
+      name: toolCall.name
+    });
+    emitEvent?.({
+      type: "action:args",
+      id: toolCall.id,
+      args: JSON.stringify(toolCall.input)
+    });
+    try {
+      let response;
+      if (tool.location === "server") {
+        if (tool.handler) {
+          response = await tool.handler(toolCall.input);
+        } else if (executeServerTool) {
+          response = await executeServerTool(toolCall.name, toolCall.input);
+        } else {
+          response = {
+            success: false,
+            error: `No handler for server tool: ${toolCall.name}`
+          };
+        }
+      } else {
+        if (waitForClientToolResult) {
+          response = await waitForClientToolResult(
+            toolCall.id,
+            toolCall.name,
+            toolCall.input
+          );
+        } else {
+          response = {
+            success: false,
+            error: `No client tool handler for: ${toolCall.name}`
+          };
+        }
+      }
+      emitEvent?.({
+        type: "action:end",
+        id: toolCall.id,
+        name: toolCall.name,
+        result: response
+      });
+      results.push({
+        toolCallId: toolCall.id,
+        content: JSON.stringify(response),
+        success: response.success,
+        error: response.error
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Tool execution failed";
+      emitEvent?.({
+        type: "action:end",
+        id: toolCall.id,
+        name: toolCall.name,
+        error: errorMessage
+      });
+      results.push({
+        toolCallId: toolCall.id,
+        content: JSON.stringify({
+          success: false,
+          error: errorMessage
+        }),
+        success: false,
+        error: errorMessage
+      });
+    }
+  }
+  return results;
+}
+
+exports.AnthropicAdapter = AnthropicAdapter;
+exports.AzureAdapter = AzureAdapter;
+exports.DEFAULT_MAX_ITERATIONS = DEFAULT_MAX_ITERATIONS;
+exports.GoogleAdapter = GoogleAdapter;
+exports.GroqAdapter = GroqAdapter;
+exports.OllamaAdapter = OllamaAdapter;
+exports.OpenAIAdapter = OpenAIAdapter;
+exports.Runtime = Runtime;
+exports.XAIAdapter = XAIAdapter;
+exports.anthropicFormatter = anthropicFormatter;
+exports.createAnthropic = createAnthropic;
+exports.createAnthropicAdapter = createAnthropicAdapter;
+exports.createAzure = createAzure;
+exports.createAzureAdapter = createAzureAdapter;
+exports.createEventStream = createEventStream;
+exports.createExpressMiddleware = createExpressMiddleware;
+exports.createGoogle = createGoogle;
+exports.createGoogleAdapter = createGoogleAdapter;
+exports.createGroq = createGroq;
+exports.createGroqAdapter = createGroqAdapter;
+exports.createHonoApp = createHonoApp;
+exports.createNextHandler = createNextHandler;
+exports.createNodeHandler = createNodeHandler;
+exports.createOllama = createOllama;
+exports.createOllamaAdapter = createOllamaAdapter;
+exports.createOpenAI = createOpenAI;
+exports.createOpenAIAdapter = createOpenAIAdapter;
+exports.createRuntime = createRuntime;
+exports.createSSEHeaders = createSSEHeaders;
+exports.createSSEResponse = createSSEResponse;
+exports.createXAI = createXAI;
+exports.createXAIAdapter = createXAIAdapter;
+exports.formatSSEData = formatSSEData;
+exports.geminiFormatter = geminiFormatter;
+exports.getAvailableProviders = getAvailableProviders;
+exports.getFormatter = getFormatter;
+exports.getModelCapabilities = getModelCapabilities;
+exports.getProvider = getProvider;
+exports.getSupportedProviders = getSupportedProviders;
+exports.hasProvider = hasProvider;
+exports.isProviderSupported = isProviderSupported;
+exports.listProviders = listProviders;
+exports.openaiFormatter = openaiFormatter;
+exports.registerProvider = registerProvider;
+exports.runAgentLoop = runAgentLoop;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map