@absolutejs/ai 0.0.1

package/dist/ai/index.js

@@ -0,0 +1,3317 @@
+// @bun
+// src/ai/providers/openai.ts
+var DEFAULT_BASE_URL = "https://api.openai.com";
+var SSE_DATA_PREFIX_LENGTH = 6;
+var DONE_SENTINEL = "[DONE]";
+var NOT_FOUND = -1;
+var isRecord = (value) => typeof value === "object" && value !== null;
+var isRecordArray = (value) => Array.isArray(value) && value.length > 0 && isRecord(value[0]);
+var hasArrayContent = (msg) => typeof msg.content !== "string" && Array.isArray(msg.content);
+var buildToolMessages = (blocks) => {
+  const toolUseBlocks = blocks.filter((block) => block.type === "tool_use");
+  const toolResultBlocks = blocks.filter((block) => block.type === "tool_result");
+  const messages = [];
+  if (toolUseBlocks.length > 0) {
+    messages.push({
+      content: null,
+      role: "assistant",
+      tool_calls: toolUseBlocks.map((block) => ({
+        function: {
+          arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input),
+          name: block.name
+        },
+        id: block.id,
+        type: "function"
+      }))
+    });
+  }
+  for (const result of toolResultBlocks) {
+    messages.push({
+      content: typeof result.content === "string" ? result.content : "",
+      role: "tool",
+      tool_call_id: result.tool_use_id
+    });
+  }
+  return messages;
+};
+var processMessageAtIndex = (result, msg, idx) => {
+  if (!hasArrayContent(msg)) {
+    return;
+  }
+  const hasToolBlocks = msg.content.some((block) => block.type === "tool_use" || block.type === "tool_result");
+  if (!hasToolBlocks) {
+    return;
+  }
+  const toolMessages = buildToolMessages(msg.content);
+  result.splice(idx, 1, ...toolMessages);
+};
+var convertSingleMessage = (result, msg, idx) => {
+  if (!msg) {
+    return;
+  }
+  processMessageAtIndex(result, msg, idx);
+};
+var convertToolResultMessages = (messages, params) => {
+  const result = [...messages];
+  for (let idx = 0;idx < params.messages.length; idx++) {
+    convertSingleMessage(result, params.messages[idx], idx);
+  }
+  return result;
+};
+var mapToolDefinitions = (tools) => tools.map((tool) => ({
+  function: {
+    description: tool.description,
+    name: tool.name,
+    parameters: tool.input_schema
+  },
+  type: "function"
+}));
+var mapContentBlockToOpenAI = (block) => {
+  if (block.type === "image") {
+    return {
+      image_url: {
+        url: `data:${block.source.media_type};base64,${block.source.data}`
+      },
+      type: "image_url"
+    };
+  }
+  if (block.type === "document") {
+    return {
+      file: {
+        file_data: `data:${block.source.media_type};base64,${block.source.data}`,
+        filename: block.name ?? "document.pdf"
+      },
+      type: "file"
+    };
+  }
+  if (block.type === "text") {
+    return { text: block.content, type: "text" };
+  }
+  return null;
+};
+var mapOpenAIContent = (msg) => {
+  if (typeof msg.content === "string") {
+    return msg.content;
+  }
+  const hasMedia = msg.content.some((block) => block.type === "image" || block.type === "document");
+  if (!hasMedia) {
+    return null;
+  }
+  return msg.content.map(mapContentBlockToOpenAI).filter((mapped) => mapped !== null);
+};
+var buildRequestBody = (params) => {
+  const messages = convertToolResultMessages(params.messages.map((msg) => ({
+    content: mapOpenAIContent(msg),
+    role: msg.role
+  })), params);
+  const body = {
+    messages,
+    model: params.model,
+    stream: true,
+    stream_options: { include_usage: true }
+  };
+  if (params.tools && params.tools.length > 0) {
+    body.tools = mapToolDefinitions(params.tools);
+  }
+  return body;
+};
+var parseToolInput = (rawArguments) => {
+  try {
+    return JSON.parse(rawArguments);
+  } catch {
+    return rawArguments;
+  }
+};
+var flushPendingToolCalls = function* (pendingToolCalls) {
+  for (const [, tool] of pendingToolCalls) {
+    const input = parseToolInput(tool.arguments);
+    yield {
+      id: tool.id,
+      input,
+      name: tool.name,
+      type: "tool_use"
+    };
+  }
+  pendingToolCalls.clear();
+};
+var extractUsage = (parsedUsage) => ({
+  inputTokens: parsedUsage.prompt_tokens ?? 0,
+  outputTokens: parsedUsage.completion_tokens ?? 0
+});
+var resolveToolCallIndex = (toolCall) => {
+  const raw = typeof toolCall.index === "number" ? toolCall.index : NOT_FOUND;
+  return raw < 0 ? undefined : raw;
+};
+var initPendingToolCall = (toolCall, func, index, pendingToolCalls) => {
+  if (pendingToolCalls.has(index)) {
+    return;
+  }
+  const toolId = typeof toolCall.id === "string" ? toolCall.id : "";
+  const toolName = func && typeof func.name === "string" ? func.name : "";
+  pendingToolCalls.set(index, {
+    arguments: "",
+    id: toolId,
+    name: toolName
+  });
+};
+var updatePendingToolCall = (toolCall, func, pending) => {
+  if (typeof toolCall.id === "string") {
+    pending.id = toolCall.id;
+  }
+  if (func && typeof func.name === "string") {
+    pending.name = func.name;
+  }
+  if (func && typeof func.arguments === "string") {
+    pending.arguments += func.arguments;
+  }
+};
+var processToolCallDelta = (toolCall, pendingToolCalls) => {
+  const index = resolveToolCallIndex(toolCall);
+  if (index === undefined) {
+    return;
+  }
+  const func = isRecord(toolCall.function) ? toolCall.function : null;
+  initPendingToolCall(toolCall, func, index, pendingToolCalls);
+  const pending = pendingToolCalls.get(index);
+  if (!pending) {
+    return;
+  }
+  updatePendingToolCall(toolCall, func, pending);
+};
+var processToolCallDeltas = (toolCalls, pendingToolCalls) => {
+  for (const toolCall of toolCalls) {
+    processToolCallDelta(toolCall, pendingToolCalls);
+  }
+};
+var processDelta = function* (delta, pendingToolCalls) {
+  if (typeof delta.content === "string") {
+    yield { content: delta.content, type: "text" };
+  }
+  if (isRecordArray(delta.tool_calls)) {
+    processToolCallDeltas(delta.tool_calls, pendingToolCalls);
+  }
+};
+var processChoice = function* (choice, pendingToolCalls) {
+  const delta = isRecord(choice.delta) ? choice.delta : null;
+  if (delta) {
+    yield* processDelta(delta, pendingToolCalls);
+  }
+  if (choice.finish_reason === "tool_calls") {
+    yield* flushPendingToolCalls(pendingToolCalls);
+  }
+};
+var narrowUsageRecord = (parsed) => {
+  if (!isRecord(parsed.usage)) {
+    return;
+  }
+  const { usage } = parsed;
+  const promptTokens = typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0;
+  const completionTokens = typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0;
+  return extractUsage({
+    completion_tokens: completionTokens,
+    prompt_tokens: promptTokens
+  });
+};
+var processSSELine = function* (line, pendingToolCalls, currentUsage) {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith("data: ")) {
+    return;
+  }
+  const data = trimmed.slice(SSE_DATA_PREFIX_LENGTH);
+  if (data === DONE_SENTINEL) {
+    yield* flushPendingToolCalls(pendingToolCalls);
+    yield { type: "done", usage: currentUsage };
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return;
+  }
+  const usageUpdate = narrowUsageRecord(parsed);
+  if (usageUpdate) {
+    yield { type: "usage_update", usage: usageUpdate };
+  }
+  const { choices } = parsed;
+  if (!isRecordArray(choices)) {
+    return;
+  }
+  const [firstChoice] = choices;
+  if (!firstChoice) {
+    return;
+  }
+  yield* processChoice(firstChoice, pendingToolCalls);
+};
+var isUsageUpdate = (chunk) => chunk.type === "usage_update";
+var collectYieldableChunks = (line, pendingToolCalls, usageRef) => {
+  const allChunks = Array.from(processSSELine(line, pendingToolCalls, usageRef.current));
+  const usageChunks = allChunks.filter(isUsageUpdate);
+  const lastUsage = usageChunks.at(NOT_FOUND);
+  if (lastUsage) {
+    usageRef.current = lastUsage.usage;
+  }
+  return allChunks.filter((chunk) => !isUsageUpdate(chunk));
+};
+var processSSELines = function* (lines, pendingToolCalls, usageRef) {
+  for (const line of lines) {
+    yield* collectYieldableChunks(line, pendingToolCalls, usageRef);
+  }
+};
+var processStreamValue = (value, decoder, state) => {
+  state.buffer += decoder.decode(value, { stream: true });
+  const lines = state.buffer.split(`
+`);
+  state.buffer = lines.pop() ?? "";
+  return lines;
+};
+var drainReader = async function* (reader, decoder, state, signal) {
+  for (let result = await reader.read();!result.done && !signal?.aborted; result = await reader.read()) {
+    const lines = processStreamValue(result.value, decoder, state);
+    yield* processSSELines(lines, state.pendingToolCalls, state.usageRef);
+  }
+};
+var parseSSEStream = async function* (body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  const state = {
+    buffer: "",
+    pendingToolCalls: new Map,
+    usageRef: { current: undefined }
+  };
+  try {
+    yield* drainReader(reader, decoder, state, signal);
+    yield { type: "done", usage: state.usageRef.current };
+  } finally {
+    reader.releaseLock();
+  }
+};
+var fetchOpenAIStream = async function* (baseUrl, apiKey, body, signal) {
+  const response = await fetch(`${baseUrl}/v1/chat/completions`, {
+    body: JSON.stringify(body),
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "POST",
+    signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`OpenAI API error ${response.status}: ${errorText}`);
+  }
+  if (!response.body) {
+    throw new Error("OpenAI API returned no response body");
+  }
+  yield* parseSSEStream(response.body, signal);
+};
+var openai = (config) => {
+  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+  return {
+    stream: (params) => {
+      const body = buildRequestBody(params);
+      return fetchOpenAIStream(baseUrl, config.apiKey, body, params.signal);
+    }
+  };
+};
+
+// src/ai/providers/openaiCompatible.ts
+var alibaba = (config) => openaiCompatible({
+  apiKey: config.apiKey,
+  baseUrl: "https://dashscope-intl.aliyuncs.com/compatible-mode"
+});
+var deepseek = (config) => openaiCompatible({
+  apiKey: config.apiKey,
+  baseUrl: "https://api.deepseek.com"
+});
+var google = (config) => openaiCompatible({
+  apiKey: config.apiKey,
+  baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai"
+});
+var meta = (config) => openaiCompatible({
+  apiKey: config.apiKey,
+  baseUrl: "https://api.llama.com/compat/v1"
+});
+var mistralai = (config) => openaiCompatible({
+  apiKey: config.apiKey,
+  baseUrl: "https://api.mistral.ai"
+});
+var moonshot = (config) => openaiCompatible({
+  apiKey: config.apiKey,
+  baseUrl: "https://api.moonshot.ai"
+});
+var openaiCompatible = (config) => openai({ apiKey: config.apiKey, baseUrl: config.baseUrl });
+var xai = (config) => openaiCompatible({
+  apiKey: config.apiKey,
+  baseUrl: "https://api.x.ai"
+});
+
+// src/ai/providers/openaiResponses.ts
+var DEFAULT_BASE_URL2 = "https://api.openai.com";
+var EVENT_PREFIX_LENGTH = 7;
+var DATA_PREFIX_LENGTH = 6;
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var isRecordArray2 = (value) => Array.isArray(value) && value.length > 0 && isRecord2(value[0]);
+var mapBlockToResponsesFormat = (block) => {
+  if (block.type === "text") {
+    return { text: block.content, type: "input_text" };
+  }
+  if (block.type === "image") {
+    return {
+      image_url: {
+        url: `data:${block.source.media_type};base64,${block.source.data}`
+      },
+      type: "input_image"
+    };
+  }
+  if (block.type === "document") {
+    return {
+      file: {
+        file_data: `data:${block.source.media_type};base64,${block.source.data}`,
+        filename: block.name ?? "document.pdf"
+      },
+      type: "input_file"
+    };
+  }
+  return null;
+};
+var mapContentToResponsesFormat = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = content.map(mapBlockToResponsesFormat).filter((mapped) => mapped !== null);
+  return parts.length > 0 ? parts : "";
+};
+var hasToolBlocks = (content) => content.some((block) => block.type === "tool_use" || block.type === "tool_result");
+var convertToolBlock = (block) => {
+  if (block.type === "tool_use") {
+    return {
+      arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input),
+      call_id: block.id,
+      name: block.name,
+      type: "function_call"
+    };
+  }
+  if (block.type === "tool_result") {
+    return {
+      call_id: block.tool_use_id,
+      output: typeof block.content === "string" ? block.content : "",
+      type: "function_call_output"
+    };
+  }
+  return null;
+};
+var convertToolBlocks = (content) => content.map(convertToolBlock).filter((converted) => converted !== null);
+var convertMessage = (msg) => {
+  if (typeof msg.content !== "string" && Array.isArray(msg.content) && hasToolBlocks(msg.content)) {
+    return convertToolBlocks(msg.content);
+  }
+  const content = mapContentToResponsesFormat(msg.content);
+  return [
+    {
+      content,
+      role: msg.role === "system" ? "developer" : msg.role,
+      type: "message"
+    }
+  ];
+};
+var buildInput = (messages) => {
+  const input = [];
+  for (const msg of messages) {
+    input.push(...convertMessage(msg));
+  }
+  return input;
+};
+var mapToolDefinition = (tool) => ({
+  description: tool.description,
+  name: tool.name,
+  parameters: tool.input_schema,
+  type: "function"
+});
+var buildTools = (tools, isImageModel) => {
+  const mapped = tools ? tools.map(mapToolDefinition) : [];
+  const result = [...mapped];
+  if (isImageModel) {
+    result.push({ type: "image_generation" });
+  }
+  return result.length > 0 ? result : undefined;
+};
+var buildRequestBody2 = (params, isImageModel) => {
+  const body = {
+    input: buildInput(params.messages),
+    model: params.model,
+    stream: true
+  };
+  if (params.systemPrompt) {
+    body.instructions = params.systemPrompt;
+  }
+  const tools = buildTools(params.tools, isImageModel);
+  if (tools) {
+    body.tools = tools;
+  }
+  if (params.thinking) {
+    body.reasoning = {
+      effort: "high",
+      summary: "auto"
+    };
+  }
+  return body;
+};
+var parseJSON = (data) => {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+};
+var parseToolInput2 = (rawArguments) => {
+  try {
+    return JSON.parse(rawArguments);
+  } catch {
+    return rawArguments;
+  }
+};
+var extractUsage2 = (response) => {
+  if (!isRecord2(response.usage)) {
+    return;
+  }
+  const { usage } = response;
+  return {
+    inputTokens: typeof usage.input_tokens === "number" ? usage.input_tokens : 0,
+    outputTokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0
+  };
+};
+var extractMimeFormat = (mimeType) => {
+  if (typeof mimeType !== "string") {
+    return "png";
+  }
+  if (mimeType.includes("jpeg"))
+    return "jpeg";
+  if (mimeType.includes("webp"))
+    return "webp";
+  return "png";
+};
+var processTextDelta = function* (parsed) {
+  if (typeof parsed.delta === "string") {
+    yield { content: parsed.delta, type: "text" };
+  }
+};
+var processPartialImage = function* (parsed) {
+  const itemId = typeof parsed.item_id === "string" ? parsed.item_id : undefined;
+  const b64 = typeof parsed.partial_image_b64 === "string" ? parsed.partial_image_b64 : undefined;
+  if (b64) {
+    yield {
+      data: b64,
+      format: "png",
+      imageId: itemId,
+      isPartial: true,
+      type: "image"
+    };
+  }
+};
+var processFunctionCallArgumentsDelta = (parsed, pendingCalls) => {
+  const itemId = typeof parsed.item_id === "string" ? parsed.item_id : "";
+  const callId = typeof parsed.call_id === "string" ? parsed.call_id : "";
+  const delta = typeof parsed.arguments_delta === "string" ? parsed.arguments_delta : "";
+  const existing = pendingCalls.get(itemId);
+  if (existing) {
+    existing.arguments += delta;
+  } else {
+    pendingCalls.set(itemId, {
+      arguments: delta,
+      callId,
+      name: ""
+    });
+  }
+};
+var processFunctionCallArgumentsDone = function* (parsed, pendingCalls) {
+  const itemId = typeof parsed.item_id === "string" ? parsed.item_id : "";
+  const callId = typeof parsed.call_id === "string" ? parsed.call_id : "";
+  const fullArgs = typeof parsed.arguments === "string" ? parsed.arguments : "";
+  const pending = pendingCalls.get(itemId);
+  const name = pending?.name ?? "";
+  const args = fullArgs || pending?.arguments || "";
+  pendingCalls.delete(itemId);
+  yield {
+    id: callId || pending?.callId || itemId,
+    input: parseToolInput2(args),
+    name,
+    type: "tool_use"
+  };
+};
+var processOutputItemAdded = (parsed, pendingCalls) => {
+  if (!isRecord2(parsed.item)) {
+    return;
+  }
+  const { item } = parsed;
+  const itemId = typeof item.id === "string" ? item.id : "";
+  const itemType = typeof item.type === "string" ? item.type : "";
+  if (itemType !== "function_call") {
+    return;
+  }
+  const callId = typeof item.call_id === "string" ? item.call_id : "";
+  const name = typeof item.name === "string" ? item.name : "";
+  pendingCalls.set(itemId, {
+    arguments: "",
+    callId,
+    name
+  });
+};
+var isCompletedImageGeneration = (item) => item.type === "image_generation_call" && item.status === "completed" && typeof item.result === "string" && item.result !== "";
+var buildImageChunk = (item) => ({
+  data: typeof item.result === "string" ? item.result : "",
+  format: extractMimeFormat(item.output_format),
+  imageId: typeof item.id === "string" ? item.id : undefined,
+  isPartial: false,
+  revisedPrompt: typeof item.revised_prompt === "string" ? item.revised_prompt : undefined,
+  type: "image"
+});
+var extractImageFromOutput = function* (output) {
+  const completedImages = output.filter(isCompletedImageGeneration);
+  for (const item of completedImages) {
+    yield buildImageChunk(item);
+  }
+};
+var processCompleted = function* (parsed) {
+  if (!isRecord2(parsed.response)) {
+    yield { type: "done", usage: undefined };
+    return;
+  }
+  const { response } = parsed;
+  const usage = extractUsage2(response);
+  if (isRecordArray2(response.output)) {
+    yield* extractImageFromOutput(response.output);
+  }
+  yield { type: "done", usage };
+};
+var processSSEEvent = function* (eventType, parsed, pendingCalls) {
+  switch (eventType) {
+    case "response.reasoning_summary_text.delta": {
+      const delta = typeof parsed.delta === "string" ? parsed.delta : "";
+      if (!delta)
+        break;
+      yield {
+        content: delta,
+        type: "thinking"
+      };
+      break;
+    }
+    case "response.output_text.delta":
+      yield* processTextDelta(parsed);
+      break;
+    case "response.image_generation_call.partial_image":
+      yield* processPartialImage(parsed);
+      break;
+    case "response.output_item.added":
+      processOutputItemAdded(parsed, pendingCalls);
+      break;
+    case "response.function_call_arguments.delta":
+      processFunctionCallArgumentsDelta(parsed, pendingCalls);
+      break;
+    case "response.function_call_arguments.done":
+      yield* processFunctionCallArgumentsDone(parsed, pendingCalls);
+      break;
+    case "response.completed":
+      yield* processCompleted(parsed);
+      break;
+    case "response.failed":
+    case "response.incomplete": {
+      const respObj = isRecord2(parsed.response) ? parsed.response : parsed;
+      const errMsg = isRecord2(respObj.error) && typeof respObj.error.message === "string" ? respObj.error.message : `OpenAI Responses API: ${eventType}`;
+      throw new Error(errMsg);
+    }
+  }
+};
+var flushSSEBuffer = function* (state) {
+  if (!state.currentEvent || !state.buffer) {
+    return;
+  }
+  const parsed = parseJSON(state.buffer);
+  if (parsed) {
+    yield* processSSEEvent(state.currentEvent, parsed, state.pendingCalls);
+  }
+  state.currentEvent = "";
+  state.buffer = "";
+};
+var parseSSELine = (trimmed, state) => {
+  if (trimmed.startsWith("event: ")) {
+    state.currentEvent = trimmed.slice(EVENT_PREFIX_LENGTH);
+  } else if (trimmed.startsWith("data: ")) {
+    state.buffer = trimmed.slice(DATA_PREFIX_LENGTH);
+  }
+};
+var processSSELine2 = function* (line, state) {
+  const trimmed = line.trim();
+  if (trimmed) {
+    parseSSELine(trimmed, state);
+    return;
+  }
+  yield* flushSSEBuffer(state);
+};
+var processSSELines2 = function* (lines, state) {
+  for (const line of lines) {
+    yield* processSSELine2(line, state);
+  }
+};
+var drainReader2 = async function* (reader, decoder, state, signal) {
+  let textBuffer = "";
+  for (let result = await reader.read();!result.done && !signal?.aborted; result = await reader.read()) {
+    textBuffer += decoder.decode(result.value, { stream: true });
+    const lines = textBuffer.split(`
+`);
+    textBuffer = lines.pop() ?? "";
+    yield* processSSELines2(lines, state);
+  }
+  if (textBuffer.trim()) {
+    yield* processSSELines2([textBuffer, ""], state);
+  }
+};
+var parseSSEStream2 = async function* (body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  const state = {
+    buffer: "",
+    currentEvent: "",
+    pendingCalls: new Map,
+    usage: undefined
+  };
+  try {
+    yield* drainReader2(reader, decoder, state, signal);
+  } finally {
+    reader.releaseLock();
+  }
+};
+var fetchResponsesStream = async function* (baseUrl, apiKey, body, signal) {
+  const response = await fetch(`${baseUrl}/v1/responses`, {
+    body: JSON.stringify(body),
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "POST",
+    signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`OpenAI Responses API error ${response.status}: ${errorText}`);
+  }
+  if (!response.body) {
+    throw new Error("OpenAI Responses API returned no response body");
+  }
+  yield* parseSSEStream2(response.body, signal);
+};
+var resolveImageModels = (imageModels) => {
+  if (!imageModels) {
+    return new Set;
+  }
+  if (imageModels instanceof Set) {
+    return imageModels;
+  }
+  return new Set(imageModels);
+};
+var openaiResponses = (config) => {
+  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL2;
+  const imageModels = resolveImageModels(config.imageModels);
+  return {
+    stream: (params) => {
+      const isImageModel = imageModels.has(params.model);
+      const body = buildRequestBody2(params, isImageModel);
+      return fetchResponsesStream(baseUrl, config.apiKey, body, params.signal);
+    }
+  };
+};
+
+// src/ai/providers/gemini.ts
+var DEFAULT_BASE_URL3 = "https://generativelanguage.googleapis.com";
+var SSE_DATA_PREFIX_LENGTH2 = 6;
+var isRecord3 = (value) => typeof value === "object" && value !== null;
+var isRecordArray3 = (value) => Array.isArray(value) && value.length > 0 && isRecord3(value[0]);
+var mapRole = (role) => {
+  if (role === "assistant" || role === "system")
+    return "model";
+  return "user";
+};
+var mapContentBlock = (block) => {
+  switch (block.type) {
+    case "text":
+      return { text: block.content };
+    case "image":
+      return {
+        inlineData: {
+          data: block.source.data,
+          mimeType: block.source.media_type
+        }
+      };
+    case "document":
+      return {
+        inlineData: {
+          data: block.source.data,
+          mimeType: block.source.media_type
+        }
+      };
+    case "tool_use":
+      return {
+        functionCall: {
+          args: typeof block.input === "string" ? JSON.parse(block.input) : block.input,
+          name: block.name
+        }
+      };
+    case "tool_result":
+      return {
+        functionResponse: {
+          name: block.tool_use_id,
+          response: { result: block.content }
+        }
+      };
+    default:
+      return null;
+  }
+};
+var convertMessageContent = (content) => {
+  if (typeof content === "string") {
+    return [{ text: content }];
+  }
+  return content.map(mapContentBlock).filter((mapped) => mapped !== null);
+};
+var hasFunctionResponse = (content) => content.some((block) => block.type === "tool_result");
+var convertSingleMessage2 = (msg) => {
+  if (typeof msg.content !== "string" && hasFunctionResponse(msg.content)) {
+    return { parts: convertMessageContent(msg.content), role: "user" };
+  }
+  return {
+    parts: convertMessageContent(msg.content),
+    role: mapRole(msg.role)
+  };
+};
+var convertMessages = (messages) => messages.map(convertSingleMessage2);
+var mapToolDefinitions2 = (tools) => tools.map((tool) => ({
+  description: tool.description,
+  name: tool.name,
+  parameters: tool.input_schema
+}));
+var buildRequestBody3 = (params, isImageModel) => {
+  const body = {
+    contents: convertMessages(params.messages)
+  };
+  if (isImageModel) {
+    body.generationConfig = {
+      responseModalities: ["TEXT", "IMAGE"]
+    };
+  }
+  if (params.systemPrompt) {
+    body.systemInstruction = {
+      parts: [{ text: params.systemPrompt }]
+    };
+  }
+  if (params.tools && params.tools.length > 0) {
+    body.tools = [
+      { functionDeclarations: mapToolDefinitions2(params.tools) }
+    ];
+  }
+  return body;
+};
+var extractMimeFormat2 = (mimeType) => {
+  if (typeof mimeType !== "string") {
+    return "png";
+  }
+  if (mimeType.includes("jpeg") || mimeType.includes("jpg"))
+    return "jpeg";
+  if (mimeType.includes("webp"))
+    return "webp";
+  return "png";
+};
+var processTextPart = function* (part) {
+  if (typeof part.text === "string" && part.text) {
+    yield { content: part.text, type: "text" };
+  }
+};
+var processInlineDataPart = function* (inlineData) {
+  const data = typeof inlineData.data === "string" ? inlineData.data : "";
+  const { mimeType } = inlineData;
+  if (!data) {
+    return;
+  }
+  yield {
+    data,
+    format: extractMimeFormat2(mimeType),
+    isPartial: false,
+    type: "image"
+  };
+};
+var processFunctionCallPart = function* (functionCall) {
+  const name = typeof functionCall.name === "string" ? functionCall.name : "";
+  const args = functionCall.args ?? {};
+  yield {
+    id: `gemini-${name}-${Date.now()}`,
+    input: args,
+    name,
+    type: "tool_use"
+  };
+};
+var processPart = function* (part) {
+  if ("text" in part) {
+    yield* processTextPart(part);
+  }
+  if (isRecord3(part.inlineData)) {
+    yield* processInlineDataPart(part.inlineData);
+  }
+  if (isRecord3(part.functionCall)) {
+    yield* processFunctionCallPart(part.functionCall);
+  }
+};
+var extractUsage3 = (parsed) => {
+  if (!isRecord3(parsed.usageMetadata)) {
+    return;
+  }
+  const { usageMetadata } = parsed;
+  return {
+    inputTokens: typeof usageMetadata.promptTokenCount === "number" ? usageMetadata.promptTokenCount : 0,
+    outputTokens: typeof usageMetadata.candidatesTokenCount === "number" ? usageMetadata.candidatesTokenCount : 0
+  };
+};
+var processChunk = function* (parsed, state) {
+  const usage = extractUsage3(parsed);
+  if (usage) {
+    state.usage = usage;
+  }
+  if (!isRecordArray3(parsed.candidates)) {
+    return;
+  }
+  const [candidate] = parsed.candidates;
+  if (!candidate || !isRecord3(candidate.content)) {
+    return;
+  }
+  const { content } = candidate;
+  if (!isRecordArray3(content.parts)) {
+    return;
+  }
+  for (const part of content.parts) {
+    yield* processPart(part);
+  }
+};
+var processSSELine3 = function* (line, state) {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith("data: ")) {
+    return;
+  }
+  const data = trimmed.slice(SSE_DATA_PREFIX_LENGTH2);
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return;
+  }
+  yield* processChunk(parsed, state);
+};
+var processSSEBuffer = function* (lines, state) {
+  for (const line of lines) {
+    yield* processSSELine3(line, state);
+  }
+};
+var drainReader3 = async function* (reader, decoder, state, signal) {
+  let textBuffer = "";
+  for (let result = await reader.read();!result.done && !signal?.aborted; result = await reader.read()) {
+    textBuffer += decoder.decode(result.value, { stream: true });
+    const lines = textBuffer.split(`
+`);
+    textBuffer = lines.pop() ?? "";
+    yield* processSSEBuffer(lines, state);
+  }
+  if (textBuffer.trim()) {
+    yield* processSSELine3(textBuffer, state);
+  }
+  yield { type: "done", usage: state.usage };
+};
+var parseSSEStream3 = async function* (body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  const state = {
+    buffer: "",
+    usage: undefined
+  };
+  try {
+    yield* drainReader3(reader, decoder, state, signal);
+  } finally {
+    reader.releaseLock();
+  }
+};
+var fetchGeminiStream = async function* (baseUrl, apiKey, model, body, signal) {
+  const url = `${baseUrl}/v1beta/models/${model}:streamGenerateContent?alt=sse&key=${apiKey}`;
+  const response = await fetch(url, {
+    body: JSON.stringify(body),
+    headers: {
+      "Content-Type": "application/json"
+    },
+    method: "POST",
+    signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Gemini API error ${response.status}: ${errorText}`);
+  }
+  if (!response.body) {
+    throw new Error("Gemini API returned no response body");
+  }
+  yield* parseSSEStream3(response.body, signal);
+};
+var resolveImageModels2 = (raw) => {
+  if (!raw) {
+    return new Set;
+  }
+  if (raw instanceof Set) {
+    return raw;
+  }
+  return new Set(raw);
+};
+var gemini = (config) => {
+  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL3;
+  const imageModels = resolveImageModels2(config.imageModels);
+  return {
+    stream: (params) => {
+      const isImageModel = imageModels.has(params.model);
+      const body = buildRequestBody3(params, isImageModel);
+      return fetchGeminiStream(baseUrl, config.apiKey, params.model, body, params.signal);
+    }
+  };
+};
+
+// src/ai/providers/anthropic.ts
+var DEFAULT_BASE_URL4 = "https://api.anthropic.com";
+var API_VERSION = "2023-06-01";
+var MAX_TOKENS = 8192;
+var EVENT_PREFIX_LENGTH2 = 7;
+var DATA_PREFIX_LENGTH2 = 6;
+var EMPTY_CHUNKS = [];
+var isRecord4 = (val) => typeof val === "object" && val !== null;
+var mapContentBlock2 = (block) => {
+  if (block.type === "thinking") {
+    return {
+      signature: block.signature,
+      thinking: block.thinking,
+      type: "thinking"
+    };
+  }
+  if (block.type === "image") {
+    return {
+      source: block.source,
+      type: "image"
+    };
+  }
+  if (block.type === "document") {
+    return {
+      source: block.source,
+      type: "document"
+    };
+  }
+  if (block.type === "tool_result") {
+    return {
+      content: block.content,
+      tool_use_id: block.tool_use_id,
+      type: "tool_result"
+    };
+  }
+  if (block.type === "tool_use") {
+    return {
+      id: block.id,
+      input: block.input,
+      name: block.name,
+      type: "tool_use"
+    };
+  }
+  return { text: block.content, type: "text" };
+};
+var mapMessage = (msg) => ({
+  content: typeof msg.content === "string" ? msg.content : msg.content.map(mapContentBlock2),
+  role: msg.role === "system" ? "user" : msg.role
+});
+var mapToolDefinition2 = (tool) => ({
+  description: tool.description,
+  input_schema: tool.input_schema,
+  name: tool.name
+});
+var buildRequestBody4 = (params) => {
+  const messages = params.messages.filter((msg) => msg.role !== "system").map(mapMessage);
+  const body = {
+    max_tokens: MAX_TOKENS,
+    messages,
+    model: params.model,
+    stream: true
+  };
+  if (params.systemPrompt) {
+    body.system = params.systemPrompt;
+  }
+  if (params.tools && params.tools.length > 0) {
+    body.tools = params.tools.map(mapToolDefinition2);
+  }
+  if (params.thinking) {
+    body.thinking = params.thinking;
+    body.max_tokens = Math.max(MAX_TOKENS, params.thinking.budget_tokens + MAX_TOKENS);
+  }
+  return body;
+};
+var classifyLine = (line) => {
+  if (line.startsWith("event: ")) {
+    return {
+      field: "event",
+      value: line.slice(EVENT_PREFIX_LENGTH2)
+    };
+  }
+  if (line.startsWith("data: ")) {
+    return {
+      field: "data",
+      value: line.slice(DATA_PREFIX_LENGTH2)
+    };
+  }
+  return;
+};
+var applyClassified = (acc, classified) => {
+  if (!classified) {
+    return acc;
+  }
+  if (classified.field === "event") {
+    return { eventData: acc.eventData, eventType: classified.value };
+  }
+  return { eventData: classified.value, eventType: acc.eventType };
+};
+var parseEventLines = (event) => event.split(`
+`).reduce((acc, line) => applyClassified(acc, classifyLine(line)), {
+  eventData: "",
+  eventType: ""
+});
+var safeParse = (text) => {
+  try {
+    const result = JSON.parse(text);
+    return result;
+  } catch {
+    return;
+  }
+};
+var tryParseJson = (text) => {
+  const result = safeParse(text);
+  if (isRecord4(result)) {
+    return result;
+  }
+  return;
+};
+var getRecord = (obj, key) => {
+  const val = obj[key];
+  if (isRecord4(val)) {
+    return val;
+  }
+  return;
+};
+var getString = (obj, key) => {
+  const val = obj[key];
+  if (typeof val === "string") {
+    return val;
+  }
+  return "";
+};
+var getNumber = (obj, key) => {
+  const val = obj[key];
+  if (typeof val === "number") {
+    return val;
+  }
+  return 0;
+};
+var handleContentBlockStart = (parsed, state) => {
+  const block = getRecord(parsed, "content_block");
+  if (block && block.type === "tool_use") {
+    state.currentToolId = getString(block, "id");
+    state.currentToolName = getString(block, "name");
+    state.toolInputJson = "";
+    state.isThinkingBlock = false;
+  } else if (block && block.type === "thinking") {
+    state.isThinkingBlock = true;
+    state.thinkingSignature = "";
+  } else {
+    state.isThinkingBlock = false;
+  }
+};
+var handleContentBlockDelta = (parsed, state) => {
+  const delta = getRecord(parsed, "delta");
+  if (!delta) {
+    return;
+  }
+  if (delta.type === "thinking_delta") {
+    return {
+      content: getString(delta, "thinking"),
+      type: "thinking"
+    };
+  }
+  if (delta.type === "text_delta") {
+    return {
+      content: getString(delta, "text"),
+      type: "text"
+    };
+  }
+  if (delta.type === "input_json_delta") {
+    state.toolInputJson += getString(delta, "partial_json");
+  }
+  if (delta.type === "signature_delta") {
+    state.thinkingSignature += getString(delta, "signature");
+  }
+  return;
+};
+var handleContentBlockStop = (state) => {
+  if (state.isThinkingBlock && state.thinkingSignature) {
+    state.isThinkingBlock = false;
+    const signature = state.thinkingSignature;
+    state.thinkingSignature = "";
+    return {
+      content: "",
+      signature,
+      type: "thinking"
+    };
+  }
+  if (!state.currentToolId) {
+    return;
+  }
+  const input = tryParseJson(state.toolInputJson) ?? state.toolInputJson;
+  const chunk = {
+    id: state.currentToolId,
+    input,
+    name: state.currentToolName,
+    type: "tool_use"
+  };
+  state.currentToolId = "";
+  state.currentToolName = "";
+  state.toolInputJson = "";
+  return chunk;
+};
+var extractUsage4 = (usageRecord, existingUsage) => {
+  if (!usageRecord) {
+    return existingUsage;
+  }
+  return {
+    inputTokens: getNumber(usageRecord, "input_tokens") || existingUsage?.inputTokens || 0,
+    outputTokens: getNumber(usageRecord, "output_tokens") || existingUsage?.outputTokens || 0
+  };
+};
+var handleMessageDelta = (parsed, state) => {
+  const deltaUsage = getRecord(parsed, "usage");
+  state.usage = extractUsage4(deltaUsage, state.usage);
+};
+var handleMessageStart = (parsed, state) => {
+  const message = getRecord(parsed, "message");
+  if (!message) {
+    return;
+  }
+  const startUsage = getRecord(message, "usage");
+  state.usage = extractUsage4(startUsage, state.usage);
+};
+var handleError = (parsed) => {
+  const error = getRecord(parsed, "error");
+  const errorMessage = error ? getString(error, "message") : "";
+  throw new Error(errorMessage || "Anthropic API error");
+};
+var processEvent = (eventType, parsed, state) => {
+  switch (eventType) {
+    case "content_block_start": {
+      handleContentBlockStart(parsed, state);
+      return;
+    }
+    case "content_block_delta": {
+      return handleContentBlockDelta(parsed, state);
+    }
+    case "content_block_stop": {
+      return handleContentBlockStop(state);
+    }
+    case "message_delta": {
+      handleMessageDelta(parsed, state);
+      return;
+    }
+    case "message_start": {
+      handleMessageStart(parsed, state);
+      return;
+    }
+    case "message_stop": {
+      return { type: "done", usage: state.usage };
+    }
+    case "error": {
+      handleError(parsed);
+      return;
+    }
+    default: {
+      return;
+    }
+  }
+};
+var processSingleEvent = (event, state) => {
+  if (!event.trim()) {
+    return;
+  }
+  const { eventData, eventType } = parseEventLines(event);
+  if (!eventData) {
+    return;
+  }
+  const parsed = tryParseJson(eventData);
+  if (!parsed) {
+    return;
+  }
+  return processEvent(eventType, parsed, state);
+};
+var collectChunk = (event, state) => {
+  const chunk = processSingleEvent(event, state);
+  return chunk ? [chunk] : [];
+};
+var processBufferedEvents = (eventsText, state) => {
+  const events = eventsText.split(`
+
+`);
+  state.buffer = events.pop() ?? "";
+  return events.flatMap((event) => collectChunk(event, state));
+};
+var readNextChunks = async (reader, decoder, state, signal) => {
+  if (signal?.aborted) {
+    return { chunks: EMPTY_CHUNKS, done: true };
+  }
+  const { done, value } = await reader.read();
+  if (done) {
+    return { chunks: EMPTY_CHUNKS, done: true };
+  }
+  const rawText = state.buffer + decoder.decode(value, { stream: true });
+  const chunks = processBufferedEvents(rawText, state);
+  return { chunks, done: false };
+};
+var findDoneChunk = (chunks) => chunks.findIndex((c) => c.type === "done");
+var sseStreamLoop = async (reader, decoder, state, signal) => {
+  const result = await readNextChunks(reader, decoder, state, signal);
+  if (result.done) {
+    return { chunks: result.chunks, finished: true };
+  }
+  const doneIdx = findDoneChunk(result.chunks);
+  if (doneIdx >= 0) {
+    return { chunks: result.chunks.slice(0, doneIdx + 1), finished: true };
+  }
+  return { chunks: result.chunks, finished: false };
+};
+async function* streamChunks(reader, decoder, state, signal) {
+  let finished = false;
+  while (!finished) {
+    const result = await sseStreamLoop(reader, decoder, state, signal);
+    ({ finished } = result);
+    yield* result.chunks;
+  }
+}
+async function* parseSSEStream4(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  const state = {
+    buffer: "",
+    currentToolId: "",
+    currentToolName: "",
+    isThinkingBlock: false,
+    thinkingSignature: "",
+    toolInputJson: "",
+    usage: undefined
+  };
+  try {
+    yield* streamChunks(reader, decoder, state, signal);
+  } finally {
+    reader.releaseLock();
+  }
+}
+var fetchAndStream = async function* (baseUrl, config, params) {
+  const body = buildRequestBody4(params);
+  const response = await fetch(`${baseUrl}/v1/messages`, {
+    body: JSON.stringify(body),
+    headers: {
+      "anthropic-version": API_VERSION,
+      "Content-Type": "application/json",
+      "x-api-key": config.apiKey
+    },
+    method: "POST",
+    signal: params.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Anthropic API error ${response.status}: ${errorText}`);
+  }
+  if (!response.body) {
+    throw new Error("Anthropic API returned no response body");
+  }
+  yield* parseSSEStream4(response.body, params.signal);
+};
+var anthropic = (config) => {
+  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL4;
+  return {
+    stream: (params) => fetchAndStream(baseUrl, config, params)
+  };
+};
+
+// src/ai/providers/ollama.ts
+var DEFAULT_BASE_URL5 = "http://localhost:11434";
+var ZERO_TOKENS = 0;
+var DONE_CHUNK = { type: "done" };
+var mapToolDefinitions3 = (tools) => tools.map((tool) => ({
+  function: {
+    description: tool.description,
+    name: tool.name,
+    parameters: tool.input_schema
+  },
+  type: "function"
+}));
+var convertMessage2 = (msg) => {
+  if (typeof msg.content === "string") {
+    return [{ content: msg.content, role: msg.role }];
+  }
+  const results = [];
+  const toolUseBlocks = msg.content.filter((block) => block.type === "tool_use");
+  const toolResultBlocks = msg.content.filter((block) => block.type === "tool_result");
+  if (toolUseBlocks.length > 0) {
+    results.push({
+      content: "",
+      role: "assistant",
+      tool_calls: toolUseBlocks.map((block) => ({
+        function: {
+          arguments: typeof block.input === "object" && block.input !== null ? { ...block.input } : {},
+          name: block.name
+        }
+      }))
+    });
+  }
+  for (const block of toolResultBlocks) {
+    results.push({
+      content: typeof block.content === "string" ? block.content : "",
+      role: "tool"
+    });
+  }
+  return results;
+};
+var buildRequestBody5 = (params) => {
+  const messages = params.messages.flatMap(convertMessage2);
+  if (params.systemPrompt) {
+    messages.unshift({ content: params.systemPrompt, role: "system" });
+  }
+  const body = {
+    messages,
+    model: params.model,
+    stream: true
+  };
+  if (params.tools && params.tools.length > 0) {
+    body.tools = mapToolDefinitions3(params.tools);
+  }
+  return body;
+};
+var isRecord5 = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+var tryParseJSON = (text) => {
+  try {
+    const result = JSON.parse(text);
+    if (isRecord5(result)) {
+      return result;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var buildDoneChunk = (parsed) => {
+  const promptEvalCount = typeof parsed.prompt_eval_count === "number" ? parsed.prompt_eval_count : undefined;
+  const evalCount = typeof parsed.eval_count === "number" ? parsed.eval_count : undefined;
+  const totalDuration = typeof parsed.total_duration === "number" ? parsed.total_duration : undefined;
+  const hasTokenCounts = promptEvalCount !== undefined || evalCount !== undefined;
+  if (hasTokenCounts) {
+    return {
+      type: "done",
+      usage: {
+        inputTokens: promptEvalCount ?? ZERO_TOKENS,
+        outputTokens: evalCount ?? ZERO_TOKENS
+      }
+    };
+  }
+  if (totalDuration !== undefined) {
+    return {
+      type: "done",
+      usage: { inputTokens: ZERO_TOKENS, outputTokens: ZERO_TOKENS }
+    };
+  }
+  return { type: "done" };
+};
+var buildTextChunk = (content) => ({
+  content,
+  type: "text"
+});
+var extractToolCalls = (message) => {
+  const toolCalls = message.tool_calls;
+  if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
+    return [];
+  }
+  return toolCalls.filter(isRecord5).filter((call) => isRecord5(call.function)).map((call) => {
+    const func = call.function;
+    if (!isRecord5(func)) {
+      return {
+        id: crypto.randomUUID(),
+        input: {},
+        name: "",
+        type: "tool_use"
+      };
+    }
+    return {
+      id: crypto.randomUUID(),
+      input: func.arguments ?? {},
+      name: typeof func.name === "string" ? func.name : "",
+      type: "tool_use"
+    };
+  });
+};
+var extractChunks = (parsed) => {
+  const { message } = parsed;
+  if (!isRecord5(message)) {
+    return [];
+  }
+  const toolChunks = extractToolCalls(message);
+  if (toolChunks.length > 0) {
+    return toolChunks;
+  }
+  const { content } = message;
+  if (typeof content !== "string" || !content) {
+    return [];
+  }
+  return [buildTextChunk(content)];
+};
+var processLine = (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return [];
+  }
+  const parsed = tryParseJSON(trimmed);
+  if (!parsed) {
+    return [];
+  }
+  if (parsed.done === true) {
+    return [buildDoneChunk(parsed)];
+  }
+  return extractChunks(parsed);
+};
+var processBufferedLines = (lines) => lines.flatMap(processLine);
+var readStreamChunks = async (reader, decoder, buffer, signal) => {
+  const emptyChunks = [];
+  if (signal?.aborted) {
+    return {
+      allChunks: emptyChunks,
+      currentBuffer: buffer,
+      finished: true
+    };
+  }
+  const result = await reader.read();
+  const { done, value } = result;
+  if (done) {
+    return {
+      allChunks: emptyChunks,
+      currentBuffer: buffer,
+      finished: true
+    };
+  }
+  const currentBuffer = buffer + decoder.decode(value, { stream: true });
+  const lines = currentBuffer.split(`
+`);
+  const remainder = lines.pop() ?? "";
+  const allChunks = processBufferedLines(lines);
+  const finished = allChunks.some((c) => c.type === "done");
+  return { allChunks, currentBuffer: remainder, finished };
+};
+var parseNDJSONStream = async function* (body, signal) {
+  const reader = body.getReader();
+  try {
+    yield* parseNDJSONStreamInner(reader, signal);
+  } finally {
+    reader.releaseLock();
+  }
+};
+var parseNDJSONStreamInner = async function* (reader, signal) {
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let done = false;
+  while (!done) {
+    const result = await readStreamChunks(reader, decoder, buffer, signal);
+    buffer = result.currentBuffer;
+    done = result.finished;
+    yield* result.allChunks;
+  }
+  yield DONE_CHUNK;
+};
+var fetchAndStream2 = async function* (baseUrl, params) {
+  const requestBody = buildRequestBody5(params);
+  const response = await fetch(`${baseUrl}/api/chat`, {
+    body: JSON.stringify(requestBody),
+    headers: { "Content-Type": "application/json" },
+    method: "POST",
+    signal: params.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Ollama API error ${response.status}: ${errorText}`);
+  }
+  if (!response.body) {
+    throw new Error("Ollama API returned no response body");
+  }
+  yield* parseNDJSONStream(response.body, params.signal);
+};
+var ollama = (config = {}) => {
+  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL5;
+  return {
+    stream: (params) => fetchAndStream2(baseUrl, params)
+  };
+};
+
+// src/plugins/aiChat.ts
+import { Elysia } from "elysia";
+
+// src/ai/memoryStore.ts
+var createMemoryStore = () => {
+  const conversations = new Map;
+  const get = async (id) => conversations.get(id);
+  const getOrCreate = async (id) => {
+    let conversation = conversations.get(id);
+    if (!conversation) {
+      conversation = { createdAt: Date.now(), id, messages: [] };
+      conversations.set(id, conversation);
+    }
+    return conversation;
+  };
+  const set = async (id, conversation) => {
+    conversations.set(id, conversation);
+  };
+  const list = async () => Array.from(conversations.values()).map((conv) => ({
+    createdAt: conv.createdAt,
+    id: conv.id,
+    lastMessageAt: conv.lastMessageAt,
+    messageCount: conv.messages.length,
+    title: conv.title ?? "Untitled"
+  })).sort((first, second) => (second.lastMessageAt ?? second.createdAt) - (first.lastMessageAt ?? first.createdAt));
+  const remove = async (id) => {
+    conversations.delete(id);
+  };
+  return { get, getOrCreate, list, remove, set };
+};
+
+// types/typeGuards.ts
+var isValidAIClientMessage = (data) => {
+  if (!data || typeof data !== "object") {
+    return false;
+  }
+  if (!("type" in data) || typeof data.type !== "string") {
+    return false;
+  }
+  switch (data.type) {
+    case "message":
+      return "content" in data && typeof data.content === "string";
+    case "cancel":
+      return "conversationId" in data && typeof data.conversationId === "string";
+    case "branch":
+      return "messageId" in data && typeof data.messageId === "string" && "content" in data && typeof data.content === "string" && "conversationId" in data && typeof data.conversationId === "string";
+    default:
+      return false;
+  }
+};
+var isValidAIServerMessage = (data) => {
+  if (!data || typeof data !== "object") {
+    return false;
+  }
+  if (!("type" in data) || typeof data.type !== "string") {
+    return false;
+  }
+  switch (data.type) {
+    case "chunk":
+    case "thinking":
+      return "content" in data && typeof data.content === "string" && "messageId" in data && "conversationId" in data;
+    case "tool_status":
+      return "name" in data && "status" in data && "messageId" in data && "conversationId" in data;
+    case "image":
+      return "data" in data && typeof data.data === "string" && "format" in data && typeof data.format === "string" && "isPartial" in data && typeof data.isPartial === "boolean" && "messageId" in data && "conversationId" in data;
+    case "complete":
+      return "messageId" in data && "conversationId" in data;
+    case "rag_retrieved":
+      return "conversationId" in data && "messageId" in data && "sources" in data && Array.isArray(data.sources);
+    case "error":
+      return "message" in data && typeof data.message === "string";
+    default:
+      return false;
+  }
+};
+
+// src/ai/protocol.ts
+var generateId = () => crypto.randomUUID();
+var parseAIMessage = (raw) => {
+  if (raw === null || raw === undefined) {
+    return null;
+  }
+  let text;
+  if (typeof raw === "string") {
+    text = raw;
+  } else if (raw instanceof ArrayBuffer) {
+    text = new TextDecoder().decode(raw);
+  } else if (ArrayBuffer.isView(raw)) {
+    text = new TextDecoder().decode(raw);
+  } else if (typeof raw === "object") {
+    if (isValidAIClientMessage(raw)) {
+      return raw;
+    }
+    return null;
+  } else {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (isValidAIClientMessage(parsed)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var serializeAIMessage = (message) => JSON.stringify(message);
+
+// src/ai/streamAI.ts
+var WS_OPEN = 1;
+var BACKPRESSURE_THRESHOLD = 1048576;
+var BACKPRESSURE_DELAY = 10;
+var DEFAULT_MAX_TURNS = 10;
+var DEFAULT_THINKING_BUDGET = 1e4;
+var INITIAL_TURN = 0;
+var delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+var checkBackpressure = async (socket) => {
+  if (!("raw" in socket)) {
+    return;
+  }
+  const { raw } = socket;
+  if (raw && typeof raw === "object" && "bufferedAmount" in raw && typeof raw.bufferedAmount === "number" && raw.bufferedAmount > BACKPRESSURE_THRESHOLD) {
+    await delay(BACKPRESSURE_DELAY);
+  }
+};
+var sendMessage = async (socket, message) => {
+  if (socket.readyState !== WS_OPEN) {
+    return false;
+  }
+  await checkBackpressure(socket);
+  socket.send(serializeAIMessage(message));
+  return true;
+};
+var buildToolDefinitions = (tools) => Object.entries(tools).map(([name, def]) => ({
+  description: def.description,
+  input_schema: def.input,
+  name
+}));
+var extractTextContent = (chunk, onChunk) => {
+  if (!onChunk) {
+    return chunk.content;
+  }
+  const transformed = onChunk(chunk);
+  if (transformed && typeof transformed === "object" && "content" in transformed) {
+    return transformed.content;
+  }
+  return chunk.content;
+};
+var sendImageMessage = async (socket, chunk, messageId, conversationId) => sendMessage(socket, {
+  conversationId,
+  data: chunk.data,
+  format: chunk.format,
+  imageId: chunk.imageId,
+  isPartial: chunk.isPartial,
+  messageId,
+  revisedPrompt: chunk.revisedPrompt,
+  type: "image"
+});
+var sendToolRunning = async (socket, toolName, toolInput, messageId, conversationId) => sendMessage(socket, {
+  conversationId,
+  input: toolInput,
+  messageId,
+  name: toolName,
+  status: "running",
+  type: "tool_status"
+});
+var sendToolComplete = async (socket, toolName, result, messageId, conversationId) => sendMessage(socket, {
+  conversationId,
+  messageId,
+  name: toolName,
+  result,
+  status: "complete",
+  type: "tool_status"
+});
+var executeTool = async (options, toolName, toolInput) => {
+  const toolDef = options.tools?.[toolName];
+  if (!toolDef) {
+    return `Error: unknown tool "${toolName}"`;
+  }
+  try {
+    return await toolDef.handler(toolInput);
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`;
+  }
+};
+var serializeToolCall = (name, input) => `${name}:${JSON.stringify(input)}`;
+var handleToolChunkText = (chunk, state, options, socket, messageId, conversationId) => {
+  const textContent = extractTextContent(chunk, options.onChunk);
+  state.currentFullResponse += textContent;
+  sendMessage(socket, {
+    content: textContent,
+    conversationId,
+    messageId,
+    type: "chunk"
+  });
+};
+var handleToolChunkToolUse = (chunk, state) => {
+  state.pendingToolCalls.push({
+    id: chunk.id,
+    input: chunk.input,
+    name: chunk.name
+  });
+};
+var flushThinking = (state) => {
+  if (state.currentThinking) {
+    state.contentBlocks.push({
+      signature: state.currentThinking.signature || undefined,
+      thinking: state.currentThinking.text,
+      type: "thinking"
+    });
+    state.currentThinking = null;
+  }
+};
+var processToolChunk = (chunk, state, options, socket, messageId, conversationId) => {
+  let hitAnotherTool = false;
+  switch (chunk.type) {
+    case "thinking":
+      if (chunk.content) {
+        sendMessage(socket, {
+          content: chunk.content,
+          conversationId,
+          messageId,
+          type: "thinking"
+        });
+      }
+      if (!state.currentThinking) {
+        state.currentThinking = { signature: "", text: "" };
+      }
+      state.currentThinking.text += chunk.content;
+      if (chunk.signature) {
+        state.currentThinking.signature = chunk.signature;
+      }
+      break;
+    case "text":
+      flushThinking(state);
+      handleToolChunkText(chunk, state, options, socket, messageId, conversationId);
+      state.contentBlocks.push({
+        content: chunk.content,
+        type: "text"
+      });
+      break;
+    case "image":
+      sendImageMessage(socket, chunk, messageId, conversationId);
+      options.onImage?.({
+        data: chunk.data,
+        format: chunk.format,
+        imageId: chunk.imageId,
+        isPartial: chunk.isPartial,
+        revisedPrompt: chunk.revisedPrompt
+      });
+      break;
+    case "tool_use":
+      flushThinking(state);
+      handleToolChunkToolUse(chunk, state);
+      state.contentBlocks.push({
+        id: chunk.id,
+        input: typeof chunk.input === "object" && chunk.input !== null ? chunk.input : {},
+        name: chunk.name,
+        type: "tool_use"
+      });
+      hitAnotherTool = true;
+      break;
+    case "done":
+      flushThinking(state);
+      state.currentUsage = chunk.usage;
+      break;
+  }
+  return hitAnotherTool;
+};
+var processToolTurn = async (socket, options, state, messageId, conversationId, signal) => {
+  const toolCalls = [...state.pendingToolCalls];
+  state.pendingToolCalls = [];
+  state.currentMessages.push({
+    content: state.contentBlocks,
+    role: "assistant"
+  });
+  state.contentBlocks = [];
+  const toolResultBlocks = [];
+  for (const toolCall of toolCalls) {
+    await sendToolRunning(socket, toolCall.name, toolCall.input, messageId, conversationId);
+    const result = await executeTool(options, toolCall.name, toolCall.input);
+    await sendToolComplete(socket, toolCall.name, result, messageId, conversationId);
+    options.onToolUse?.(toolCall.name, toolCall.input, result);
+    toolResultBlocks.push({
+      content: result,
+      tool_use_id: toolCall.id,
+      type: "tool_result"
+    });
+    state.executedToolKeys.add(serializeToolCall(toolCall.name, toolCall.input));
+  }
+  state.currentMessages.push({
+    content: toolResultBlocks,
+    role: "user"
+  });
+  const toolDefs = options.tools ? buildToolDefinitions(options.tools) : undefined;
+  const thinkingConfig = options.thinking ? {
+    budget_tokens: typeof options.thinking === "object" ? options.thinking.budgetTokens : DEFAULT_THINKING_BUDGET,
+    type: "enabled"
+  } : undefined;
+  const stream = options.provider.stream({
+    messages: state.currentMessages,
+    model: options.model,
+    signal,
+    systemPrompt: options.systemPrompt,
+    thinking: thinkingConfig,
+    tools: toolDefs
+  });
+  await consumeToolStream(stream, state, options, socket, messageId, conversationId, signal);
+};
+var consumeToolStream = async (stream, state, options, socket, messageId, conversationId, signal) => {
+  let hitAnotherTool = false;
+  for await (const chunk of stream) {
+    if (signal.aborted)
+      break;
+    const isToolHit = processToolChunk(chunk, state, options, socket, messageId, conversationId);
+    if (isToolHit)
+      hitAnotherTool = true;
+  }
+  return hitAnotherTool;
+};
+var shouldContinueToolLoop = (state, maxTurns, signal) => state.pendingToolCalls.length > 0 && state.currentTurn < maxTurns && !signal.aborted;
+var areAllRepeatedToolCalls = (state) => state.pendingToolCalls.every((toolCall) => state.executedToolKeys.has(serializeToolCall(toolCall.name, toolCall.input)));
+var buildToolLoopResult = (state) => ({
+  fullResponse: state.currentFullResponse,
+  usage: state.currentUsage
+});
+var executeToolLoop = async (socket, options, messages, initialToolCalls, initialContentBlocks, messageId, conversationId, signal, fullResponse, turn) => {
+  const maxTurns = options.maxTurns ?? DEFAULT_MAX_TURNS;
+  const state = {
+    contentBlocks: initialContentBlocks,
+    currentFullResponse: fullResponse,
+    currentMessages: [...messages],
+    currentThinking: null,
+    currentTurn: turn,
+    currentUsage: undefined,
+    executedToolKeys: new Set,
+    pendingToolCalls: initialToolCalls
+  };
+  while (shouldContinueToolLoop(state, maxTurns, signal)) {
+    if (areAllRepeatedToolCalls(state))
+      break;
+    await processToolTurn(socket, options, state, messageId, conversationId, signal);
+    state.currentTurn++;
+  }
+  return buildToolLoopResult(state);
+};
+var sendComplete = async (socket, messageId, conversationId, usage, durationMs, model, completeMeta) => sendMessage(socket, {
+  conversationId,
+  durationMs,
+  messageId,
+  model,
+  sources: completeMeta?.sources,
+  type: "complete",
+  usage
+});
+var sendError = async (socket, err, messageId, conversationId) => sendMessage(socket, {
+  conversationId,
+  message: err instanceof Error ? err.message : String(err),
+  messageId,
+  type: "error"
+});
+var handleTextChunk = async (chunk, options, socket, messageId, conversationId) => {
+  const textContent = extractTextContent(chunk, options.onChunk);
+  await sendMessage(socket, {
+    content: textContent,
+    conversationId,
+    messageId,
+    type: "chunk"
+  });
+  return textContent;
+};
+var handleToolCalls = async (socket, options, messages, toolCalls, contentBlocks, messageId, conversationId, signal, fullResponse, startTime) => {
+  const toolResult = await executeToolLoop(socket, options, messages, toolCalls, contentBlocks, messageId, conversationId, signal, fullResponse, INITIAL_TURN);
+  await sendComplete(socket, messageId, conversationId, toolResult.usage, Date.now() - startTime, options.model, options.completeMeta);
+  options.onComplete?.(toolResult.fullResponse, toolResult.usage, options.completeMeta);
+  return toolResult;
+};
+var processStreamTextChunk = async (chunk, options, socket, messageId, conversationId) => {
+  const textContent = await handleTextChunk(chunk, options, socket, messageId, conversationId);
+  return textContent;
+};
+var processStream = async (socket, options, messages, messageId, conversationId, signal, startTime) => {
+  const toolDefs = options.tools ? buildToolDefinitions(options.tools) : undefined;
+  const thinkingConfig = options.thinking ? {
+    budget_tokens: typeof options.thinking === "object" ? options.thinking.budgetTokens : DEFAULT_THINKING_BUDGET,
+    type: "enabled"
+  } : undefined;
+  const stream = options.provider.stream({
+    messages,
+    model: options.model,
+    signal,
+    systemPrompt: options.systemPrompt,
+    thinking: thinkingConfig,
+    tools: toolDefs
+  });
+  const result = await consumeStream(stream, options, socket, messages, messageId, conversationId, signal);
+  if (result.pendingToolCalls.length > 0) {
+    await handleToolCalls(socket, options, messages, result.pendingToolCalls, result.contentBlocks, messageId, conversationId, signal, result.fullResponse, startTime);
+  } else {
+    await sendComplete(socket, messageId, conversationId, result.usage, Date.now() - startTime, options.model, options.completeMeta);
+    options.onComplete?.(result.fullResponse, result.usage, options.completeMeta);
+  }
+};
+var flushStreamThinking = (state) => {
+  if (state.currentThinking) {
+    state.contentBlocks.push({
+      signature: state.currentThinking.signature || undefined,
+      thinking: state.currentThinking.text,
+      type: "thinking"
+    });
+    state.currentThinking = null;
+  }
+};
+var consumeStreamChunk = async (chunk, options, socket, state, messageId, conversationId) => {
+  switch (chunk.type) {
+    case "thinking":
+      if (chunk.content) {
+        await sendMessage(socket, {
+          content: chunk.content,
+          conversationId,
+          messageId,
+          type: "thinking"
+        });
+      }
+      if (!state.currentThinking) {
+        state.currentThinking = { signature: "", text: "" };
+      }
+      state.currentThinking.text += chunk.content;
+      if (chunk.signature) {
+        state.currentThinking.signature = chunk.signature;
+      }
+      break;
+    case "text":
+      flushStreamThinking(state);
+      state.fullResponse += await processStreamTextChunk(chunk, options, socket, messageId, conversationId);
+      state.contentBlocks.push({ content: chunk.content, type: "text" });
+      break;
+    case "image":
+      await sendImageMessage(socket, chunk, messageId, conversationId);
+      options.onImage?.({
+        data: chunk.data,
+        format: chunk.format,
+        imageId: chunk.imageId,
+        isPartial: chunk.isPartial,
+        revisedPrompt: chunk.revisedPrompt
+      });
+      break;
+    case "tool_use":
+      flushStreamThinking(state);
+      state.pendingToolCalls.push({
+        id: chunk.id,
+        input: chunk.input,
+        name: chunk.name
+      });
+      state.contentBlocks.push({
+        id: chunk.id,
+        input: typeof chunk.input === "object" && chunk.input !== null ? chunk.input : {},
+        name: chunk.name,
+        type: "tool_use"
+      });
+      break;
+    case "done":
+      flushStreamThinking(state);
+      state.usage = chunk.usage;
+      break;
+  }
+};
+var consumeStream = async (stream, options, socket, messages, messageId, conversationId, signal) => {
+  const state = {
+    contentBlocks: [],
+    currentThinking: null,
+    fullResponse: "",
+    pendingToolCalls: [],
+    usage: undefined
+  };
+  for await (const chunk of stream) {
+    if (signal.aborted)
+      break;
+    await consumeStreamChunk(chunk, options, socket, state, messageId, conversationId);
+  }
+  return state;
+};
+var streamAI = async (socket, conversationId, messageId, options) => {
+  const signal = options.signal ?? new AbortController().signal;
+  const startTime = Date.now();
+  const messages = options.messages ? [...options.messages] : [];
+  try {
+    await processStream(socket, options, messages, messageId, conversationId, signal, startTime);
+  } catch (err) {
+    await handleStreamError(socket, err, messageId, conversationId, signal, startTime);
+  }
+};
+var handleStreamError = async (socket, err, messageId, conversationId, signal, startTime) => {
+  if (signal.aborted) {
+    await sendComplete(socket, messageId, conversationId, undefined, Date.now() - startTime);
+    return;
+  }
+  await sendError(socket, err, messageId, conversationId);
+};
+
+// src/ai/streamAIToSSE.ts
+var DEFAULT_MAX_TURNS2 = 10;
+var DEFAULT_THINKING_BUDGET2 = 1e4;
+var buildToolDefinitions2 = (tools) => Object.entries(tools).map(([name, def]) => ({
+  description: def.description,
+  input_schema: def.input,
+  name
+}));
+var executeTool2 = async (options, toolName, toolInput) => {
+  const toolDef = options.tools?.[toolName];
+  if (!toolDef) {
+    return `Error: unknown tool "${toolName}"`;
+  }
+  try {
+    return await toolDef.handler(toolInput);
+  } catch (err) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`;
+  }
+};
+var buildThinkingConfig = (options) => options.thinking ? {
+  budget_tokens: typeof options.thinking === "object" ? options.thinking.budgetTokens : DEFAULT_THINKING_BUDGET2,
+  type: "enabled"
+} : undefined;
+var serializeToolCall2 = (name, input) => `${name}:${JSON.stringify(input)}`;
+var streamAIToSSE = async function* (conversationId, messageId, options, renderers) {
+  const signal = options.signal ?? new AbortController().signal;
+  const startTime = Date.now();
+  const maxTurns = options.maxTurns ?? DEFAULT_MAX_TURNS2;
+  const messages = options.messages ? [...options.messages] : [];
+  try {
+    yield* streamTurns(options, renderers, messages, signal, startTime, maxTurns);
+  } catch (err) {
+    if (signal.aborted)
+      return;
+    yield {
+      data: renderers.error(err instanceof Error ? err.message : String(err)),
+      event: "status"
+    };
+  }
+};
+var flushThinking2 = (thinking, contentBlocks) => {
+  contentBlocks.push({
+    signature: thinking.signature || undefined,
+    thinking: thinking.text,
+    type: "thinking"
+  });
+};
+var yieldCompletion = (renderers, options, fullResponse, usage, startTime) => {
+  const durationMs = Date.now() - startTime;
+  options.onComplete?.(fullResponse, usage);
+  return {
+    data: renderers.complete(usage, durationMs, options.model),
+    event: "status"
+  };
+};
+var processThinkingChunk = function* (content, signature, chunkState, renderers) {
+  chunkState.currentThinking ??= { signature: "", text: "" };
+  chunkState.currentThinking.text += content;
+  chunkState.currentThinking.signature = signature ?? chunkState.currentThinking.signature;
+  yield {
+    data: renderers.thinking(chunkState.currentThinking.text),
+    event: "thinking"
+  };
+};
+var maybeFlushThinking = (chunkState) => {
+  if (!chunkState.currentThinking)
+    return;
+  flushThinking2(chunkState.currentThinking, chunkState.contentBlocks);
+  chunkState.currentThinking = null;
+};
+var processTextChunk = function* (content, chunkState, renderers, fullResponse) {
+  maybeFlushThinking(chunkState);
+  chunkState.contentBlocks.push({
+    content,
+    type: "text"
+  });
+  yield {
+    data: renderers.chunk(content, fullResponse + content),
+    event: "content"
+  };
+};
+var processImageChunk = function* (chunk, renderers, options) {
+  yield {
+    data: renderers.image(chunk.data, chunk.format, chunk.revisedPrompt),
+    event: "images"
+  };
+  options.onImage?.({
+    data: chunk.data,
+    format: chunk.format,
+    imageId: chunk.imageId,
+    isPartial: chunk.isPartial,
+    revisedPrompt: chunk.revisedPrompt
+  });
+};
+var processToolUseChunk = (chunk, chunkState) => {
+  maybeFlushThinking(chunkState);
+  chunkState.pendingToolCalls.push({
+    id: chunk.id,
+    input: chunk.input,
+    name: chunk.name
+  });
+  chunkState.contentBlocks.push({
+    id: chunk.id,
+    input: typeof chunk.input === "object" && chunk.input !== null ? chunk.input : {},
+    name: chunk.name,
+    type: "tool_use"
+  });
+};
+var processChunk2 = function* (chunk, chunkState, renderers, options, fullResponse) {
+  switch (chunk.type) {
+    case "thinking":
+      yield* processThinkingChunk(chunk.content, chunk.signature, chunkState, renderers);
+      break;
+    case "text":
+      yield* processTextChunk(chunk.content, chunkState, renderers, fullResponse);
+      break;
+    case "image":
+      yield* processImageChunk(chunk, renderers, options);
+      break;
+    case "tool_use":
+      processToolUseChunk(chunk, chunkState);
+      break;
+    case "done":
+      maybeFlushThinking(chunkState);
+      chunkState.usage = chunk.usage;
+      break;
+  }
+};
+var executeToolCalls = async function* (pendingToolCalls, options, renderers, turnState) {
+  const toolResultBlocks = [];
+  for (const toolCall of pendingToolCalls) {
+    turnState.allToolsHtml += renderers.toolRunning(toolCall.name, toolCall.input);
+    yield { data: turnState.allToolsHtml, event: "tools" };
+    const result = await executeTool2(options, toolCall.name, toolCall.input);
+    turnState.allToolsHtml = turnState.allToolsHtml.replace(renderers.toolRunning(toolCall.name, toolCall.input), renderers.toolComplete(toolCall.name, result));
+    yield { data: turnState.allToolsHtml, event: "tools" };
+    options.onToolUse?.(toolCall.name, toolCall.input, result);
+    toolResultBlocks.push({
+      content: result,
+      tool_use_id: toolCall.id,
+      type: "tool_result"
+    });
+    turnState.executedToolKeys.add(serializeToolCall2(toolCall.name, toolCall.input));
+  }
+  return toolResultBlocks;
+};
+var consumeStream2 = async function* (stream, chunkState, renderers, options, turnState, signal) {
+  for await (const chunk of stream) {
+    if (signal.aborted)
+      break;
+    const prevResponse = turnState.fullResponse;
+    yield* processChunk2(chunk, chunkState, renderers, options, turnState.fullResponse);
+    if (chunk.type !== "text")
+      continue;
+    turnState.fullResponse = prevResponse + chunk.content;
+  }
+};
+var shouldStopToolLoop = (chunkState, turnState, signal) => {
+  if (chunkState.pendingToolCalls.length === 0 || signal.aborted) {
+    return true;
+  }
+  return chunkState.pendingToolCalls.every((toolCall) => turnState.executedToolKeys.has(serializeToolCall2(toolCall.name, toolCall.input)));
+};
+var processTurn = async function* (chunkState, options, renderers, turnState) {
+  turnState.currentMessages.push({
+    content: chunkState.contentBlocks,
+    role: "assistant"
+  });
+  const toolResults = yield* executeToolCalls(chunkState.pendingToolCalls, options, renderers, turnState);
+  turnState.currentMessages.push({
+    content: toolResults,
+    role: "user"
+  });
+};
+var streamTurns = async function* (options, renderers, messages, signal, startTime, maxTurns) {
+  const turnState = {
+    allToolsHtml: "",
+    currentMessages: [...messages],
+    executedToolKeys: new Set,
+    fullResponse: "",
+    turn: 0
+  };
+  const toolDefs = options.tools ? buildToolDefinitions2(options.tools) : undefined;
+  const thinkingConfig = buildThinkingConfig(options);
+  for (;turnState.turn <= maxTurns && !signal.aborted; turnState.turn++) {
+    const chunkState = {
+      contentBlocks: [],
+      currentThinking: null,
+      pendingToolCalls: [],
+      usage: undefined
+    };
+    const stream = options.provider.stream({
+      messages: turnState.currentMessages,
+      model: options.model,
+      signal,
+      systemPrompt: options.systemPrompt,
+      thinking: thinkingConfig,
+      tools: toolDefs
+    });
+    yield* consumeStream2(stream, chunkState, renderers, options, turnState, signal);
+    if (shouldStopToolLoop(chunkState, turnState, signal)) {
+      return void (yield yieldCompletion(renderers, options, turnState.fullResponse, chunkState.usage, startTime));
+    }
+    yield* processTurn(chunkState, options, renderers, turnState);
+  }
+  return;
+};
+
+// src/constants.ts
+var EXCLUDE_LAST_OFFSET = -1;
+var HOURS_IN_DAY = 24;
+var MILLISECONDS_IN_A_SECOND = 1000;
+var MINUTES_IN_AN_HOUR = 60;
+var SECONDS_IN_A_MINUTE = 60;
+var MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
+var MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_DAY;
+var TWO_THIRDS = 2 / 3;
+
+// src/ai/htmxRenderers.ts
+var escapeHtml = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var defaultChunk = (_text, fullContent) => `<div class="ai-content">${escapeHtml(fullContent)}</div>`;
+var defaultMessageStart = ({
+  cancelUrl,
+  content,
+  messageId,
+  sseUrl
+}) => `<div id="msg-${messageId}" class="message user">` + `<div>${escapeHtml(content)}</div>` + `</div>` + `<div id="response-${messageId}" ` + `hx-ext="sse" ` + `sse-connect="${escapeHtml(sseUrl)}" ` + `hx-swap="innerHTML">` + `<div id="sse-retrieval-${messageId}" sse-swap="retrieval" hx-swap="innerHTML"></div>` + `<div id="sse-sources-${messageId}" sse-swap="sources" hx-swap="innerHTML"></div>` + `<div id="sse-content-${messageId}" sse-swap="content" hx-swap="innerHTML"></div>` + `<div id="sse-thinking-${messageId}" sse-swap="thinking" hx-swap="innerHTML"></div>` + `<div id="sse-tools-${messageId}" sse-swap="tools" hx-swap="innerHTML"></div>` + `<div id="sse-images-${messageId}" sse-swap="images" hx-swap="innerHTML"></div>` + `<div id="sse-status-${messageId}" sse-swap="status" hx-swap="innerHTML">` + `<button type="button" class="ai-cancel-button" hx-post="${escapeHtml(cancelUrl)}" hx-target="#sse-status-${messageId}" hx-swap="innerHTML">Cancel</button>` + `</div>` + `</div>`;
+var defaultThinking = (text) => `<details class="ai-thinking"><summary>Thinking</summary><p>${escapeHtml(text)}</p></details>`;
+var defaultToolRunning = (name, _input) => `<div class="ai-tool running"><span class="tool-name">${escapeHtml(name)}</span> <span class="tool-status">Running...</span></div>`;
+var defaultToolComplete = (name, result) => `<details class="ai-tool complete"><summary>${escapeHtml(name)}</summary><pre>${escapeHtml(result)}</pre></details>`;
+var defaultImage = (data, format, revisedPrompt) => `<figure class="ai-image">` + `<img src="data:image/${escapeHtml(format)};base64,${data}" alt="${revisedPrompt ? escapeHtml(revisedPrompt) : "Generated image"}" />${revisedPrompt ? `<figcaption>${escapeHtml(revisedPrompt)}</figcaption>` : ""}</figure>`;
+var defaultComplete = (usage, durationMs, model) => {
+  const parts = [];
+  if (model) {
+    parts.push(escapeHtml(model));
+  }
+  if (usage) {
+    parts.push(`${usage.inputTokens}in / ${usage.outputTokens}out`);
+  }
+  if (durationMs !== undefined) {
+    const seconds = (durationMs / MILLISECONDS_IN_A_SECOND).toFixed(1);
+    parts.push(`${seconds}s`);
+  }
+  return parts.length > 0 ? `<div class="ai-usage">${parts.join(" \xB7 ")}</div>` : "";
+};
+var defaultError = (message) => `<div class="ai-error">${escapeHtml(message)}</div>`;
+var defaultCanceled = () => `<div class="ai-canceled">Canceled.</div>`;
+var defaultRAGRetrieving = () => `<div class="ai-retrieving">Retrieving sources...</div>`;
+var renderTraceSummary = (trace) => {
+  if (!trace) {
+    return "";
+  }
+  return `<div class="ai-trace-summary">` + `Mode: ${escapeHtml(trace.mode)} \xB7 Final: ${trace.resultCounts.final} \xB7 Vector: ${trace.resultCounts.vector} \xB7 Lexical: ${trace.resultCounts.lexical}` + `</div>`;
+};
+var defaultRAGRetrieved = (sources, input) => sources.length === 0 ? "" : `<div class="ai-sources">` + `<h4>Citations</h4>` + renderTraceSummary(input?.trace) + `<ul>` + `${sources.map((source) => `<li>[${source.chunkId}] ${escapeHtml(source.text)}${source.source ? ` (${escapeHtml(source.source)})` : ""}</li>`).join("")}` + `</ul>` + `</div>`;
+var resolveRenderers = (custom) => ({
+  chunk: custom?.chunk ?? defaultChunk,
+  messageStart: custom?.messageStart ?? defaultMessageStart,
+  complete: custom?.complete ?? defaultComplete,
+  canceled: custom?.canceled ?? defaultCanceled,
+  error: custom?.error ?? defaultError,
+  image: custom?.image ?? defaultImage,
+  ragRetrieving: custom?.ragRetrieving ?? defaultRAGRetrieving,
+  ragRetrieved: custom?.ragRetrieved ?? defaultRAGRetrieved,
+  thinking: custom?.thinking ?? defaultThinking,
+  toolComplete: custom?.toolComplete ?? defaultToolComplete,
+  toolRunning: custom?.toolRunning ?? defaultToolRunning
+});
+
+// src/plugins/aiChat.ts
+var DEFAULT_PATH = "/chat";
+var MAX_PREFIX_LEN = 12;
+var TITLE_MAX_LENGTH = 80;
+var NOT_FOUND2 = -1;
+var defaultParseProvider = (content) => {
+  const colonIdx = content.indexOf(":");
+  const hasPrefix = colonIdx > 0 && colonIdx < MAX_PREFIX_LEN;
+  return {
+    content: hasPrefix ? content.slice(colonIdx + 1) : content,
+    providerName: hasPrefix ? content.slice(0, colonIdx) : "anthropic"
+  };
+};
+var appendMessage = (conversation, message) => {
+  conversation.messages.push(message);
+  conversation.lastMessageAt = Date.now();
+  if (!conversation.title && message.role === "user") {
+    conversation.title = message.content.slice(0, TITLE_MAX_LENGTH);
+  }
+};
+var getHistory = (conversation) => conversation.messages.map((msg) => ({
+  content: msg.content,
+  role: msg.role
+}));
+var branchConversation = (source, fromMessageId) => {
+  const cutoffIndex = source.messages.findIndex((msg) => msg.id === fromMessageId);
+  if (cutoffIndex === NOT_FOUND2) {
+    return null;
+  }
+  const newId = generateId();
+  const branchedMessages = source.messages.slice(0, cutoffIndex + 1).map((msg) => ({ ...msg, conversationId: newId }));
+  const newConversation = {
+    createdAt: Date.now(),
+    id: newId,
+    messages: branchedMessages
+  };
+  return newConversation;
+};
+var buildUserMessage = (content, attachments) => {
+  if (attachments && attachments.length > 0) {
+    return {
+      content: [
+        ...attachments.map((att) => {
+          if (att.media_type === "application/pdf") {
+            return {
+              name: att.name,
+              source: {
+                data: att.data,
+                media_type: att.media_type,
+                type: "base64"
+              },
+              type: "document"
+            };
+          }
+          return {
+            source: {
+              data: att.data,
+              media_type: att.media_type,
+              type: "base64"
+            },
+            type: "image"
+          };
+        }),
+        { content, type: "text" }
+      ],
+      role: "user"
+    };
+  }
+  return { content, role: "user" };
+};
+var resolveModel = (config, parsed) => {
+  if (parsed.model) {
+    return parsed.model;
+  }
+  if (typeof config.model === "string") {
+    return config.model;
+  }
+  if (typeof config.model === "function") {
+    return config.model(parsed.providerName);
+  }
+  return parsed.providerName;
+};
+var resolveTools = (config, providerName, model) => typeof config.tools === "function" ? config.tools(providerName, model) : config.tools;
+var resolveThinking = (config, providerName, model) => typeof config.thinking === "function" ? config.thinking(providerName, model) : config.thinking;
+var aiChat = (config) => {
+  const path = config.path ?? DEFAULT_PATH;
+  const store = config.store ?? createMemoryStore();
+  const parseProvider = config.parseProvider ?? defaultParseProvider;
+  const abortControllers = new Map;
+  const handleCancel = (conversationId) => {
+    const controller = abortControllers.get(conversationId);
+    if (controller) {
+      controller.abort();
+      abortControllers.delete(conversationId);
+    }
+  };
+  const handleBranch = async (ws, messageId, conversationId) => {
+    const source = await store.get(conversationId);
+    if (!source) {
+      return;
+    }
+    const newConv = branchConversation(source, messageId);
+    if (newConv) {
+      await store.set(newConv.id, newConv);
+      ws.send(JSON.stringify({ conversationId: newConv.id, type: "branched" }));
+    }
+  };
+  const handleUserMessage = async (ws, rawContent, rawConversationId, attachments) => {
+    const conversationId = rawConversationId ?? generateId();
+    const messageId = generateId();
+    const parsed = parseProvider(rawContent);
+    const { content, providerName } = parsed;
+    const conversation = await store.getOrCreate(conversationId);
+    const history = getHistory(conversation);
+    const controller = new AbortController;
+    abortControllers.set(conversationId, controller);
+    appendMessage(conversation, {
+      attachments,
+      content,
+      conversationId,
+      id: messageId,
+      role: "user",
+      timestamp: Date.now()
+    });
+    await store.set(conversationId, conversation);
+    const model = resolveModel(config, parsed);
+    const userMessage = buildUserMessage(content, attachments);
+    await streamAI(ws, conversationId, messageId, {
+      maxTurns: config.maxTurns,
+      messages: [...history, userMessage],
+      model,
+      provider: config.provider(providerName),
+      signal: controller.signal,
+      systemPrompt: config.systemPrompt,
+      thinking: resolveThinking(config, providerName, model),
+      tools: resolveTools(config, providerName, model),
+      onComplete: async (fullResponse, usage) => {
+        const conv = await store.get(conversationId);
+        if (conv) {
+          appendMessage(conv, {
+            content: fullResponse,
+            conversationId,
+            id: generateId(),
+            role: "assistant",
+            timestamp: Date.now()
+          });
+          await store.set(conversationId, conv);
+        }
+        abortControllers.delete(conversationId);
+        config.onComplete?.(conversationId, fullResponse, usage);
+      }
+    });
+  };
+  const htmxRoutes = () => {
+    if (!config.htmx) {
+      return new Elysia;
+    }
+    const renderers = resolveRenderers(typeof config.htmx === "object" ? config.htmx.render : undefined);
+    return new Elysia().post(`${path}/message`, async ({ body }) => {
+      const requestBody = body && typeof body === "object" ? body : {};
+      const rawContent = "content" in requestBody ? String(requestBody.content) : undefined;
+      const rawConvId = "conversationId" in requestBody ? String(requestBody.conversationId) : undefined;
+      const rawAttachmentsValue = "attachments" in requestBody ? requestBody.attachments : undefined;
+      const rawAttachments = Array.isArray(rawAttachmentsValue) ? rawAttachmentsValue : undefined;
+      if (!rawContent) {
+        return new Response("Missing content", { status: 400 });
+      }
+      const conversationId = rawConvId || generateId();
+      const messageId = generateId();
+      const parsed = parseProvider(rawContent);
+      const { content } = parsed;
+      const conversation = await store.getOrCreate(conversationId);
+      appendMessage(conversation, {
+        attachments: rawAttachments,
+        content,
+        conversationId,
+        id: messageId,
+        role: "user",
+        timestamp: Date.now()
+      });
+      await store.set(conversationId, conversation);
+      const sseUrl = `${path}/sse/${conversationId}/${messageId}`;
+      return new Response(`<div id="msg-${messageId}" class="message user">` + `<div>${content}</div>` + `</div>` + `<div id="response-${messageId}" ` + `hx-ext="sse" ` + `sse-connect="${sseUrl}" ` + `hx-swap="innerHTML">` + `<div id="sse-content-${messageId}" sse-swap="content" hx-swap="innerHTML"></div>` + `<div id="sse-thinking-${messageId}" sse-swap="thinking" hx-swap="innerHTML"></div>` + `<div id="sse-tools-${messageId}" sse-swap="tools" hx-swap="innerHTML"></div>` + `<div id="sse-images-${messageId}" sse-swap="images" hx-swap="innerHTML"></div>` + `<div id="sse-status-${messageId}" sse-swap="status" hx-swap="innerHTML"></div>` + `</div>`, { headers: { "Content-Type": "text/html" } });
+    }).get(`${path}/sse/:conversationId/:messageId`, async function* ({ params }) {
+      const { conversationId, messageId } = params;
+      const conversation = await store.get(conversationId);
+      if (!conversation) {
+        yield {
+          data: renderers.error("Conversation not found"),
+          event: "status"
+        };
+        return;
+      }
+      const parsed = parseProvider(conversation.messages.at(EXCLUDE_LAST_OFFSET)?.content ?? "");
+      const { providerName } = parsed;
+      const model = resolveModel(config, parsed);
+      const controller = new AbortController;
+      abortControllers.set(conversationId, controller);
+      const history = getHistory(conversation);
+      const lastMsg = conversation.messages.at(EXCLUDE_LAST_OFFSET);
+      const userMessage = buildUserMessage(lastMsg?.content ?? "", lastMsg?.attachments);
+      const sseStream = streamAIToSSE(conversationId, messageId, {
+        maxTurns: config.maxTurns,
+        messages: [
+          ...history.slice(0, EXCLUDE_LAST_OFFSET),
+          userMessage
+        ],
+        model,
+        provider: config.provider(providerName),
+        signal: controller.signal,
+        systemPrompt: config.systemPrompt,
+        thinking: resolveThinking(config, providerName, model),
+        tools: resolveTools(config, providerName, model)
+      }, renderers);
+      for await (const event of sseStream) {
+        yield event;
+      }
+      const conv = await store.get(conversationId);
+      if (conv) {
+        await store.set(conversationId, conv);
+      }
+      abortControllers.delete(conversationId);
+    }).get(`${path}/history/:conversationId`, async ({ params }) => {
+      const conv = await store.get(params.conversationId);
+      if (!conv) {
+        return new Response("", { status: 404 });
+      }
+      const html = conv.messages.map((msg) => `<div class="message ${msg.role}"><div>${msg.content}</div></div>`).join("");
+      return new Response(html, {
+        headers: { "Content-Type": "text/html" }
+      });
+    }).get(`${path}/conversations/list`, async () => {
+      const convos = await store.list();
+      const html = convos.map((c) => `<div class="conversation-item" ` + `hx-get="${path}/history/${c.id}" ` + `hx-target="#messages" ` + `hx-swap="innerHTML">` + `<span class="title">${c.title}</span>` + `<span class="count">${c.messageCount} messages</span>` + `</div>`).join("");
+      return new Response(html || '<div class="empty">No conversations</div>', { headers: { "Content-Type": "text/html" } });
+    });
+  };
+  return new Elysia().ws(path, {
+    message: async (ws, raw) => {
+      const msg = parseAIMessage(raw);
+      if (!msg) {
+        return;
+      }
+      if (msg.type === "cancel" && msg.conversationId) {
+        handleCancel(msg.conversationId);
+        return;
+      }
+      if (msg.type === "branch") {
+        await handleBranch(ws, msg.messageId, msg.conversationId);
+        return;
+      }
+      if (msg.type === "message") {
+        await handleUserMessage(ws, msg.content, msg.conversationId, msg.attachments);
+      }
+    }
+  }).get(`${path}/conversations`, () => store.list()).get(`${path}/conversations/:id`, async ({ params }) => {
+    const conv = await store.get(params.id);
+    if (!conv) {
+      return new Response("Not found", { status: 404 });
+    }
+    return {
+      id: conv.id,
+      messages: conv.messages,
+      title: conv.title ?? "Untitled"
+    };
+  }).delete(`${path}/conversations/:id`, async ({ params }) => {
+    await store.remove(params.id);
+    return { ok: true };
+  }).use(htmxRoutes());
+};
+// src/ai/conversationManager.ts
+var NOT_FOUND3 = -1;
+var TITLE_MAX_LENGTH2 = 80;
+var createConversationManager = () => {
+  const conversations = new Map;
+  const getOrCreate = (conversationId) => {
+    const id = conversationId ?? generateId();
+    let conversation = conversations.get(id);
+    if (!conversation) {
+      conversation = { createdAt: Date.now(), id, messages: [] };
+      conversations.set(id, conversation);
+    }
+    return conversation;
+  };
+  const appendMessage2 = (conversationId, message) => {
+    const conversation = getOrCreate(conversationId);
+    conversation.messages.push(message);
+    conversation.lastMessageAt = Date.now();
+    if (!conversation.title && message.role === "user") {
+      conversation.title = message.content.slice(0, TITLE_MAX_LENGTH2);
+    }
+  };
+  const branch = (fromMessageId, sourceConversationId) => {
+    const source = conversations.get(sourceConversationId);
+    if (!source) {
+      return null;
+    }
+    const cutoffIndex = source.messages.findIndex((msg) => msg.id === fromMessageId);
+    if (cutoffIndex === NOT_FOUND3) {
+      return null;
+    }
+    const newId = generateId();
+    const branchedMessages = source.messages.slice(0, cutoffIndex + 1).map((msg) => ({ ...msg, conversationId: newId }));
+    const newConversation = {
+      createdAt: Date.now(),
+      id: newId,
+      messages: branchedMessages
+    };
+    conversations.set(newId, newConversation);
+    return newId;
+  };
+  const emptyHistory = [];
+  const getHistory2 = (conversationId) => {
+    const conversation = conversations.get(conversationId);
+    if (!conversation) {
+      return emptyHistory;
+    }
+    const history = conversation.messages.map((msg) => ({
+      content: msg.content,
+      role: msg.role
+    }));
+    return history;
+  };
+  const getAbortController = (conversationId) => {
+    const conversation = getOrCreate(conversationId);
+    const controller = new AbortController;
+    conversation.activeStreamAbort = controller;
+    return controller;
+  };
+  const abort = (conversationId) => {
+    const conversation = conversations.get(conversationId);
+    if (conversation?.activeStreamAbort) {
+      conversation.activeStreamAbort.abort();
+      conversation.activeStreamAbort = undefined;
+    }
+  };
+  const get = (conversationId) => conversations.get(conversationId);
+  const remove = (conversationId) => conversations.delete(conversationId);
+  const list = () => Array.from(conversations.values()).map((conv) => ({
+    createdAt: conv.createdAt,
+    id: conv.id,
+    lastMessageAt: conv.lastMessageAt,
+    messageCount: conv.messages.length,
+    title: conv.title ?? "Untitled"
+  })).sort((first, second) => (second.lastMessageAt ?? second.createdAt) - (first.lastMessageAt ?? first.createdAt));
+  const getMessages = (conversationId) => {
+    const conversation = conversations.get(conversationId);
+    if (!conversation) {
+      return [];
+    }
+    return conversation.messages;
+  };
+  return {
+    abort,
+    appendMessage: appendMessage2,
+    branch,
+    get,
+    getAbortController,
+    getHistory: getHistory2,
+    getMessages,
+    getOrCreate,
+    list,
+    remove
+  };
+};
+// src/ai/client/actions.ts
+var serverMessageToAction = (message) => {
+  switch (message.type) {
+    case "chunk":
+      return {
+        content: message.content,
+        conversationId: message.conversationId,
+        messageId: message.messageId,
+        type: "chunk"
+      };
+    case "thinking":
+      return {
+        content: message.content,
+        conversationId: message.conversationId,
+        messageId: message.messageId,
+        type: "thinking"
+      };
+    case "tool_status":
+      return {
+        conversationId: message.conversationId,
+        input: message.input,
+        messageId: message.messageId,
+        name: message.name,
+        result: message.result,
+        status: message.status,
+        type: "tool_status"
+      };
+    case "image":
+      return {
+        conversationId: message.conversationId,
+        data: message.data,
+        format: message.format,
+        imageId: message.imageId,
+        isPartial: message.isPartial,
+        messageId: message.messageId,
+        revisedPrompt: message.revisedPrompt,
+        type: "image"
+      };
+    case "complete":
+      return {
+        conversationId: message.conversationId,
+        durationMs: message.durationMs,
+        messageId: message.messageId,
+        model: message.model,
+        sources: message.sources,
+        type: "complete",
+        usage: message.usage
+      };
+    case "rag_retrieving":
+      return {
+        conversationId: message.conversationId,
+        messageId: message.messageId,
+        retrievalStartedAt: message.retrievalStartedAt,
+        type: "rag_retrieving"
+      };
+    case "rag_retrieved":
+      return {
+        conversationId: message.conversationId,
+        messageId: message.messageId,
+        retrievalDurationMs: message.retrievalDurationMs,
+        retrievalStartedAt: message.retrievalStartedAt,
+        retrievedAt: message.retrievedAt,
+        sources: message.sources,
+        trace: message.trace,
+        type: "rag_retrieved"
+      };
+    case "error":
+      return { message: message.message, type: "error" };
+    default:
+      return null;
+  }
+};
+// src/ai/client/connection.ts
+var WS_OPEN2 = 1;
+var WS_NORMAL_CLOSURE = 1000;
+var WS_CLOSED = 3;
+var DEFAULT_PING_INTERVAL = 30000;
+var RECONNECT_INITIAL_DELAY = 500;
+var RECONNECT_POLL_INTERVAL = 300;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 60;
+var noop = () => {};
+var noopUnsubscribe = () => noop;
+var NOOP_CONNECTION = {
+  close: noop,
+  send: noop,
+  subscribe: noopUnsubscribe,
+  getReadyState: () => WS_CLOSED
+};
+var buildWsUrl = (path) => {
+  const { hostname, port, protocol } = window.location;
+  const wsProtocol = protocol === "https:" ? "wss:" : "ws:";
+  const portSuffix = port ? `:${port}` : "";
+  return `${wsProtocol}//${hostname}${portSuffix}${path}`;
+};
+var parseServerMessage = (event) => {
+  let data;
+  try {
+    data = JSON.parse(String(event.data));
+  } catch {
+    return null;
+  }
+  if (data && typeof data === "object" && "type" in data && data.type === "pong") {
+    return null;
+  }
+  if (!isValidAIServerMessage(data)) {
+    return null;
+  }
+  return data;
+};
+var createAIConnection = (path, options = {}) => {
+  if (typeof window === "undefined") {
+    return NOOP_CONNECTION;
+  }
+  const shouldReconnect = options.reconnect !== false;
+  const pingInterval = options.pingInterval ?? DEFAULT_PING_INTERVAL;
+  const maxReconnectAttempts = options.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
+  const listeners = new Set;
+  const connState = {
+    isConnected: false,
+    pendingMessages: [],
+    pingInterval: null,
+    reconnectAttempts: 0,
+    reconnectTimeout: null,
+    ws: null
+  };
+  const flushPendingMessages = () => {
+    if (connState.ws?.readyState !== WS_OPEN2) {
+      return;
+    }
+    while (connState.pendingMessages.length > 0) {
+      const next = connState.pendingMessages.shift();
+      if (typeof next === "string") {
+        connState.ws.send(next);
+      }
+    }
+  };
+  const clearTimers = () => {
+    if (connState.pingInterval) {
+      clearInterval(connState.pingInterval);
+      connState.pingInterval = null;
+    }
+    if (connState.reconnectTimeout) {
+      clearTimeout(connState.reconnectTimeout);
+      connState.reconnectTimeout = null;
+    }
+  };
+  const scheduleReconnect = () => {
+    connState.reconnectAttempts++;
+    const delay2 = connState.reconnectAttempts === 1 ? RECONNECT_INITIAL_DELAY : RECONNECT_POLL_INTERVAL;
+    connState.reconnectTimeout = setTimeout(() => {
+      if (connState.reconnectAttempts > maxReconnectAttempts) {
+        return;
+      }
+      connect();
+    }, delay2);
+  };
+  const connect = () => {
+    const url = buildWsUrl(path);
+    const wsInstance = new WebSocket(url, options.protocols);
+    wsInstance.onopen = () => {
+      connState.isConnected = true;
+      connState.reconnectAttempts = 0;
+      flushPendingMessages();
+      connState.pingInterval = setInterval(() => {
+        if (wsInstance.readyState === WS_OPEN2 && connState.isConnected) {
+          wsInstance.send(JSON.stringify({ type: "ping" }));
+        }
+      }, pingInterval);
+    };
+    wsInstance.onmessage = (event) => {
+      const message = parseServerMessage(event);
+      if (!message) {
+        return;
+      }
+      listeners.forEach((listener) => listener(message));
+    };
+    wsInstance.onclose = (event) => {
+      connState.isConnected = false;
+      clearTimers();
+      const shouldAttemptReconnect = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && connState.reconnectAttempts < maxReconnectAttempts;
+      if (shouldAttemptReconnect) {
+        scheduleReconnect();
+      }
+    };
+    wsInstance.onerror = () => {};
+    connState.ws = wsInstance;
+  };
+  const send = (msg) => {
+    const serialized = JSON.stringify(msg);
+    if (connState.ws?.readyState === WS_OPEN2) {
+      connState.ws.send(serialized);
+      return;
+    }
+    connState.pendingMessages.push(serialized);
+  };
+  const subscribe = (callback) => {
+    listeners.add(callback);
+    return () => {
+      listeners.delete(callback);
+    };
+  };
+  const close = () => {
+    clearTimers();
+    if (connState.ws) {
+      connState.ws.close(WS_NORMAL_CLOSURE);
+      connState.ws = null;
+    }
+    connState.isConnected = false;
+    listeners.clear();
+  };
+  const getReadyState = () => connState.ws?.readyState ?? WS_CLOSED;
+  connect();
+  return { close, getReadyState, send, subscribe };
+};
+// src/ai/client/messageStore.ts
+var EMPTY_STATE = {
+  activeConversationId: null,
+  conversations: new Map,
+  error: null,
+  isStreaming: false
+};
+var initialActiveConversationId = null;
+var initialError = null;
+var freshState = () => ({
+  activeConversationId: initialActiveConversationId,
+  conversations: new Map,
+  error: initialError,
+  isStreaming: false
+});
+var findAssistantMessage = (conversation, messageId) => conversation.messages.find((msg) => msg.id === messageId && msg.role === "assistant");
+var getOrCreate = (state, conversationId) => {
+  let conversation = state.conversations.get(conversationId);
+  if (!conversation) {
+    conversation = {
+      createdAt: Date.now(),
+      id: conversationId,
+      messages: []
+    };
+    state.conversations.set(conversationId, conversation);
+  }
+  return conversation;
+};
+var handleSend = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = {
+    attachments: action.attachments,
+    content: action.content,
+    conversationId: action.conversationId,
+    id: action.messageId,
+    role: "user",
+    timestamp: Date.now()
+  };
+  conversation.messages = [...conversation.messages, message];
+  state.activeConversationId = action.conversationId;
+  state.error = null;
+  state.isStreaming = true;
+};
+var handleChunk = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const existingIdx = conversation.messages.findIndex((msg) => msg.id === action.messageId && msg.role === "assistant");
+  if (existingIdx >= 0) {
+    const prevContent = conversation.messages[existingIdx]?.content ?? "";
+    conversation.messages = conversation.messages.map((msg, idx) => idx === existingIdx ? { ...msg, content: prevContent + action.content } : msg);
+    return;
+  }
+  const message = {
+    content: action.content,
+    conversationId: action.conversationId,
+    id: action.messageId,
+    isStreaming: true,
+    role: "assistant",
+    timestamp: Date.now()
+  };
+  conversation.messages = [...conversation.messages, message];
+};
+var handleThinking = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const existingIdx = conversation.messages.findIndex((msg) => msg.id === action.messageId && msg.role === "assistant");
+  if (existingIdx >= 0) {
+    const prevThinking = conversation.messages[existingIdx]?.thinking ?? "";
+    conversation.messages = conversation.messages.map((msg, idx) => idx === existingIdx ? { ...msg, thinking: prevThinking + action.content } : msg);
+    return;
+  }
+  const message = {
+    content: "",
+    conversationId: action.conversationId,
+    id: action.messageId,
+    isStreaming: true,
+    role: "assistant",
+    thinking: action.content,
+    timestamp: Date.now()
+  };
+  conversation.messages = [...conversation.messages, message];
+};
+var upsertToolCall = (message, toolCall) => {
+  if (!message.toolCalls) {
+    message.toolCalls = [toolCall];
+    return;
+  }
+  const existingIdx = message.toolCalls.findIndex((existing) => existing.name === toolCall.name);
+  if (existingIdx >= 0) {
+    message.toolCalls[existingIdx] = toolCall;
+  } else {
+    message.toolCalls = [...message.toolCalls, toolCall];
+  }
+};
+var getOrCreateAssistantMessage = (conversation, messageId, conversationId) => {
+  const existing = findAssistantMessage(conversation, messageId);
+  if (existing) {
+    return existing;
+  }
+  const message = {
+    content: "",
+    conversationId,
+    id: messageId,
+    isStreaming: true,
+    role: "assistant",
+    timestamp: Date.now()
+  };
+  conversation.messages = [...conversation.messages, message];
+  return message;
+};
+var handleRAGRetrieved = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = getOrCreateAssistantMessage(conversation, action.messageId, action.conversationId);
+  message.sources = action.sources;
+  message.retrievalStartedAt = action.retrievalStartedAt ?? message.retrievalStartedAt;
+  message.retrievedAt = action.retrievedAt;
+  message.retrievalDurationMs = action.retrievalDurationMs;
+  message.retrievalTrace = action.trace;
+  conversation.messages = [...conversation.messages];
+};
+var handleRAGRetrieving = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = getOrCreateAssistantMessage(conversation, action.messageId, action.conversationId);
+  message.retrievalStartedAt = action.retrievalStartedAt;
+  conversation.messages = [...conversation.messages];
+};
+var handleToolStatus = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = getOrCreateAssistantMessage(conversation, action.messageId, action.conversationId);
+  const toolCall = {
+    id: action.messageId,
+    input: action.input,
+    name: action.name,
+    result: action.status === "complete" ? action.result ?? "" : undefined
+  };
+  upsertToolCall(message, toolCall);
+  conversation.messages = [...conversation.messages];
+};
+var markMessageComplete = (conversation, messageId, usage, durationMs, model, sources) => {
+  conversation.messages = conversation.messages.map((msg) => msg.id === messageId && msg.role === "assistant" ? {
+    ...msg,
+    durationMs,
+    isStreaming: false,
+    model,
+    sources: sources ?? msg.sources,
+    usage
+  } : msg);
+};
+var NOT_FOUND4 = -1;
+var findExistingImageById = (images, imageId) => {
+  if (!imageId)
+    return NOT_FOUND4;
+  return images.findIndex((img) => img.imageId === imageId);
+};
+var findReplaceablePartialIndex = (images) => {
+  const lastIdx = images.length - 1;
+  if (lastIdx >= 0 && images[lastIdx]?.isPartial) {
+    return lastIdx;
+  }
+  return NOT_FOUND4;
+};
+var upsertImage = (message, imageData) => {
+  if (!message.images) {
+    message.images = [imageData];
+    return;
+  }
+  const existingIdx = findExistingImageById(message.images, imageData.imageId);
+  if (existingIdx >= 0) {
+    message.images[existingIdx] = imageData;
+    return;
+  }
+  const replaceableIdx = findReplaceablePartialIndex(message.images);
+  if (replaceableIdx >= 0) {
+    message.images[replaceableIdx] = imageData;
+    return;
+  }
+  message.images = [...message.images, imageData];
+};
+var handleImage = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = getOrCreateAssistantMessage(conversation, action.messageId, action.conversationId);
+  upsertImage(message, {
+    data: action.data,
+    format: action.format,
+    imageId: action.imageId,
+    isPartial: action.isPartial,
+    revisedPrompt: action.revisedPrompt
+  });
+  conversation.messages = [...conversation.messages];
+};
+var handleComplete = (state, action) => {
+  const conversation = state.conversations.get(action.conversationId);
+  if (conversation) {
+    markMessageComplete(conversation, action.messageId, action.usage, action.durationMs, action.model, action.sources);
+  }
+  state.isStreaming = false;
+};
+var markConversationStreamsComplete = (conversation) => {
+  const streamingMessages = conversation.messages.filter((msg) => msg.isStreaming);
+  if (streamingMessages.length === 0) {
+    return;
+  }
+  for (const msg of streamingMessages) {
+    msg.isStreaming = false;
+  }
+  conversation.messages = [...conversation.messages];
+};
+var markAllStreamsComplete = (state) => {
+  for (const [, conversation] of state.conversations) {
+    markConversationStreamsComplete(conversation);
+  }
+};
+var handleBranch = (state, action) => {
+  const source = state.conversations.get(action.oldConversationId);
+  if (!source) {
+    return;
+  }
+  const cutoffIndex = source.messages.findIndex((msg) => msg.id === action.fromMessageId);
+  if (cutoffIndex < 0) {
+    return;
+  }
+  const branchedMessages = source.messages.slice(0, cutoffIndex + 1).map((msg) => ({ ...msg, conversationId: action.newConversationId }));
+  const newConversation = {
+    createdAt: Date.now(),
+    id: action.newConversationId,
+    messages: branchedMessages
+  };
+  state.conversations.set(action.newConversationId, newConversation);
+  state.activeConversationId = action.newConversationId;
+};
+var applyAction = (state, action) => {
+  switch (action.type) {
+    case "send":
+      handleSend(state, action);
+      break;
+    case "chunk":
+      handleChunk(state, action);
+      break;
+    case "thinking":
+      handleThinking(state, action);
+      break;
+    case "tool_status":
+      handleToolStatus(state, action);
+      break;
+    case "image":
+      handleImage(state, action);
+      break;
+    case "complete":
+      handleComplete(state, action);
+      break;
+    case "error":
+      state.error = action.message;
+      state.isStreaming = false;
+      break;
+    case "rag_retrieving":
+      handleRAGRetrieving(state, action);
+      break;
+    case "rag_retrieved":
+      handleRAGRetrieved(state, action);
+      break;
+    case "cancel":
+      state.isStreaming = false;
+      markAllStreamsComplete(state);
+      break;
+    case "branch":
+      handleBranch(state, action);
+      break;
+    case "set_conversation":
+      state.activeConversationId = action.conversationId;
+      break;
+  }
+};
+var createAIMessageStore = () => {
+  let state = freshState();
+  const subscribers = new Set;
+  return {
+    dispatch: (action) => {
+      applyAction(state, action);
+      state = { ...state, conversations: new Map(state.conversations) };
+      subscribers.forEach((callback) => callback());
+    },
+    getServerSnapshot: () => EMPTY_STATE,
+    getSnapshot: () => state,
+    subscribe: (callback) => {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+      };
+    }
+  };
+};
+
+// src/ai/client/createAIStream.ts
+var createAIStream = (path, conversationId) => {
+  const connection = createAIConnection(path);
+  const store = createAIMessageStore();
+  const listeners = new Set;
+  let currentError = null;
+  let currentIsStreaming = false;
+  let currentMessages = [];
+  let activeConversationId = conversationId ?? null;
+  const syncState = () => {
+    const snapshot = store.getSnapshot();
+    const convId = activeConversationId ?? snapshot.activeConversationId;
+    const conversation = convId ? snapshot.conversations.get(convId) : undefined;
+    activeConversationId = convId ?? snapshot.activeConversationId;
+    currentError = snapshot.error;
+    currentIsStreaming = snapshot.isStreaming;
+    currentMessages = conversation?.messages ?? [];
+    listeners.forEach((listener) => listener());
+  };
+  const unsubscribeStore = store.subscribe(syncState);
+  const unsubscribeConnection = connection.subscribe((message) => {
+    const action = serverMessageToAction(message);
+    if (action) {
+      store.dispatch(action);
+    }
+  });
+  const branch = (messageId, content) => {
+    if (activeConversationId) {
+      connection.send({
+        content,
+        conversationId: activeConversationId,
+        messageId,
+        type: "branch"
+      });
+    }
+  };
+  const cancel = () => {
+    if (activeConversationId) {
+      store.dispatch({ type: "cancel" });
+      connection.send({
+        conversationId: activeConversationId,
+        type: "cancel"
+      });
+    }
+  };
+  const destroy = () => {
+    unsubscribeStore();
+    unsubscribeConnection();
+    connection.close();
+    listeners.clear();
+  };
+  const send = (content, attachments) => {
+    const convId = activeConversationId ?? generateId();
+    const msgId = generateId();
+    store.dispatch({
+      attachments,
+      content,
+      conversationId: convId,
+      messageId: msgId,
+      type: "send"
+    });
+    connection.send({
+      attachments,
+      content,
+      conversationId: convId,
+      type: "message"
+    });
+  };
+  const subscribe = (callback) => {
+    listeners.add(callback);
+    return () => {
+      listeners.delete(callback);
+    };
+  };
+  return {
+    branch,
+    cancel,
+    destroy,
+    send,
+    subscribe,
+    get error() {
+      return currentError;
+    },
+    get isStreaming() {
+      return currentIsStreaming;
+    },
+    get messages() {
+      return currentMessages;
+    }
+  };
+};
+export {
+  xai,
+  streamAIToSSE,
+  streamAI,
+  serverMessageToAction,
+  serializeAIMessage,
+  resolveRenderers,
+  parseAIMessage,
+  openaiResponses,
+  openaiCompatible,
+  openai,
+  ollama,
+  moonshot,
+  mistralai,
+  meta,
+  google,
+  generateId,
+  gemini,
+  deepseek,
+  createMemoryStore,
+  createConversationManager,
+  createAIStream,
+  createAIConnection,
+  anthropic,
+  alibaba,
+  aiChat
+};
+
+//# debugId=165B0DAA4823A12464756E2164756E21
+//# sourceMappingURL=index.js.map