@absolutejs/absolute 0.19.0-beta.241 → 0.19.0-beta.243

package/.claude/settings.local.json

@@ -259,7 +259,8 @@
       "mcp__playwright__browser_take_screenshot",
       "Bash(xargs -r kill -9)",
       "mcp__playwright__browser_type",
-      "Bash(ollama list:*)"
+      "Bash(ollama list:*)",
+      "WebFetch(domain:platform.openai.com)"
     ]
   }
 }

package/dist/ai/index.js

@@ -134,6 +134,308 @@ var isValidAIClientMessage = (data) => {
   }
 };
 
+// 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 buildRequestBody = (params) => {
+  const messages = convertToolResultMessages(params.messages.map((msg) => ({
+    content: typeof msg.content === "string" ? msg.content : null,
+    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 openaiCompatible = (config) => openai({ apiKey: config.apiKey, baseUrl: config.baseUrl });
+var google = (config) => openaiCompatible({
+  apiKey: config.apiKey,
+  baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai"
+});
+var xai = (config) => openaiCompatible({
+  apiKey: config.apiKey,
+  baseUrl: "https://api.x.ai"
+});
+var deepseek = (config) => openaiCompatible({
+  apiKey: config.apiKey,
+  baseUrl: "https://api.deepseek.com"
+});
+var mistralai = (config) => openaiCompatible({
+  apiKey: config.apiKey,
+  baseUrl: "https://api.mistral.ai"
+});
+
 // src/plugins/aiChat.ts
 import { Elysia } from "elysia";
 
@@ -171,14 +473,14 @@ var parseAIMessage = (raw) => {
 var serializeAIMessage = (msg) => JSON.stringify(msg);
 
 // src/ai/conversationManager.ts
-var NOT_FOUND = -1;
+var NOT_FOUND2 = -1;
 var createConversationManager = () => {
   const conversations = new Map;
   const getOrCreate = (conversationId) => {
     const id = conversationId ?? generateId();
     let conversation = conversations.get(id);
     if (!conversation) {
-      conversation = { id, messages: [] };
+      conversation = { createdAt: Date.now(), id, messages: [] };
       conversations.set(id, conversation);
     }
     return conversation;
@@ -186,6 +488,10 @@ var createConversationManager = () => {
   const appendMessage = (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, 80);
+    }
   };
   const branch = (fromMessageId, sourceConversationId) => {
     const source = conversations.get(sourceConversationId);
@@ -193,12 +499,13 @@ var createConversationManager = () => {
       return null;
     }
     const cutoffIndex = source.messages.findIndex((msg) => msg.id === fromMessageId);
-    if (cutoffIndex === NOT_FOUND) {
+    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
     };
@@ -232,6 +539,20 @@ var createConversationManager = () => {
   };
   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,
@@ -239,7 +560,9 @@ var createConversationManager = () => {
     get,
     getAbortController,
     getHistory,
+    getMessages,
     getOrCreate,
+    list,
     remove
   };
 };
@@ -423,10 +746,11 @@ var executeToolLoop = async (socket, options, messages, toolUseId, toolName, too
     usage: state.currentUsage
   };
 };
-var sendComplete = async (socket, messageId, conversationId, usage, durationMs) => sendMessage(socket, {
+var sendComplete = async (socket, messageId, conversationId, usage, durationMs, model) => sendMessage(socket, {
   conversationId,
   durationMs,
   messageId,
+  model,
   type: "complete",
   usage
 });
@@ -448,7 +772,7 @@ var handleTextChunk = async (chunk, options, socket, messageId, conversationId)
 };
 var handleToolUseChunk = async (socket, options, messages, chunkId, chunkName, chunkInput, messageId, conversationId, signal, fullResponse, startTime) => {
   const toolResult = await executeToolLoop(socket, options, messages, chunkId, chunkName, chunkInput, messageId, conversationId, signal, fullResponse, INITIAL_TURN);
-  await sendComplete(socket, messageId, conversationId, toolResult.usage, Date.now() - startTime);
+  await sendComplete(socket, messageId, conversationId, toolResult.usage, Date.now() - startTime, options.model);
   options.onComplete?.(toolResult.fullResponse, toolResult.usage);
   return toolResult;
 };
@@ -470,7 +794,7 @@ var processStream = async (socket, options, messages, messageId, conversationId,
   });
   const result = await consumeStream(stream, options, socket, messages, messageId, conversationId, signal, startTime);
   if (!result.earlyReturn) {
-    await sendComplete(socket, messageId, conversationId, result.usage, Date.now() - startTime);
+    await sendComplete(socket, messageId, conversationId, result.usage, Date.now() - startTime, options.model);
     options.onComplete?.(result.fullResponse, result.usage);
   }
 };
@@ -622,16 +946,34 @@ var aiChat = (config) => {
         await handleUserMessage(ws, msg.content, msg.conversationId);
       }
     }
+  }).get(`${path}/conversations`, () => conversations.list()).get(`${path}/conversations/:id`, ({ params }) => {
+    const conv = conversations.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`, ({ params }) => {
+    conversations.remove(params.id);
+    return { ok: true };
   });
 };
 export {
+  xai,
   streamAI,
   serializeAIMessage,
   parseAIMessage,
+  openaiCompatible,
+  mistralai,
+  google,
   generateId,
+  deepseek,
   createConversationManager,
   aiChat
 };
 
-//# debugId=2FEA80C34C79993464756E2164756E21
+//# debugId=1D1368F3FA8E162364756E2164756E21
 //# sourceMappingURL=index.js.map