@yourgpt/llm-sdk 0.1.0 → 1.0.0

package/dist/index.js

@@ -4,7 +4,1694 @@ var core = require('@yourgpt/copilot-sdk/core');
 var hono = require('hono');
 var cors = require('hono/cors');
 
-// src/server/runtime.ts
+// src/core/tool.ts
+function tool(config) {
+  return {
+    description: config.description,
+    parameters: config.parameters,
+    execute: config.execute
+  };
+}
+function toolToJsonSchema(toolDef) {
+  const schema = zodToJsonSchema(toolDef.parameters);
+  return {
+    type: "object",
+    properties: schema.properties ?? {},
+    required: schema.required
+  };
+}
+function zodToJsonSchema(schema) {
+  const def = schema._def;
+  const typeName = def.typeName;
+  const description = def.description;
+  switch (typeName) {
+    case "ZodString":
+      return { type: "string", description };
+    case "ZodNumber":
+      return { type: "number", description };
+    case "ZodBoolean":
+      return { type: "boolean", description };
+    case "ZodEnum": {
+      const values = def.values;
+      return { type: "string", enum: values, description };
+    }
+    case "ZodArray": {
+      const innerType = def.type;
+      return {
+        type: "array",
+        items: zodToJsonSchema(innerType),
+        description
+      };
+    }
+    case "ZodObject": {
+      const shape = def.shape;
+      const shapeObj = shape();
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shapeObj)) {
+        properties[key] = zodToJsonSchema(value);
+        const valueDef = value._def;
+        const isOptional = valueDef.typeName === "ZodOptional" || valueDef.typeName === "ZodNullable" || valueDef.typeName === "ZodDefault";
+        if (!isOptional) {
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : void 0,
+        description
+      };
+    }
+    case "ZodOptional":
+    case "ZodNullable": {
+      const innerType = def.innerType;
+      return zodToJsonSchema(innerType);
+    }
+    case "ZodDefault": {
+      const innerType = def.innerType;
+      return zodToJsonSchema(innerType);
+    }
+    case "ZodLiteral": {
+      const value = def.value;
+      if (typeof value === "string") {
+        return { type: "string", enum: [value], description };
+      }
+      if (typeof value === "number") {
+        return { type: "number", enum: [value], description };
+      }
+      if (typeof value === "boolean") {
+        return { type: "boolean", enum: [value], description };
+      }
+      return { description };
+    }
+    case "ZodUnion": {
+      const options = def.options;
+      const stringLiterals = [];
+      for (const option of options) {
+        const optDef = option._def;
+        if (optDef.typeName === "ZodLiteral" && typeof optDef.value === "string") {
+          stringLiterals.push(optDef.value);
+        }
+      }
+      if (stringLiterals.length === options.length) {
+        return { type: "string", enum: stringLiterals, description };
+      }
+      return zodToJsonSchema(options[0]);
+    }
+    default:
+      return { type: "string", description };
+  }
+}
+function formatToolsForOpenAI(tools) {
+  return Object.entries(tools).map(([name, toolDef]) => ({
+    type: "function",
+    function: {
+      name,
+      description: toolDef.description,
+      parameters: toolToJsonSchema(toolDef)
+    }
+  }));
+}
+function formatToolsForAnthropic(tools) {
+  return Object.entries(tools).map(([name, toolDef]) => ({
+    name,
+    description: toolDef.description,
+    input_schema: toolToJsonSchema(toolDef)
+  }));
+}
+function formatToolsForGoogle(tools) {
+  return [
+    {
+      functionDeclarations: Object.entries(tools).map(([name, toolDef]) => ({
+        name,
+        description: toolDef.description,
+        parameters: toolToJsonSchema(toolDef)
+      }))
+    }
+  ];
+}
+
+// src/core/generate-text.ts
+async function generateText(params) {
+  const { model, tools, maxSteps = 1, signal } = params;
+  let messages = buildMessages(params);
+  const steps = [];
+  const allToolCalls = [];
+  const allToolResults = [];
+  for (let step = 0; step < maxSteps; step++) {
+    if (signal?.aborted) {
+      throw new Error("Generation aborted");
+    }
+    const formattedTools = tools ? formatToolsForProvider(tools, model.provider) : void 0;
+    const result = await model.doGenerate({
+      messages,
+      tools: formattedTools,
+      temperature: params.temperature,
+      maxTokens: params.maxTokens,
+      signal
+    });
+    const stepToolResults = [];
+    if (result.toolCalls && result.toolCalls.length > 0 && tools) {
+      allToolCalls.push(...result.toolCalls);
+      for (const call of result.toolCalls) {
+        const toolDef = tools[call.name];
+        if (!toolDef) {
+          const errorResult = {
+            toolCallId: call.id,
+            result: { error: `Tool not found: ${call.name}` }
+          };
+          stepToolResults.push(errorResult);
+          allToolResults.push(errorResult);
+          continue;
+        }
+        try {
+          const parsedArgs = toolDef.parameters.parse(call.args);
+          const toolResult = await toolDef.execute(parsedArgs, {
+            toolCallId: call.id,
+            abortSignal: signal,
+            messages
+          });
+          const result2 = {
+            toolCallId: call.id,
+            result: toolResult
+          };
+          stepToolResults.push(result2);
+          allToolResults.push(result2);
+        } catch (error) {
+          const errorResult = {
+            toolCallId: call.id,
+            result: {
+              error: error instanceof Error ? error.message : "Tool execution failed"
+            }
+          };
+          stepToolResults.push(errorResult);
+          allToolResults.push(errorResult);
+        }
+      }
+    }
+    steps.push({
+      text: result.text,
+      toolCalls: result.toolCalls,
+      toolResults: stepToolResults,
+      finishReason: result.finishReason,
+      usage: result.usage
+    });
+    if (!result.toolCalls || result.toolCalls.length === 0) {
+      break;
+    }
+    const assistantMessage = {
+      role: "assistant",
+      content: result.text || null,
+      toolCalls: result.toolCalls
+    };
+    messages = [...messages, assistantMessage];
+    for (const tr of stepToolResults) {
+      const toolMessage = {
+        role: "tool",
+        toolCallId: tr.toolCallId,
+        content: JSON.stringify(tr.result)
+      };
+      messages = [...messages, toolMessage];
+    }
+  }
+  const lastStep = steps[steps.length - 1];
+  return {
+    text: lastStep?.text ?? "",
+    usage: sumUsage(steps),
+    finishReason: lastStep?.finishReason ?? "stop",
+    steps,
+    toolCalls: allToolCalls,
+    toolResults: allToolResults,
+    response: {
+      messages
+    }
+  };
+}
+function buildMessages(params) {
+  const messages = [];
+  if (params.system) {
+    messages.push({ role: "system", content: params.system });
+  }
+  if (params.messages) {
+    messages.push(...params.messages);
+  }
+  if (params.prompt) {
+    messages.push({ role: "user", content: params.prompt });
+  }
+  return messages;
+}
+function formatToolsForProvider(tools, provider) {
+  switch (provider) {
+    case "anthropic":
+      return formatToolsForAnthropic(tools);
+    case "openai":
+    case "xai":
+    case "azure":
+    default:
+      return formatToolsForOpenAI(tools);
+  }
+}
+function sumUsage(steps) {
+  return steps.reduce(
+    (acc, step) => ({
+      promptTokens: acc.promptTokens + (step.usage?.promptTokens ?? 0),
+      completionTokens: acc.completionTokens + (step.usage?.completionTokens ?? 0),
+      totalTokens: acc.totalTokens + (step.usage?.totalTokens ?? 0)
+    }),
+    { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+  );
+}
+
+// src/core/stream-text.ts
+async function streamText(params) {
+  const { model, tools, maxSteps = 1, signal } = params;
+  let fullText = "";
+  let finalUsage = {
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0
+  };
+  let finalFinishReason = "stop";
+  async function* createFullStream() {
+    let messages = buildMessages2(params);
+    for (let step = 0; step < maxSteps; step++) {
+      yield { type: "step-start", step };
+      if (signal?.aborted) {
+        yield { type: "error", error: new Error("Stream aborted") };
+        return;
+      }
+      const formattedTools = tools ? formatToolsForProvider2(tools, model.provider) : void 0;
+      let stepText = "";
+      const toolCalls = [];
+      let stepFinishReason = "stop";
+      try {
+        for await (const chunk of model.doStream({
+          messages,
+          tools: formattedTools,
+          temperature: params.temperature,
+          maxTokens: params.maxTokens,
+          signal
+        })) {
+          switch (chunk.type) {
+            case "text-delta":
+              stepText += chunk.text;
+              fullText += chunk.text;
+              yield { type: "text-delta", text: chunk.text };
+              break;
+            case "tool-call":
+              toolCalls.push(chunk.toolCall);
+              yield {
+                type: "tool-call-complete",
+                toolCall: chunk.toolCall
+              };
+              break;
+            case "finish":
+              stepFinishReason = chunk.finishReason;
+              finalFinishReason = chunk.finishReason;
+              if (chunk.usage) {
+                finalUsage = {
+                  promptTokens: finalUsage.promptTokens + chunk.usage.promptTokens,
+                  completionTokens: finalUsage.completionTokens + chunk.usage.completionTokens,
+                  totalTokens: finalUsage.totalTokens + chunk.usage.totalTokens
+                };
+              }
+              break;
+            case "error":
+              yield { type: "error", error: chunk.error };
+              return;
+          }
+        }
+      } catch (error) {
+        yield {
+          type: "error",
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+        return;
+      }
+      yield { type: "step-finish", step, finishReason: stepFinishReason };
+      if (toolCalls.length === 0 || !tools) {
+        break;
+      }
+      const assistantMessage = {
+        role: "assistant",
+        content: stepText || null,
+        toolCalls
+      };
+      messages = [...messages, assistantMessage];
+      for (const call of toolCalls) {
+        const toolDef = tools[call.name];
+        if (!toolDef) {
+          const errorResult = { error: `Tool not found: ${call.name}` };
+          yield {
+            type: "tool-result",
+            toolCallId: call.id,
+            result: errorResult
+          };
+          messages = [
+            ...messages,
+            {
+              role: "tool",
+              toolCallId: call.id,
+              content: JSON.stringify(errorResult)
+            }
+          ];
+          continue;
+        }
+        try {
+          const parsedArgs = toolDef.parameters.parse(call.args);
+          const result = await toolDef.execute(parsedArgs, {
+            toolCallId: call.id,
+            abortSignal: signal,
+            messages
+          });
+          yield { type: "tool-result", toolCallId: call.id, result };
+          messages = [
+            ...messages,
+            {
+              role: "tool",
+              toolCallId: call.id,
+              content: JSON.stringify(result)
+            }
+          ];
+        } catch (error) {
+          const errorResult = {
+            error: error instanceof Error ? error.message : "Tool execution failed"
+          };
+          yield {
+            type: "tool-result",
+            toolCallId: call.id,
+            result: errorResult
+          };
+          messages = [
+            ...messages,
+            {
+              role: "tool",
+              toolCallId: call.id,
+              content: JSON.stringify(errorResult)
+            }
+          ];
+        }
+      }
+    }
+    yield {
+      type: "finish",
+      finishReason: finalFinishReason,
+      usage: finalUsage
+    };
+  }
+  async function* createTextStream() {
+    for await (const part of createFullStream()) {
+      if (part.type === "text-delta") {
+        yield part.text;
+      }
+    }
+  }
+  let textPromise;
+  let usagePromise;
+  let finishReasonPromise;
+  async function consumeStream() {
+    for await (const _ of createFullStream()) {
+    }
+  }
+  return {
+    textStream: createTextStream(),
+    fullStream: createFullStream(),
+    get text() {
+      if (!textPromise) {
+        textPromise = consumeStream().then(() => fullText);
+      }
+      return textPromise;
+    },
+    get usage() {
+      if (!usagePromise) {
+        usagePromise = consumeStream().then(() => finalUsage);
+      }
+      return usagePromise;
+    },
+    get finishReason() {
+      if (!finishReasonPromise) {
+        finishReasonPromise = consumeStream().then(() => finalFinishReason);
+      }
+      return finishReasonPromise;
+    },
+    toTextStreamResponse(options) {
+      const stream = createTextStreamReadable(createTextStream());
+      return new Response(stream, {
+        status: options?.status ?? 200,
+        headers: {
+          "Content-Type": "text/plain; charset=utf-8",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+          ...options?.headers
+        }
+      });
+    },
+    toDataStreamResponse(options) {
+      const stream = createDataStreamReadable(createFullStream());
+      return new Response(stream, {
+        status: options?.status ?? 200,
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+          ...options?.headers
+        }
+      });
+    }
+  };
+}
+function buildMessages2(params) {
+  const messages = [];
+  if (params.system) {
+    messages.push({ role: "system", content: params.system });
+  }
+  if (params.messages) {
+    messages.push(...params.messages);
+  }
+  if (params.prompt) {
+    messages.push({ role: "user", content: params.prompt });
+  }
+  return messages;
+}
+function formatToolsForProvider2(tools, provider) {
+  switch (provider) {
+    case "anthropic":
+      return formatToolsForAnthropic(tools);
+    case "openai":
+    case "xai":
+    case "azure":
+    default:
+      return formatToolsForOpenAI(tools);
+  }
+}
+function createTextStreamReadable(textStream) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const text of textStream) {
+          controller.enqueue(encoder.encode(text));
+        }
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+}
+function createDataStreamReadable(fullStream) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const part of fullStream) {
+          const data = JSON.stringify(part);
+          controller.enqueue(encoder.encode(`data: ${data}
+
+`));
+        }
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.close();
+      } catch (error) {
+        const errorData = JSON.stringify({
+          type: "error",
+          error: error instanceof Error ? error.message : String(error)
+        });
+        controller.enqueue(encoder.encode(`data: ${errorData}
+
+`));
+        controller.close();
+      }
+    }
+  });
+}
+
+// src/core/types.ts
+var DEFAULT_CAPABILITIES = {
+  supportsVision: false,
+  supportsTools: true,
+  supportsStreaming: true,
+  supportsJsonMode: false,
+  supportsThinking: false,
+  supportsPDF: false,
+  maxTokens: 8192,
+  supportedImageTypes: []
+};
+
+// src/providers/openai/provider.ts
+var OPENAI_MODELS = {
+  // GPT-4o series
+  "gpt-4o": { vision: true, tools: true, jsonMode: true, maxTokens: 128e3 },
+  "gpt-4o-mini": {
+    vision: true,
+    tools: true,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  "gpt-4o-2024-11-20": {
+    vision: true,
+    tools: true,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  "gpt-4o-2024-08-06": {
+    vision: true,
+    tools: true,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  // GPT-4 Turbo
+  "gpt-4-turbo": {
+    vision: true,
+    tools: true,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  "gpt-4-turbo-preview": {
+    vision: false,
+    tools: true,
+    jsonMode: true,
+    maxTokens: 128e3
+  },
+  // GPT-4
+  "gpt-4": { vision: false, tools: true, jsonMode: false, maxTokens: 8192 },
+  "gpt-4-32k": {
+    vision: false,
+    tools: true,
+    jsonMode: false,
+    maxTokens: 32768
+  },
+  // GPT-3.5
+  "gpt-3.5-turbo": {
+    vision: false,
+    tools: true,
+    jsonMode: true,
+    maxTokens: 16385
+  },
+  // O1 series (reasoning)
+  o1: { vision: true, tools: false, jsonMode: false, maxTokens: 128e3 },
+  "o1-mini": { vision: true, tools: false, jsonMode: false, maxTokens: 128e3 },
+  "o1-preview": {
+    vision: true,
+    tools: false,
+    jsonMode: false,
+    maxTokens: 128e3
+  },
+  // O3 series
+  "o3-mini": { vision: true, tools: false, jsonMode: false, maxTokens: 128e3 }
+};
+function openai(modelId, options = {}) {
+  const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
+  const baseURL = options.baseURL ?? "https://api.openai.com/v1";
+  let client = null;
+  async function getClient() {
+    if (!client) {
+      const { default: OpenAI } = await import('openai');
+      client = new OpenAI({
+        apiKey,
+        baseURL,
+        organization: options.organization,
+        defaultHeaders: options.headers
+      });
+    }
+    return client;
+  }
+  const modelConfig = OPENAI_MODELS[modelId] ?? OPENAI_MODELS["gpt-4o"];
+  return {
+    provider: "openai",
+    modelId,
+    capabilities: {
+      supportsVision: modelConfig.vision,
+      supportsTools: modelConfig.tools,
+      supportsStreaming: true,
+      supportsJsonMode: modelConfig.jsonMode,
+      supportsThinking: false,
+      supportsPDF: false,
+      maxTokens: modelConfig.maxTokens,
+      supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
+    },
+    async doGenerate(params) {
+      const client2 = await getClient();
+      const messages = formatMessagesForOpenAI(params.messages);
+      const response = await client2.chat.completions.create({
+        model: modelId,
+        messages,
+        tools: params.tools,
+        temperature: params.temperature,
+        max_tokens: params.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 {
+        text: message.content ?? "",
+        toolCalls,
+        finishReason: mapFinishReason(choice.finish_reason),
+        usage: {
+          promptTokens: response.usage?.prompt_tokens ?? 0,
+          completionTokens: response.usage?.completion_tokens ?? 0,
+          totalTokens: response.usage?.total_tokens ?? 0
+        },
+        rawResponse: response
+      };
+    },
+    async *doStream(params) {
+      const client2 = await getClient();
+      const messages = formatMessagesForOpenAI(params.messages);
+      const stream = await client2.chat.completions.create({
+        model: modelId,
+        messages,
+        tools: params.tools,
+        temperature: params.temperature,
+        max_tokens: params.maxTokens,
+        stream: true
+      });
+      let currentToolCall = null;
+      let totalPromptTokens = 0;
+      let totalCompletionTokens = 0;
+      for await (const chunk of stream) {
+        if (params.signal?.aborted) {
+          yield { type: "error", error: new Error("Aborted") };
+          return;
+        }
+        const choice = chunk.choices[0];
+        const delta = choice?.delta;
+        if (delta?.content) {
+          yield { type: "text-delta", text: delta.content };
+        }
+        if (delta?.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            if (tc.id) {
+              if (currentToolCall) {
+                yield {
+                  type: "tool-call",
+                  toolCall: {
+                    id: currentToolCall.id,
+                    name: currentToolCall.name,
+                    args: JSON.parse(currentToolCall.arguments || "{}")
+                  }
+                };
+              }
+              currentToolCall = {
+                id: tc.id,
+                name: tc.function?.name ?? "",
+                arguments: tc.function?.arguments ?? ""
+              };
+            } else if (currentToolCall && tc.function?.arguments) {
+              currentToolCall.arguments += tc.function.arguments;
+            }
+          }
+        }
+        if (choice?.finish_reason) {
+          if (currentToolCall) {
+            yield {
+              type: "tool-call",
+              toolCall: {
+                id: currentToolCall.id,
+                name: currentToolCall.name,
+                args: JSON.parse(currentToolCall.arguments || "{}")
+              }
+            };
+            currentToolCall = null;
+          }
+          if (chunk.usage) {
+            totalPromptTokens = chunk.usage.prompt_tokens;
+            totalCompletionTokens = chunk.usage.completion_tokens;
+          }
+          yield {
+            type: "finish",
+            finishReason: mapFinishReason(choice.finish_reason),
+            usage: {
+              promptTokens: totalPromptTokens,
+              completionTokens: totalCompletionTokens,
+              totalTokens: totalPromptTokens + totalCompletionTokens
+            }
+          };
+        }
+      }
+    }
+  };
+}
+function mapFinishReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "tool_calls":
+    case "function_call":
+      return "tool-calls";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return "unknown";
+  }
+}
+function formatMessagesForOpenAI(messages) {
+  return messages.map((msg) => {
+    switch (msg.role) {
+      case "system":
+        return { role: "system", content: msg.content };
+      case "user":
+        if (typeof msg.content === "string") {
+          return { role: "user", content: msg.content };
+        }
+        return {
+          role: "user",
+          content: msg.content.map((part) => {
+            if (part.type === "text") {
+              return { type: "text", text: part.text };
+            }
+            if (part.type === "image") {
+              const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
+              const url = imageData.startsWith("data:") ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
+              return { type: "image_url", image_url: { url, detail: "auto" } };
+            }
+            return { type: "text", text: "" };
+          })
+        };
+      case "assistant":
+        const assistantMsg = {
+          role: "assistant",
+          content: msg.content
+        };
+        if (msg.toolCalls && msg.toolCalls.length > 0) {
+          assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.args)
+            }
+          }));
+        }
+        return assistantMsg;
+      case "tool":
+        return {
+          role: "tool",
+          tool_call_id: msg.toolCallId,
+          content: msg.content
+        };
+      default:
+        return msg;
+    }
+  });
+}
+
+// src/providers/anthropic/provider.ts
+var ANTHROPIC_MODELS = {
+  // Claude 4 series
+  "claude-sonnet-4-20250514": {
+    vision: true,
+    tools: true,
+    thinking: true,
+    pdf: true,
+    maxTokens: 2e5
+  },
+  "claude-opus-4-20250514": {
+    vision: true,
+    tools: true,
+    thinking: true,
+    pdf: true,
+    maxTokens: 2e5
+  },
+  // Claude 3.7 series
+  "claude-3-7-sonnet-20250219": {
+    vision: true,
+    tools: true,
+    thinking: true,
+    pdf: true,
+    maxTokens: 2e5
+  },
+  "claude-3-7-sonnet-latest": {
+    vision: true,
+    tools: true,
+    thinking: true,
+    pdf: true,
+    maxTokens: 2e5
+  },
+  // Claude 3.5 series
+  "claude-3-5-sonnet-20241022": {
+    vision: true,
+    tools: true,
+    thinking: false,
+    pdf: true,
+    maxTokens: 2e5
+  },
+  "claude-3-5-sonnet-latest": {
+    vision: true,
+    tools: true,
+    thinking: false,
+    pdf: true,
+    maxTokens: 2e5
+  },
+  "claude-3-5-haiku-20241022": {
+    vision: true,
+    tools: true,
+    thinking: false,
+    pdf: false,
+    maxTokens: 2e5
+  },
+  "claude-3-5-haiku-latest": {
+    vision: true,
+    tools: true,
+    thinking: false,
+    pdf: false,
+    maxTokens: 2e5
+  },
+  // Claude 3 series
+  "claude-3-opus-20240229": {
+    vision: true,
+    tools: true,
+    thinking: false,
+    pdf: false,
+    maxTokens: 2e5
+  },
+  "claude-3-sonnet-20240229": {
+    vision: true,
+    tools: true,
+    thinking: false,
+    pdf: false,
+    maxTokens: 2e5
+  },
+  "claude-3-haiku-20240307": {
+    vision: true,
+    tools: true,
+    thinking: false,
+    pdf: false,
+    maxTokens: 2e5
+  }
+};
+function anthropic(modelId, options = {}) {
+  const apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY;
+  let client = null;
+  async function getClient() {
+    if (!client) {
+      const { default: Anthropic } = await import('@anthropic-ai/sdk');
+      client = new Anthropic({
+        apiKey,
+        baseURL: options.baseURL
+      });
+    }
+    return client;
+  }
+  const modelConfig = ANTHROPIC_MODELS[modelId] ?? ANTHROPIC_MODELS["claude-3-5-sonnet-latest"];
+  return {
+    provider: "anthropic",
+    modelId,
+    capabilities: {
+      supportsVision: modelConfig.vision,
+      supportsTools: modelConfig.tools,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      supportsThinking: modelConfig.thinking,
+      supportsPDF: modelConfig.pdf,
+      maxTokens: modelConfig.maxTokens,
+      supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
+    },
+    async doGenerate(params) {
+      const client2 = await getClient();
+      const { system, messages } = formatMessagesForAnthropic(params.messages);
+      const requestOptions = {
+        model: modelId,
+        max_tokens: params.maxTokens ?? 4096,
+        system: system || void 0,
+        messages,
+        tools: params.tools
+      };
+      if (params.temperature !== void 0) {
+        requestOptions.temperature = params.temperature;
+      }
+      if (options.thinking?.enabled && modelConfig.thinking) {
+        requestOptions.thinking = {
+          type: "enabled",
+          budget_tokens: options.thinking.budgetTokens ?? 1e4
+        };
+      }
+      const response = await client2.messages.create(requestOptions);
+      let text = "";
+      const toolCalls = [];
+      for (const block of response.content) {
+        if (block.type === "text") {
+          text += block.text;
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            name: block.name,
+            args: block.input
+          });
+        }
+      }
+      return {
+        text,
+        toolCalls,
+        finishReason: mapFinishReason2(response.stop_reason),
+        usage: {
+          promptTokens: response.usage?.input_tokens ?? 0,
+          completionTokens: response.usage?.output_tokens ?? 0,
+          totalTokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0)
+        },
+        rawResponse: response
+      };
+    },
+    async *doStream(params) {
+      const client2 = await getClient();
+      const { system, messages } = formatMessagesForAnthropic(params.messages);
+      const requestOptions = {
+        model: modelId,
+        max_tokens: params.maxTokens ?? 4096,
+        system: system || void 0,
+        messages,
+        tools: params.tools
+      };
+      if (params.temperature !== void 0) {
+        requestOptions.temperature = params.temperature;
+      }
+      if (options.thinking?.enabled && modelConfig.thinking) {
+        requestOptions.thinking = {
+          type: "enabled",
+          budget_tokens: options.thinking.budgetTokens ?? 1e4
+        };
+      }
+      const stream = await client2.messages.stream(requestOptions);
+      let currentToolUse = null;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      for await (const event of stream) {
+        if (params.signal?.aborted) {
+          yield { type: "error", error: new Error("Aborted") };
+          return;
+        }
+        switch (event.type) {
+          case "message_start":
+            if (event.message?.usage) {
+              inputTokens = event.message.usage.input_tokens ?? 0;
+            }
+            break;
+          case "content_block_start":
+            if (event.content_block?.type === "tool_use") {
+              currentToolUse = {
+                id: event.content_block.id,
+                name: event.content_block.name,
+                input: ""
+              };
+            }
+            break;
+          case "content_block_delta":
+            if (event.delta?.type === "text_delta") {
+              yield { type: "text-delta", text: event.delta.text };
+            } else if (event.delta?.type === "input_json_delta" && currentToolUse) {
+              currentToolUse.input += event.delta.partial_json;
+            }
+            break;
+          case "content_block_stop":
+            if (currentToolUse) {
+              yield {
+                type: "tool-call",
+                toolCall: {
+                  id: currentToolUse.id,
+                  name: currentToolUse.name,
+                  args: JSON.parse(currentToolUse.input || "{}")
+                }
+              };
+              currentToolUse = null;
+            }
+            break;
+          case "message_delta":
+            if (event.usage) {
+              outputTokens = event.usage.output_tokens ?? 0;
+            }
+            if (event.delta?.stop_reason) {
+              yield {
+                type: "finish",
+                finishReason: mapFinishReason2(event.delta.stop_reason),
+                usage: {
+                  promptTokens: inputTokens,
+                  completionTokens: outputTokens,
+                  totalTokens: inputTokens + outputTokens
+                }
+              };
+            }
+            break;
+        }
+      }
+    }
+  };
+}
+function mapFinishReason2(reason) {
+  switch (reason) {
+    case "end_turn":
+    case "stop_sequence":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "tool-calls";
+    default:
+      return "unknown";
+  }
+}
+function formatMessagesForAnthropic(messages) {
+  let system = "";
+  const formatted = [];
+  const pendingToolResults = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      system += (system ? "\n" : "") + msg.content;
+      continue;
+    }
+    if (msg.role === "assistant" && pendingToolResults.length > 0) {
+      formatted.push({
+        role: "user",
+        content: pendingToolResults.map((tr) => ({
+          type: "tool_result",
+          tool_use_id: tr.toolCallId,
+          content: tr.content
+        }))
+      });
+      pendingToolResults.length = 0;
+    }
+    if (msg.role === "user") {
+      if (pendingToolResults.length > 0) {
+        formatted.push({
+          role: "user",
+          content: pendingToolResults.map((tr) => ({
+            type: "tool_result",
+            tool_use_id: tr.toolCallId,
+            content: tr.content
+          }))
+        });
+        pendingToolResults.length = 0;
+      }
+      if (typeof msg.content === "string") {
+        formatted.push({ role: "user", content: msg.content });
+      } else {
+        const content = [];
+        for (const part of msg.content) {
+          if (part.type === "text") {
+            content.push({ type: "text", text: part.text });
+          } else if (part.type === "image") {
+            const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
+            if (imageData.startsWith("http")) {
+              content.push({
+                type: "image",
+                source: { type: "url", url: imageData }
+              });
+            } else {
+              const base64 = imageData.startsWith("data:") ? imageData.split(",")[1] : imageData;
+              content.push({
+                type: "image",
+                source: {
+                  type: "base64",
+                  media_type: part.mimeType ?? "image/png",
+                  data: base64
+                }
+              });
+            }
+          }
+        }
+        formatted.push({ role: "user", content });
+      }
+    } else if (msg.role === "assistant") {
+      const content = [];
+      if (msg.content) {
+        content.push({ type: "text", text: msg.content });
+      }
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        for (const tc of msg.toolCalls) {
+          content.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.name,
+            input: tc.args
+          });
+        }
+      }
+      if (content.length > 0) {
+        formatted.push({ role: "assistant", content });
+      }
+    } else if (msg.role === "tool") {
+      pendingToolResults.push({
+        toolCallId: msg.toolCallId,
+        content: msg.content
+      });
+    }
+  }
+  if (pendingToolResults.length > 0) {
+    formatted.push({
+      role: "user",
+      content: pendingToolResults.map((tr) => ({
+        type: "tool_result",
+        tool_use_id: tr.toolCallId,
+        content: tr.content
+      }))
+    });
+  }
+  return { system, messages: formatted };
+}
+
+// src/providers/xai/provider.ts
+var XAI_MODELS = {
+  // Grok 4.1 Fast (Latest - December 2025)
+  "grok-4-1-fast-reasoning": { vision: false, tools: true, maxTokens: 2e6 },
+  "grok-4-1-fast-non-reasoning": {
+    vision: false,
+    tools: true,
+    maxTokens: 2e6
+  },
+  // Grok 4 Fast (September 2025)
+  "grok-4-fast-reasoning": { vision: false, tools: true, maxTokens: 2e6 },
+  "grok-4-fast-non-reasoning": {
+    vision: false,
+    tools: true,
+    maxTokens: 2e6
+  },
+  // Grok 4 (July 2025)
+  "grok-4": { vision: true, tools: true, maxTokens: 256e3 },
+  "grok-4-0709": { vision: true, tools: true, maxTokens: 256e3 },
+  // Grok 3 (February 2025) - Stable
+  "grok-3-beta": { vision: true, tools: true, maxTokens: 131072 },
+  "grok-3-fast-beta": { vision: false, tools: true, maxTokens: 131072 },
+  "grok-3-mini-beta": { vision: false, tools: true, maxTokens: 32768 },
+  "grok-3-mini-fast-beta": { vision: false, tools: true, maxTokens: 32768 },
+  // Grok Code Fast (August 2025)
+  "grok-code-fast-1": { vision: false, tools: true, maxTokens: 256e3 },
+  // Grok 2 (Legacy)
+  "grok-2": { vision: true, tools: true, maxTokens: 131072 },
+  "grok-2-latest": { vision: true, tools: true, maxTokens: 131072 },
+  "grok-2-mini": { vision: false, tools: true, maxTokens: 131072 }
+};
+function xai(modelId, options = {}) {
+  const apiKey = options.apiKey ?? process.env.XAI_API_KEY;
+  const baseURL = options.baseURL ?? "https://api.x.ai/v1";
+  let client = null;
+  async function getClient() {
+    if (!client) {
+      const { default: OpenAI } = await import('openai');
+      client = new OpenAI({
+        apiKey,
+        baseURL
+      });
+    }
+    return client;
+  }
+  const modelConfig = XAI_MODELS[modelId] ?? XAI_MODELS["grok-3-fast-beta"];
+  return {
+    provider: "xai",
+    modelId,
+    capabilities: {
+      supportsVision: modelConfig.vision,
+      supportsTools: modelConfig.tools,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      // xAI doesn't support JSON mode yet
+      supportsThinking: false,
+      supportsPDF: false,
+      maxTokens: modelConfig.maxTokens,
+      supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
+    },
+    async doGenerate(params) {
+      const client2 = await getClient();
+      const messages = formatMessagesForXAI(params.messages);
+      const response = await client2.chat.completions.create({
+        model: modelId,
+        messages,
+        tools: params.tools,
+        temperature: params.temperature,
+        max_tokens: params.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 {
+        text: message.content ?? "",
+        toolCalls,
+        finishReason: mapFinishReason3(choice.finish_reason),
+        usage: {
+          promptTokens: response.usage?.prompt_tokens ?? 0,
+          completionTokens: response.usage?.completion_tokens ?? 0,
+          totalTokens: response.usage?.total_tokens ?? 0
+        },
+        rawResponse: response
+      };
+    },
+    async *doStream(params) {
+      const client2 = await getClient();
+      const messages = formatMessagesForXAI(params.messages);
+      const stream = await client2.chat.completions.create({
+        model: modelId,
+        messages,
+        tools: params.tools,
+        temperature: params.temperature,
+        max_tokens: params.maxTokens,
+        stream: true
+      });
+      let currentToolCall = null;
+      let totalPromptTokens = 0;
+      let totalCompletionTokens = 0;
+      for await (const chunk of stream) {
+        if (params.signal?.aborted) {
+          yield { type: "error", error: new Error("Aborted") };
+          return;
+        }
+        const choice = chunk.choices[0];
+        const delta = choice?.delta;
+        if (delta?.content) {
+          yield { type: "text-delta", text: delta.content };
+        }
+        if (delta?.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            if (tc.id) {
+              if (currentToolCall) {
+                yield {
+                  type: "tool-call",
+                  toolCall: {
+                    id: currentToolCall.id,
+                    name: currentToolCall.name,
+                    args: JSON.parse(currentToolCall.arguments || "{}")
+                  }
+                };
+              }
+              currentToolCall = {
+                id: tc.id,
+                name: tc.function?.name ?? "",
+                arguments: tc.function?.arguments ?? ""
+              };
+            } else if (currentToolCall && tc.function?.arguments) {
+              currentToolCall.arguments += tc.function.arguments;
+            }
+          }
+        }
+        if (choice?.finish_reason) {
+          if (currentToolCall) {
+            yield {
+              type: "tool-call",
+              toolCall: {
+                id: currentToolCall.id,
+                name: currentToolCall.name,
+                args: JSON.parse(currentToolCall.arguments || "{}")
+              }
+            };
+            currentToolCall = null;
+          }
+          if (chunk.usage) {
+            totalPromptTokens = chunk.usage.prompt_tokens;
+            totalCompletionTokens = chunk.usage.completion_tokens;
+          }
+          yield {
+            type: "finish",
+            finishReason: mapFinishReason3(choice.finish_reason),
+            usage: {
+              promptTokens: totalPromptTokens,
+              completionTokens: totalCompletionTokens,
+              totalTokens: totalPromptTokens + totalCompletionTokens
+            }
+          };
+        }
+      }
+    }
+  };
+}
+function mapFinishReason3(reason) {
+  switch (reason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "tool_calls":
+    case "function_call":
+      return "tool-calls";
+    case "content_filter":
+      return "content-filter";
+    default:
+      return "unknown";
+  }
+}
+function formatMessagesForXAI(messages) {
+  return messages.map((msg) => {
+    switch (msg.role) {
+      case "system":
+        return { role: "system", content: msg.content };
+      case "user":
+        if (typeof msg.content === "string") {
+          return { role: "user", content: msg.content };
+        }
+        return {
+          role: "user",
+          content: msg.content.map((part) => {
+            if (part.type === "text") {
+              return { type: "text", text: part.text };
+            }
+            if (part.type === "image") {
+              const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
+              const url = imageData.startsWith("data:") ? imageData : `data:${part.mimeType ?? "image/png"};base64,${imageData}`;
+              return { type: "image_url", image_url: { url, detail: "auto" } };
+            }
+            return { type: "text", text: "" };
+          })
+        };
+      case "assistant":
+        const assistantMsg = {
+          role: "assistant",
+          content: msg.content
+        };
+        if (msg.toolCalls && msg.toolCalls.length > 0) {
+          assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.args)
+            }
+          }));
+        }
+        return assistantMsg;
+      case "tool":
+        return {
+          role: "tool",
+          tool_call_id: msg.toolCallId,
+          content: msg.content
+        };
+      default:
+        return msg;
+    }
+  });
+}
+
+// src/providers/google/provider.ts
+var GOOGLE_MODELS = {
+  // Gemini 2.0
+  "gemini-2.0-flash": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 1048576
+  },
+  "gemini-2.0-flash-exp": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 1048576
+  },
+  "gemini-2.0-flash-thinking-exp": {
+    vision: true,
+    tools: false,
+    audio: false,
+    video: false,
+    maxTokens: 32767
+  },
+  // Gemini 1.5
+  "gemini-1.5-pro": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 2097152
+  },
+  "gemini-1.5-pro-latest": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 2097152
+  },
+  "gemini-1.5-flash": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 1048576
+  },
+  "gemini-1.5-flash-latest": {
+    vision: true,
+    tools: true,
+    audio: true,
+    video: true,
+    maxTokens: 1048576
+  },
+  "gemini-1.5-flash-8b": {
+    vision: true,
+    tools: true,
+    audio: false,
+    video: false,
+    maxTokens: 1048576
+  }
+};
+function google(modelId, options = {}) {
+  const apiKey = options.apiKey ?? process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
+  let client = null;
+  async function getClient() {
+    if (!client) {
+      const { GoogleGenerativeAI } = await import('@google/generative-ai');
+      client = new GoogleGenerativeAI(apiKey);
+    }
+    return client;
+  }
+  const modelConfig = GOOGLE_MODELS[modelId] ?? GOOGLE_MODELS["gemini-2.0-flash"];
+  return {
+    provider: "google",
+    modelId,
+    capabilities: {
+      supportsVision: modelConfig.vision,
+      supportsTools: modelConfig.tools,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      supportsThinking: modelId.includes("thinking"),
+      supportsPDF: true,
+      maxTokens: modelConfig.maxTokens,
+      supportedImageTypes: modelConfig.vision ? ["image/png", "image/jpeg", "image/gif", "image/webp"] : []
+    },
+    async doGenerate(params) {
+      const client2 = await getClient();
+      const model = client2.getGenerativeModel({
+        model: modelId,
+        safetySettings: options.safetySettings
+      });
+      const { systemInstruction, contents } = formatMessagesForGemini(
+        params.messages
+      );
+      const chat = model.startChat({
+        history: contents.slice(0, -1),
+        systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,
+        tools: params.tools ? [{ functionDeclarations: formatToolsForGemini(params.tools) }] : void 0,
+        generationConfig: {
+          temperature: params.temperature,
+          maxOutputTokens: params.maxTokens
+        }
+      });
+      const lastMessage = contents[contents.length - 1];
+      const result = await chat.sendMessage(lastMessage.parts);
+      const response = result.response;
+      let text = "";
+      const toolCalls = [];
+      let toolCallIndex = 0;
+      const candidate = response.candidates?.[0];
+      if (candidate?.content?.parts) {
+        for (const part of candidate.content.parts) {
+          if ("text" in part && part.text) {
+            text += part.text;
+          }
+          if ("functionCall" in part && part.functionCall) {
+            toolCalls.push({
+              id: `call_${toolCallIndex++}`,
+              name: part.functionCall.name,
+              args: part.functionCall.args || {}
+            });
+          }
+        }
+      }
+      return {
+        text,
+        toolCalls,
+        finishReason: mapFinishReason4(candidate?.finishReason),
+        usage: {
+          promptTokens: response.usageMetadata?.promptTokenCount ?? 0,
+          completionTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
+          totalTokens: response.usageMetadata?.totalTokenCount ?? 0
+        },
+        rawResponse: response
+      };
+    },
+    async *doStream(params) {
+      const client2 = await getClient();
+      const model = client2.getGenerativeModel({
+        model: modelId,
+        safetySettings: options.safetySettings
+      });
+      const { systemInstruction, contents } = formatMessagesForGemini(
+        params.messages
+      );
+      const chat = model.startChat({
+        history: contents.slice(0, -1),
+        systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,
+        tools: params.tools ? [{ functionDeclarations: formatToolsForGemini(params.tools) }] : void 0,
+        generationConfig: {
+          temperature: params.temperature,
+          maxOutputTokens: params.maxTokens
+        }
+      });
+      const lastMessage = contents[contents.length - 1];
+      const result = await chat.sendMessageStream(lastMessage.parts);
+      let toolCallIndex = 0;
+      let promptTokens = 0;
+      let completionTokens = 0;
+      try {
+        for await (const chunk of result.stream) {
+          if (params.signal?.aborted) {
+            yield { type: "error", error: new Error("Aborted") };
+            return;
+          }
+          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: "text-delta", text: part.text };
+            }
+            if ("functionCall" in part && part.functionCall) {
+              yield {
+                type: "tool-call",
+                toolCall: {
+                  id: `call_${toolCallIndex++}`,
+                  name: part.functionCall.name,
+                  args: part.functionCall.args || {}
+                }
+              };
+            }
+          }
+          if (chunk.usageMetadata) {
+            promptTokens = chunk.usageMetadata.promptTokenCount ?? 0;
+            completionTokens = chunk.usageMetadata.candidatesTokenCount ?? 0;
+          }
+          if (candidate.finishReason) {
+            yield {
+              type: "finish",
+              finishReason: mapFinishReason4(candidate.finishReason),
+              usage: {
+                promptTokens,
+                completionTokens,
+                totalTokens: promptTokens + completionTokens
+              }
+            };
+          }
+        }
+      } catch (error) {
+        yield {
+          type: "error",
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
+    }
+  };
+}
+function mapFinishReason4(reason) {
+  switch (reason) {
+    case "STOP":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "SAFETY":
+      return "content-filter";
+    default:
+      return "unknown";
+  }
+}
+function formatMessagesForGemini(messages) {
+  let systemInstruction = "";
+  const contents = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      systemInstruction += (systemInstruction ? "\n" : "") + msg.content;
+      continue;
+    }
+    const parts = [];
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        parts.push({ text: msg.content });
+      } else {
+        for (const part of msg.content) {
+          if (part.type === "text") {
+            parts.push({ text: part.text });
+          } else if (part.type === "image") {
+            const imageData = typeof part.image === "string" ? part.image : Buffer.from(part.image).toString("base64");
+            const base64 = imageData.startsWith("data:") ? imageData.split(",")[1] : imageData;
+            parts.push({
+              inlineData: {
+                mimeType: part.mimeType ?? "image/png",
+                data: base64
+              }
+            });
+          }
+        }
+      }
+      contents.push({ role: "user", parts });
+    } else if (msg.role === "assistant") {
+      if (msg.content) {
+        parts.push({ text: msg.content });
+      }
+      if (msg.toolCalls?.length) {
+        for (const tc of msg.toolCalls) {
+          parts.push({
+            functionCall: {
+              name: tc.name,
+              args: tc.args
+            }
+          });
+        }
+      }
+      if (parts.length > 0) {
+        contents.push({ role: "model", parts });
+      }
+    } else if (msg.role === "tool") {
+      contents.push({
+        role: "user",
+        parts: [
+          {
+            functionResponse: {
+              name: "tool",
+              // Gemini doesn't track by ID
+              response: JSON.parse(msg.content || "{}")
+            }
+          }
+        ]
+      });
+    }
+  }
+  if (contents.length === 0 || contents[0].role !== "user") {
+    contents.unshift({ role: "user", parts: [{ text: "" }] });
+  }
+  const merged = [];
+  for (const content of contents) {
+    const last = merged[merged.length - 1];
+    if (last && last.role === content.role) {
+      last.parts.push(...content.parts);
+    } else {
+      merged.push({ ...content, parts: [...content.parts] });
+    }
+  }
+  return { systemInstruction, contents: merged };
+}
+function formatToolsForGemini(tools) {
+  return tools.map((t) => ({
+    name: t.function.name,
+    description: t.function.description,
+    parameters: t.function.parameters
+  }));
+}
 
 // src/adapters/base.ts
 function formatMessages(messages, systemPrompt) {
@@ -197,7 +1884,7 @@ function messageToOpenAIContent(message) {
   }
   return blocks;
 }
