@absolutejs/absolute 0.19.0-beta.248 → 0.19.0-beta.249

package/.claude/settings.local.json

@@ -263,7 +263,8 @@
       "WebFetch(domain:platform.openai.com)",
       "Bash(bunx absolute:*)",
       "mcp__playwright__browser_file_upload",
-      "WebFetch(domain:docs.anthropic.com)"
+      "WebFetch(domain:docs.anthropic.com)",
+      "WebFetch(domain:ai.google.dev)"
     ]
   }
 }

package/dist/ai/index.js

@@ -106,6 +106,8 @@ var isValidAIClientMessage = (data) => {
       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 "error":
@@ -481,6 +483,607 @@ var moonshot = (config) => openaiCompatible({
   baseUrl: "https://api.moonshot.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 mapContentToResponsesFormat = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      parts.push({ text: block.content, type: "input_text" });
+    } else if (block.type === "image") {
+      parts.push({
+        image_url: {
+          url: `data:${block.source.media_type};base64,${block.source.data}`
+        },
+        type: "input_image"
+      });
+    } else if (block.type === "document") {
+      parts.push({
+        file: {
+          file_data: `data:${block.source.media_type};base64,${block.source.data}`,
+          filename: block.name ?? "document.pdf"
+        },
+        type: "input_file"
+      });
+    }
+  }
+  return parts.length > 0 ? parts : "";
+};
+var hasToolBlocks = (content) => content.some((block) => block.type === "tool_use" || block.type === "tool_result");
+var convertToolBlocks = (content) => {
+  const items = [];
+  for (const block of content) {
+    if (block.type === "tool_use") {
+      items.push({
+        arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input),
+        call_id: block.id,
+        name: block.name,
+        type: "function_call"
+      });
+    } else if (block.type === "tool_result") {
+      items.push({
+        call_id: block.tool_use_id,
+        output: typeof block.content === "string" ? block.content : "",
+        type: "function_call_output"
+      });
+    }
+  }
+  return items;
+};
+var convertMessage = (msg) => {
+  if (typeof msg.content !== "string" && Array.isArray(msg.content)) {
+    if (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, imageGeneration) => {
+  const result = [];
+  if (tools) {
+    for (const tool of tools) {
+      result.push(mapToolDefinition(tool));
+    }
+  }
+  if (imageGeneration) {
+    const imageGenTool = {
+      type: "image_generation"
+    };
+    if (imageGeneration.partialImages !== undefined) {
+      imageGenTool.partial_images = imageGeneration.partialImages;
+    }
+    result.push(imageGenTool);
+  }
+  return result.length > 0 ? result : undefined;
+};
+var buildRequestBody2 = (params, imageGeneration) => {
+  const body = {
+    input: buildInput(params.messages),
+    model: params.model,
+    stream: true
+  };
+  if (params.systemPrompt) {
+    body.instructions = params.systemPrompt;
+  }
+  const tools = buildTools(params.tools, imageGeneration);
+  if (tools) {
+    body.tools = tools;
+  }
+  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,
+    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") {
+    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 extractImageFromOutput = function* (output) {
+  for (const item of output) {
+    if (item.type !== "image_generation_call") {
+      continue;
+    }
+    if (item.status !== "completed") {
+      continue;
+    }
+    const data = typeof item.result === "string" ? item.result : "";
+    if (!data) {
+      continue;
+    }
+    const format = extractMimeFormat(item.output_format);
+    const revisedPrompt = typeof item.revised_prompt === "string" ? item.revised_prompt : undefined;
+    const imageId = typeof item.id === "string" ? item.id : undefined;
+    yield {
+      data,
+      format,
+      imageId,
+      isPartial: false,
+      revisedPrompt,
+      type: "image"
+    };
+  }
+};
+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.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;
+  }
+};
+var processSSELines2 = function* (lines, state) {
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      if (state.currentEvent && state.buffer) {
+        const parsed = parseJSON(state.buffer);
+        if (parsed) {
+          yield* processSSEEvent(state.currentEvent, parsed, state.pendingCalls);
+        }
+        state.currentEvent = "";
+        state.buffer = "";
+      }
+      continue;
+    }
+    if (trimmed.startsWith("event: ")) {
+      state.currentEvent = trimmed.slice(EVENT_PREFIX_LENGTH);
+    } else if (trimmed.startsWith("data: ")) {
+      state.buffer = trimmed.slice(DATA_PREFIX_LENGTH);
+    }
+  }
+};
+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 openaiResponses = (config) => {
+  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL2;
+  return {
+    stream: (params) => {
+      const body = buildRequestBody2(params, config.imageGeneration);
+      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 }];
+  }
+  const parts = [];
+  for (const block of content) {
+    const mapped = mapContentBlock(block);
+    if (mapped) {
+      parts.push(mapped);
+    }
+  }
+  return parts;
+};
+var hasFunctionResponse = (content) => content.some((block) => block.type === "tool_result");
+var convertMessages = (messages) => {
+  const contents = [];
+  for (const msg of messages) {
+    if (typeof msg.content !== "string" && hasFunctionResponse(msg.content)) {
+      const parts = convertMessageContent(msg.content);
+      contents.push({ parts, role: "user" });
+      continue;
+    }
+    contents.push({
+      parts: convertMessageContent(msg.content),
+      role: mapRole(msg.role)
+    });
+  }
+  return contents;
+};
+var mapToolDefinitions2 = (tools) => tools.map((tool) => ({
+  description: tool.description,
+  name: tool.name,
+  parameters: tool.input_schema
+}));
+var buildRequestBody3 = (params) => {
+  const body = {
+    contents: convertMessages(params.messages),
+    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.mimeType;
+  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[0];
+  if (!candidate || !isRecord3(candidate.content)) {
+    return;
+  }
+  const { content } = candidate;
+  if (!isRecordArray3(content.parts)) {
+    return;
+  }
+  for (const part of content.parts) {
+    yield* processPart(part);
+  }
+};
+var processSSELine2 = 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 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() ?? "";
+    for (const line of lines) {
+      yield* processSSELine2(line, state);
+    }
+  }
+  if (textBuffer.trim()) {
+    yield* processSSELine2(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 gemini = (config) => {
+  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL3;
+  return {
+    stream: (params) => {
+      const body = buildRequestBody3(params);
+      return fetchGeminiStream(baseUrl, config.apiKey, params.model, body, params.signal);
+    }
+  };
+};
+
 // src/plugins/aiChat.ts
 import { Elysia } from "elysia";
 
@@ -651,6 +1254,16 @@ var extractTextContent = (chunk, onChunk) => {
   }
   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,
@@ -715,6 +1328,16 @@ var processToolChunk = (chunk, state, options, socket, messageId, conversationId
     case "text":
       handleToolChunkText(chunk, state, options, socket, messageId, conversationId);
       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":
       handleToolChunkToolUse(chunk, state);
       hitAnotherTool = true;
@@ -865,6 +1488,16 @@ var consumeStreamChunk = async (chunk, options, socket, messages, messageId, con
       return "";
     case "text":
       return processStreamTextChunk(chunk, options, socket, messageId, conversationId);
+    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
+      });
+      return "";
     case "tool_use":
       await processStreamToolUseChunk(chunk, socket, options, messages, messageId, conversationId, signal, fullResponse, startTime);
       return { earlyReturn: true, fullResponse, usage: undefined };
@@ -1059,17 +1692,19 @@ export {
   streamAI,
   serializeAIMessage,
   parseAIMessage,
+  openaiResponses,
   openaiCompatible,
   moonshot,
   mistralai,
   meta,
   google,
   generateId,
+  gemini,
   deepseek,
   createConversationManager,
   alibaba,
   aiChat
 };
 
-//# debugId=C554CBF32C5F355864756E2164756E21
+//# debugId=214AE01443FBB99E64756E2164756E21
 //# sourceMappingURL=index.js.map