-function formatMessagesForAnthropic(messages, systemPrompt) {
+function formatMessagesForAnthropic2(messages, systemPrompt) {
   const formatted = [];
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i];
@@ -256,7 +1943,7 @@ function formatMessagesForAnthropic(messages, systemPrompt) {
     messages: formatted
   };
 }
-function formatMessagesForOpenAI(messages, systemPrompt) {
+function formatMessagesForOpenAI2(messages, systemPrompt) {
   const formatted = [];
   if (systemPrompt) {
     formatted.push({ role: "system", content: systemPrompt });
@@ -349,7 +2036,7 @@ var OpenAIAdapter = class {
         messages = processedMessages;
       }
     } else {
-      messages = formatMessagesForOpenAI(
+      messages = formatMessagesForOpenAI2(
         request.messages,
         request.systemPrompt
       );
@@ -597,7 +2284,7 @@ var AnthropicAdapter = class {
     if (request.rawMessages && request.rawMessages.length > 0) {
       messages = this.convertToAnthropicMessages(request.rawMessages);
     } else {
-      const formatted = formatMessagesForAnthropic(request.messages);
+      const formatted = formatMessagesForAnthropic2(request.messages);
       messages = formatted.messages;
     }
     const tools = request.actions?.map((action) => ({
@@ -743,117 +2430,6 @@ var AnthropicAdapter = class {
 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";
@@ -1020,7 +2596,7 @@ function messageToGeminiContent(msg) {
     parts
   };
 }
-function formatToolsForGemini(actions) {
+function formatToolsForGemini2(actions) {
   if (!actions || actions.length === 0) return void 0;
   return {
     functionDeclarations: actions.map((action) => ({
@@ -1106,7 +2682,7 @@ var GoogleAdapter = class {
         mergedContents.push({ ...content, parts: [...content.parts] });
       }
     }
-    const tools = formatToolsForGemini(request.actions);
+    const tools = formatToolsForGemini2(request.actions);
     const messageId = core.generateMessageId();
     yield { type: "message:start", id: messageId };
     try {
@@ -1212,7 +2788,7 @@ var GoogleAdapter = class {
         mergedContents.push({ ...content, parts: [...content.parts] });
       }
     }
-    const tools = formatToolsForGemini(request.actions);
+    const tools = formatToolsForGemini2(request.actions);
     const chat = model.startChat({
       history: mergedContents.slice(0, -1),
       systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,
@@ -1310,7 +2886,7 @@ var XAIAdapter = class {
         messages = processedMessages;
       }
     } else {
-      messages = formatMessagesForOpenAI(
+      messages = formatMessagesForOpenAI2(
         request.messages,
         request.systemPrompt
       );
@@ -1399,7 +2975,7 @@ var XAIAdapter = class {
         }
       }
     } else {
-      messages = formatMessagesForOpenAI(
+      messages = formatMessagesForOpenAI2(
         request.messages,
         request.systemPrompt
       );
@@ -1496,7 +3072,7 @@ var AzureAdapter = class {
         messages = processedMessages;
       }
     } else {
-      messages = formatMessagesForOpenAI(
+      messages = formatMessagesForOpenAI2(
         request.messages,
         request.systemPrompt
       );
@@ -1586,7 +3162,7 @@ var AzureAdapter = class {
         }
       }
     } else {
-      messages = formatMessagesForOpenAI(
+      messages = formatMessagesForOpenAI2(
         request.messages,
         request.systemPrompt
       );
@@ -1660,23 +3236,23 @@ function createSSEResponse(generator) {
 }
 
 // src/server/runtime.ts
-function buildToolResultForAI(tool, result, args) {
+function buildToolResultForAI(tool2, result, args) {
   const typedResult = result;
-  const responseMode = typedResult?._aiResponseMode ?? tool?.aiResponseMode ?? "full";
+  const responseMode = typedResult?._aiResponseMode ?? tool2?.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;
+  } else if (tool2?.aiContext) {
+    aiContext = typeof tool2.aiContext === "function" ? tool2.aiContext(typedResult, args) : tool2.aiContext;
   }
   switch (responseMode) {
     case "none":
       return aiContext ?? "[Result displayed to user]";
     case "brief":
-      return aiContext ?? `[Tool ${tool?.name ?? "unknown"} executed successfully]`;
+      return aiContext ?? `[Tool ${tool2?.name ?? "unknown"} executed successfully]`;
     case "full":
     default:
       const fullData = JSON.stringify(result);
@@ -1745,8 +3321,8 @@ var Runtime = class {
       }
     }
     if (config.tools) {
-      for (const tool of config.tools) {
-        this.tools.set(tool.name, tool);
+      for (const tool2 of config.tools) {
+        this.tools.set(tool2.name, tool2);
       }
     }
   }
@@ -1776,13 +3352,6 @@ var Runtime = class {
           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,
@@ -1863,8 +3432,28 @@ var Runtime = class {
   }
   /**
    * Handle HTTP request (for use with any framework)
+   *
+   * @param request - The HTTP request
+   * @param options - Optional configuration including onFinish callback for persistence
+   *
+   * @example
+   * ```typescript
+   * // Basic usage
+   * return runtime.handleRequest(request);
+   *
+   * // With server-side persistence
+   * return runtime.handleRequest(request, {
+   *   onFinish: async ({ messages, threadId }) => {
+   *     await db.thread.upsert({
+   *       where: { id: threadId },
+   *       update: { messages, updatedAt: new Date() },
+   *       create: { id: threadId, messages },
+   *     });
+   *   },
+   * });
+   * ```
    */
-  async handleRequest(request) {
+  async handleRequest(request, options) {
     try {
       const body = await request.json();
       if (this.config.debug) {
@@ -1878,11 +3467,17 @@ var Runtime = class {
           body,
           signal,
           useAgentLoop || false,
-          request
+          request,
+          options
         );
       }
       const generator = useAgentLoop ? this.processChatWithLoop(body, signal, void 0, void 0, request) : this.processChat(body, signal);
-      return createSSEResponse(generator);
+      const wrappedGenerator = this.wrapGeneratorWithOnFinish(
+        generator,
+        body.threadId,
+        options
+      );
+      return createSSEResponse(wrappedGenerator);
     } catch (error) {
       console.error("[Copilot SDK] Error:", error);
       return new Response(
@@ -1896,10 +3491,34 @@ var Runtime = class {
       );
     }
   }
+  /**
+   * Wrap a generator to intercept the done event and call onFinish
+   */
+  async *wrapGeneratorWithOnFinish(generator, threadId, options) {
+    let doneMessages;
+    for await (const event of generator) {
+      if (event.type === "done" && event.messages) {
+        doneMessages = event.messages;
+      }
+      yield event;
+    }
+    if (options?.onFinish && doneMessages) {
+      try {
+        const result = {
+          messages: doneMessages,
+          threadId
+          // TODO: Add usage tracking when available from adapter
+        };
+        await options.onFinish(result);
+      } catch (error) {
+        console.error("[Copilot SDK] onFinish callback error:", error);
+      }
+    }
+  }
   /**
    * Handle non-streaming request - returns JSON instead of SSE
    */
-  async handleNonStreamingRequest(body, signal, useAgentLoop, httpRequest) {
+  async handleNonStreamingRequest(body, signal, useAgentLoop, httpRequest, options) {
     try {
       const generator = useAgentLoop ? this.processChatWithLoop(
         body,
@@ -1951,6 +3570,20 @@ var Runtime = class {
             break;
         }
       }
+      if (options?.onFinish && messages && !error) {
+        try {
+          const result = {
+            messages,
+            threadId: body.threadId
+          };
+          await options.onFinish(result);
+        } catch (callbackError) {
+          console.error(
+            "[Copilot SDK] onFinish callback error:",
+            callbackError
+          );
+        }
+      }
       const response = {
         success: !error,
         content,
@@ -2014,8 +3647,8 @@ var Runtime = class {
   /**
    * Register a new tool
    */
-  registerTool(tool) {
-    this.tools.set(tool.name, tool);
+  registerTool(tool2) {
+    this.tools.set(tool2.name, tool2);
   }
   /**
    * Unregister a tool
@@ -2094,12 +3727,12 @@ var Runtime = class {
     this.config.agentLoop?.maxIterations || 20;
     const allTools = [...this.tools.values()];
     if (request.tools) {
-      for (const tool of request.tools) {
+      for (const tool2 of request.tools) {
         allTools.push({
-          name: tool.name,
-          description: tool.description,
+          name: tool2.name,
+          description: tool2.description,
           location: "client",
-          inputSchema: tool.inputSchema
+          inputSchema: tool2.inputSchema
         });
       }
     }
@@ -2204,8 +3837,8 @@ var Runtime = class {
       const serverToolCalls = [];
       const clientToolCalls = [];
       for (const tc of toolCalls) {
-        const tool = allTools.find((t) => t.name === tc.name);
-        if (tool?.location === "server" && tool.handler) {
+        const tool2 = allTools.find((t) => t.name === tc.name);
+        if (tool2?.location === "server" && tool2.handler) {
           serverToolCalls.push(tc);
         } else {
           clientToolCalls.push(tc);
@@ -2214,8 +3847,8 @@ var Runtime = class {
       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) {
+        const tool2 = allTools.find((t) => t.name === tc.name);
+        if (tool2?.handler) {
           if (debug) {
             console.log(`[Copilot SDK] Executing server-side tool: ${tc.name}`);
           }
@@ -2227,13 +3860,13 @@ var Runtime = class {
             toolContextData
           );
           try {
-            const result = await tool.handler(tc.args, toolContext);
+            const result = await tool2.handler(tc.args, toolContext);
             serverToolResults.push({
               id: tc.id,
               name: tc.name,
               args: tc.args,
               result,
-              tool
+              tool: tool2
             });
             yield {
               type: "action:end",
@@ -2250,7 +3883,7 @@ var Runtime = class {
               name: tc.name,
               args: tc.args,
               result: errorResult,
-              tool
+              tool: tool2
             });
             yield {
               type: "action:end",
@@ -2369,12 +4002,12 @@ var Runtime = class {
     const maxIterations = this.config.agentLoop?.maxIterations || 20;
     const allTools = [...this.tools.values()];
     if (request.tools) {
-      for (const tool of request.tools) {
+      for (const tool2 of request.tools) {
         allTools.push({
-          name: tool.name,
-          description: tool.description,
+          name: tool2.name,
+          description: tool2.description,
           location: "client",
-          inputSchema: tool.inputSchema
+          inputSchema: tool2.inputSchema
         });
       }
     }
@@ -2439,8 +4072,8 @@ var Runtime = class {
           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) {
+            const tool2 = allTools.find((t) => t.name === tc.name);
+            if (tool2?.location === "server" && tool2.handler) {
               serverToolCalls.push(tc);
             } else {
               clientToolCalls.push({
@@ -2465,8 +4098,8 @@ var Runtime = class {
           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) {
+            const tool2 = allTools.find((t) => t.name === tc.name);
+            if (tool2?.handler) {
               if (debug) {
                 console.log(`[Copilot SDK] Executing tool: ${tc.name}`);
               }
@@ -2478,13 +4111,13 @@ var Runtime = class {
                 toolContextData
               );
               try {
-                const toolResult = await tool.handler(tc.args, toolContext);
+                const toolResult = await tool2.handler(tc.args, toolContext);
                 serverToolResults.push({
                   id: tc.id,
                   name: tc.name,
                   args: tc.args,
                   result: toolResult,
-                  tool
+                  tool: tool2
                 });
                 yield {
                   type: "action:end",
@@ -2501,7 +4134,7 @@ var Runtime = class {
                   name: tc.name,
                   args: tc.args,
                   result: errorResult,
-                  tool
+                  tool: tool2
                 });
                 yield {
                   type: "action:end",
@@ -2608,11 +4241,11 @@ var Runtime = class {
    * 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 }))
+    return tools.map((tool2) => ({
+      name: tool2.name,
+      description: tool2.description,
+      parameters: this.convertInputSchemaToParameters(tool2.inputSchema),
+      handler: tool2.handler || (async () => ({ handled: false }))
     }));
   }
   /**
@@ -2834,7 +4467,7 @@ function getModelCapabilities(providerName, modelId) {
 }
 
 // src/providers/openai/index.ts
-var OPENAI_MODELS = {
+var OPENAI_MODELS2 = {
   // GPT-4o series
   "gpt-4o": {
     vision: true,
@@ -2945,7 +4578,7 @@ function createOpenAI(config = {}) {
   const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY ?? "";
   return {
     name: "openai",
-    supportedModels: Object.keys(OPENAI_MODELS),
+    supportedModels: Object.keys(OPENAI_MODELS2),
     languageModel(modelId) {
       return createOpenAIAdapter({
         apiKey,
@@ -2954,7 +4587,7 @@ function createOpenAI(config = {}) {
       });
     },
     getCapabilities(modelId) {
-      const model = OPENAI_MODELS[modelId] ?? OPENAI_MODELS["gpt-4o"];
+      const model = OPENAI_MODELS2[modelId] ?? OPENAI_MODELS2["gpt-4o"];
       return {
         supportsVision: model.vision,
         supportsTools: model.tools,
@@ -2976,7 +4609,7 @@ function createOpenAI(config = {}) {
 }
 
 // src/providers/anthropic/index.ts
-var ANTHROPIC_MODELS = {
+var ANTHROPIC_MODELS2 = {
   // Claude 4 series (latest)
   "claude-sonnet-4-20250514": {
     vision: true,
@@ -3045,7 +4678,7 @@ function createAnthropic(config = {}) {
   const apiKey = config.apiKey ?? process.env.ANTHROPIC_API_KEY ?? "";
   return {
     name: "anthropic",
-    supportedModels: Object.keys(ANTHROPIC_MODELS),
+    supportedModels: Object.keys(ANTHROPIC_MODELS2),
     languageModel(modelId) {
       return createAnthropicAdapter({
         apiKey,
@@ -3055,7 +4688,7 @@ function createAnthropic(config = {}) {
       });
     },
     getCapabilities(modelId) {
-      const model = ANTHROPIC_MODELS[modelId] ?? ANTHROPIC_MODELS["claude-3-5-sonnet-latest"];
+      const model = ANTHROPIC_MODELS2[modelId] ?? ANTHROPIC_MODELS2["claude-3-5-sonnet-latest"];
       return {
         supportsVision: model.vision,
         supportsTools: model.tools,
@@ -3080,90 +4713,6 @@ function createAnthropic(config = {}) {
   };
 }
 
-// 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
@@ -3297,7 +4846,7 @@ function createOllama(config = {}) {
 }
 
 // src/providers/google/index.ts
-var GOOGLE_MODELS = {
+var GOOGLE_MODELS2 = {
   // Gemini 2.0 series (latest)
   "gemini-2.0-flash": {
     vision: true,
@@ -3397,7 +4946,7 @@ function createGoogle(config = {}) {
   const apiKey = config.apiKey ?? process.env.GOOGLE_API_KEY ?? "";
   return {
     name: "google",
-    supportedModels: Object.keys(GOOGLE_MODELS),
+    supportedModels: Object.keys(GOOGLE_MODELS2),
     languageModel(modelId) {
       return createGoogleAdapter({
         apiKey,
@@ -3407,7 +4956,7 @@ function createGoogle(config = {}) {
       });
     },
     getCapabilities(modelId) {
-      const model = GOOGLE_MODELS[modelId] ?? GOOGLE_MODELS["gemini-2.0-flash"];
+      const model = GOOGLE_MODELS2[modelId] ?? GOOGLE_MODELS2["gemini-2.0-flash"];
       return {
         supportsVision: model.vision,
         supportsTools: model.tools,
@@ -3451,56 +5000,95 @@ function createGoogle(config = {}) {
 }
 
 // src/providers/xai/index.ts
-var XAI_MODELS = {
-  // Grok 2 series (latest)
-  "grok-2": {
+var XAI_MODELS2 = {
+  // Grok 4.1 Fast (Latest - December 2025)
+  "grok-4-1-fast-reasoning": {
+    vision: false,
+    tools: true,
+    maxTokens: 2e6,
+    outputTokens: 16384
+  },
+  "grok-4-1-fast-non-reasoning": {
+    vision: false,
+    tools: true,
+    maxTokens: 2e6,
+    outputTokens: 16384
+  },
+  // Grok 4 Fast (September 2025)
+  "grok-4-fast-reasoning": {
+    vision: false,
+    tools: true,
+    maxTokens: 2e6,
+    outputTokens: 16384
+  },
+  "grok-4-fast-non-reasoning": {
+    vision: false,
+    tools: true,
+    maxTokens: 2e6,
+    outputTokens: 16384
+  },
+  // Grok 4 (July 2025)
+  "grok-4": {
     vision: true,
     tools: true,
-    maxTokens: 131072,
-    outputTokens: 4096
+    maxTokens: 256e3,
+    outputTokens: 16384
   },
-  "grok-2-latest": {
+  "grok-4-0709": {
     vision: true,
     tools: true,
-    maxTokens: 131072,
-    outputTokens: 4096
+    maxTokens: 256e3,
+    outputTokens: 16384
   },
-  "grok-2-mini": {
-    vision: false,
+  // Grok 3 (February 2025) - Stable
+  "grok-3-beta": {
+    vision: true,
     tools: true,
     maxTokens: 131072,
-    outputTokens: 4096
+    outputTokens: 8192
   },
-  "grok-2-mini-latest": {
+  "grok-3-fast-beta": {
     vision: false,
     tools: true,
     maxTokens: 131072,
-    outputTokens: 4096
+    outputTokens: 8192
   },
-  // Grok Vision
-  "grok-2-vision": {
-    vision: true,
+  "grok-3-mini-beta": {
+    vision: false,
     tools: true,
     maxTokens: 32768,
-    outputTokens: 4096
+    outputTokens: 8192
   },
-  "grok-2-vision-latest": {
-    vision: true,
+  "grok-3-mini-fast-beta": {
+    vision: false,
     tools: true,
     maxTokens: 32768,
-    outputTokens: 4096
+    outputTokens: 8192
   },
-  // Grok Beta (legacy)
-  "grok-beta": {
+  // Grok Code Fast (August 2025)
+  "grok-code-fast-1": {
     vision: false,
     tools: true,
+    maxTokens: 256e3,
+    outputTokens: 16384
+  },
+  // Grok 2 (Legacy - for backward compatibility)
+  "grok-2": {
+    vision: true,
+    tools: true,
     maxTokens: 131072,
     outputTokens: 4096
   },
-  "grok-vision-beta": {
+  "grok-2-latest": {
     vision: true,
     tools: true,
-    maxTokens: 8192,
+    maxTokens: 131072,
+    outputTokens: 4096
+  },
+  "grok-2-mini": {
+    vision: false,
+    tools: true,
+    maxTokens: 131072,
     outputTokens: 4096
   }
 };
@@ -3508,7 +5096,7 @@ function createXAI(config = {}) {
   const apiKey = config.apiKey ?? process.env.XAI_API_KEY ?? "";
   return {
     name: "xai",
-    supportedModels: Object.keys(XAI_MODELS),
+    supportedModels: Object.keys(XAI_MODELS2),
     languageModel(modelId) {
       return createXAIAdapter({
         apiKey,
@@ -3517,7 +5105,7 @@ function createXAI(config = {}) {
       });
     },
     getCapabilities(modelId) {
-      const model = XAI_MODELS[modelId] ?? XAI_MODELS["grok-2"];
+      const model = XAI_MODELS2[modelId] ?? XAI_MODELS2["grok-3-fast-beta"];
       return {
         supportsVision: model.vision,
         supportsTools: model.tools,
@@ -3596,12 +5184,12 @@ function createAzure(config) {
 
 // src/providers/openai.ts
 function transformTools(tools) {
-  return tools.map((tool) => ({
+  return tools.map((tool2) => ({
     type: "function",
     function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.inputSchema
+      name: tool2.name,
+      description: tool2.description,
+      parameters: tool2.inputSchema
     }
   }));
 }
@@ -3687,10 +5275,10 @@ var openaiFormatter = {
 
 // src/providers/anthropic.ts
 function transformTools2(tools) {
-  return tools.map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    input_schema: tool.inputSchema
+  return tools.map((tool2) => ({
+    name: tool2.name,
+    description: tool2.description,
+    input_schema: tool2.inputSchema
   }));
 }
 function parseToolCalls2(response) {
@@ -3768,10 +5356,10 @@ var anthropicFormatter = {
 function transformTools3(tools) {
   return [
     {
-      functionDeclarations: tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.inputSchema
+      functionDeclarations: tools.map((tool2) => ({
+        name: tool2.name,
+        description: tool2.description,
+        parameters: tool2.inputSchema
       }))
     }
   ];
@@ -3897,7 +5485,6 @@ var formatters = {
   gemini: geminiFormatter,
   // Alias
   // OpenAI-compatible providers use openaiFormatter
-  groq: openaiFormatter,
   ollama: openaiFormatter,
   xai: openaiFormatter,
   azure: openaiFormatter
@@ -3921,7 +5508,6 @@ function getSupportedProviders() {
 // 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));
@@ -4080,8 +5666,8 @@ function buildConversation(messages, systemPrompt) {
 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) {
+    const tool2 = tools.find((t) => t.name === toolCall.name);
+    if (!tool2) {
       if (debug) {
         console.warn(`[AgentLoop] Unknown tool: ${toolCall.name}`);
       }
@@ -4108,9 +5694,9 @@ async function executeToolCalls(toolCalls, tools, executeServerTool, waitForClie
     });
     try {
       let response;
-      if (tool.location === "server") {
-        if (tool.handler) {
-          response = await tool.handler(toolCall.input);
+      if (tool2.location === "server") {
+        if (tool2.handler) {
+          response = await tool2.handler(toolCall.input);
         } else if (executeServerTool) {
           response = await executeServerTool(toolCall.name, toolCall.input);
         } else {
@@ -4169,13 +5755,14 @@ async function executeToolCalls(toolCalls, tools, executeServerTool, waitForClie
 
 exports.AnthropicAdapter = AnthropicAdapter;
 exports.AzureAdapter = AzureAdapter;
+exports.DEFAULT_CAPABILITIES = DEFAULT_CAPABILITIES;
 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.anthropic = anthropic;
 exports.anthropicFormatter = anthropicFormatter;
 exports.createAnthropic = createAnthropic;
 exports.createAnthropicAdapter = createAnthropicAdapter;
@@ -4185,8 +5772,6 @@ 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;
@@ -4200,17 +5785,26 @@ exports.createSSEResponse = createSSEResponse;
 exports.createXAI = createXAI;
 exports.createXAIAdapter = createXAIAdapter;
 exports.formatSSEData = formatSSEData;
+exports.formatToolsForAnthropic = formatToolsForAnthropic;
+exports.formatToolsForGoogle = formatToolsForGoogle;
+exports.formatToolsForOpenAI = formatToolsForOpenAI;
 exports.geminiFormatter = geminiFormatter;
+exports.generateText = generateText;
 exports.getAvailableProviders = getAvailableProviders;
 exports.getFormatter = getFormatter;
 exports.getModelCapabilities = getModelCapabilities;
 exports.getProvider = getProvider;
 exports.getSupportedProviders = getSupportedProviders;
+exports.google = google;
 exports.hasProvider = hasProvider;
 exports.isProviderSupported = isProviderSupported;
 exports.listProviders = listProviders;
+exports.openai = openai;
 exports.openaiFormatter = openaiFormatter;
 exports.registerProvider = registerProvider;
 exports.runAgentLoop = runAgentLoop;
+exports.streamText = streamText;
+exports.tool = tool;
+exports.xai = xai;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map