acp-kernel 0.0.23 → 0.0.25

package/dist/wire/index.js

@@ -0,0 +1,676 @@
+// src/wire/util.ts
+import { createHash } from "crypto";
+function hashId(s) {
+  return createHash("sha256").update(s, "utf8").digest("hex").slice(0, 16);
+}
+
+// src/wire/message-id.ts
+function deriveMessageId(role, contentType, text, options = {}) {
+  const seed = `${role}|${contentType}|${options.toolCallId ?? ""}|${options.toolName ?? ""}|${text}`;
+  return "h_" + hashId(seed);
+}
+var ClusterCounter = class {
+  counts = /* @__PURE__ */ new Map();
+  next(baseId) {
+    const n = this.counts.get(baseId) ?? 0;
+    this.counts.set(baseId, n + 1);
+    return n === 0 ? baseId : `${baseId}_${n}`;
+  }
+};
+
+// src/wire/anthropic.ts
+function extractSystem(system) {
+  if (!system) return "";
+  if (typeof system === "string") return system;
+  return system.map((b) => b.text).join("\n\n");
+}
+function buildSystem(text, original) {
+  if (Array.isArray(original) && original.length > 0) {
+    const ccBlock = original.find((b) => b.cache_control);
+    return [{ type: "text", text, ...ccBlock ? { cache_control: ccBlock.cache_control } : {} }];
+  }
+  return text;
+}
+function anthropicToCore(body) {
+  const msgs = [];
+  const cacheControls = /* @__PURE__ */ new Map();
+  const clusters = new ClusterCounter();
+  for (const m of body.messages) {
+    const blocks = typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content;
+    for (const b of blocks) {
+      switch (b.type) {
+        case "text": {
+          const base = deriveMessageId(m.role, "text", b.text);
+          const id = clusters.next(base);
+          msgs.push({ id, role: m.role, contentType: "text", text: b.text });
+          if (b.cache_control) cacheControls.set(id, b.cache_control);
+          break;
+        }
+        case "tool_use": {
+          const base = deriveMessageId("assistant", "tool-call", safeStringify(b.input), {
+            toolCallId: b.id,
+            toolName: b.name
+          });
+          const id = clusters.next(base);
+          msgs.push({
+            id,
+            role: "assistant",
+            contentType: "tool-call",
+            toolName: b.name,
+            toolCallId: b.id,
+            text: safeStringify(b.input)
+          });
+          if (b.cache_control) cacheControls.set(id, b.cache_control);
+          break;
+        }
+        case "tool_result": {
+          const text = typeof b.content === "string" ? b.content : b.content.map((c) => c.text).join("\n");
+          const base = deriveMessageId("tool", "tool-result", text, { toolCallId: b.tool_use_id });
+          const id = clusters.next(base);
+          msgs.push({
+            id,
+            role: "tool",
+            contentType: "tool-result",
+            toolCallId: b.tool_use_id,
+            text,
+            ...b.is_error === true ? { toolIsError: true } : {}
+          });
+          if (b.cache_control) cacheControls.set(id, b.cache_control);
+          break;
+        }
+        case "thinking": {
+          const base = deriveMessageId("assistant", "reasoning", b.thinking);
+          msgs.push({
+            id: clusters.next(base),
+            role: "assistant",
+            contentType: "reasoning",
+            text: b.thinking,
+            ...b.signature ? { thinkingSignature: b.signature } : {}
+          });
+          break;
+        }
+        case "image": {
+          const base = deriveMessageId(m.role, "text", "[image]");
+          msgs.push({
+            id: clusters.next(base),
+            role: m.role,
+            contentType: "text",
+            text: "[image]",
+            rawAnthropicBlock: b
+          });
+          break;
+        }
+      }
+    }
+  }
+  return { msgs, cacheControls };
+}
+function coreToAnthropic(messages, cacheControls) {
+  const out = [];
+  let current = null;
+  const flush = () => {
+    if (current && current.blocks.length > 0) {
+      out.push({ role: current.role, content: current.blocks });
+    }
+    current = null;
+  };
+  const cc = (id) => {
+    const v = cacheControls?.get(id);
+    return v ? { cache_control: v } : {};
+  };
+  for (const m of messages) {
+    const target = m.role === "assistant" ? "assistant" : "user";
+    if (!current || current.role !== target) {
+      flush();
+      current = { role: target, blocks: [] };
+    }
+    switch (m.contentType) {
+      case "text": {
+        if (m.rawAnthropicBlock) {
+          current.blocks.push(m.rawAnthropicBlock);
+          break;
+        }
+        current.blocks.push({ type: "text", text: m.text ?? "", ...cc(m.id) });
+        break;
+      }
+      case "tool-call":
+        current.blocks.push({
+          type: "tool_use",
+          id: m.toolCallId ?? `call_${m.id}`,
+          name: m.toolName ?? "unknown",
+          input: safeParse(m.text),
+          ...cc(m.id)
+        });
+        break;
+      case "tool-result":
+        current.blocks.push({
+          type: "tool_result",
+          tool_use_id: m.toolCallId ?? "",
+          content: m.text ?? "",
+          ...m.toolIsError ? { is_error: true } : {},
+          ...cc(m.id)
+        });
+        break;
+      case "reasoning":
+        current.blocks.push({
+          type: "thinking",
+          thinking: m.text ?? "",
+          ...m.thinkingSignature ? { signature: m.thinkingSignature } : {}
+        });
+        break;
+    }
+  }
+  flush();
+  return out;
+}
+function conversationSignalAnthropic(body, headerValue) {
+  if (headerValue && headerValue.trim()) return headerValue.trim();
+  const firstUser = body.messages.find((m) => m.role === "user");
+  const seed = firstUser ? JSON.stringify(firstUser.content) : "default";
+  return hashId(seed);
+}
+function safeStringify(v) {
+  try {
+    return JSON.stringify(v ?? {});
+  } catch {
+    return "{}";
+  }
+}
+function safeParse(s) {
+  if (!s) return {};
+  try {
+    return JSON.parse(s);
+  } catch {
+    return {};
+  }
+}
+
+// src/wire/bili-message.ts
+function toCoreMessages(msgs) {
+  return msgs;
+}
+function parseDataUrl(url) {
+  const m = /^data:([^;,]+)(?:;base64)?,(.+)$/i.exec(url);
+  if (!m) return void 0;
+  return { mediaType: m[1], base64: m[2] };
+}
+
+// src/wire/openai.ts
+function openaiToCore(body) {
+  const msgs = [];
+  const clusters = new ClusterCounter();
+  for (const m of body.messages) {
+    switch (m.role) {
+      case "system":
+      case "developer": {
+        const base = deriveMessageId(m.role, "text", stringContent(m.content));
+        msgs.push({ id: clusters.next(base), role: "system", contentType: "text", text: stringContent(m.content), originalRole: m.role });
+        break;
+      }
+      case "user": {
+        const text = stringContent(m.content);
+        const img = firstImagePart(m.content);
+        const base = deriveMessageId("user", "text", text);
+        msgs.push({
+          id: clusters.next(base),
+          role: "user",
+          contentType: "text",
+          text,
+          ...img ? { rawOpenaiContent: img.part, imageMediaType: img.mediaType, imageBase64: img.base64 } : {}
+        });
+        break;
+      }
+      case "assistant": {
+        const reasoning = typeof m.reasoning_content === "string" ? m.reasoning_content : "";
+        if (reasoning) {
+          const base = deriveMessageId("assistant", "reasoning", reasoning);
+          msgs.push({
+            id: clusters.next(base),
+            role: "assistant",
+            contentType: "reasoning",
+            text: reasoning,
+            reasoningContent: reasoning
+          });
+        }
+        const text = stringContent(m.content);
+        if (text) {
+          const base = deriveMessageId("assistant", "text", text);
+          msgs.push({ id: clusters.next(base), role: "assistant", contentType: "text", text });
+        }
+        if (Array.isArray(m.tool_calls)) {
+          for (const tc of m.tool_calls) {
+            const base = deriveMessageId("assistant", "tool-call", tc.function.arguments ?? "", {
+              toolCallId: tc.id,
+              toolName: tc.function.name
+            });
+            msgs.push({
+              id: clusters.next(base),
+              role: "assistant",
+              contentType: "tool-call",
+              toolName: tc.function.name,
+              toolCallId: tc.id,
+              text: tc.function.arguments ?? ""
+            });
+          }
+        }
+        break;
+      }
+      case "tool": {
+        const base = deriveMessageId("tool", "tool-result", stringContent(m.content), {
+          toolCallId: m.tool_call_id ?? ""
+        });
+        msgs.push({
+          id: clusters.next(base),
+          role: "tool",
+          contentType: "tool-result",
+          toolCallId: m.tool_call_id ?? "",
+          text: stringContent(m.content)
+        });
+        break;
+      }
+    }
+  }
+  return { msgs };
+}
+function coreToOpenai(messages) {
+  const out = [];
+  let pending = null;
+  const flush = () => {
+    if (!pending) return;
+    const reasoning = pending.reasoning !== null && pending.reasoning.length > 0 ? pending.reasoning : void 0;
+    if (pending.toolCalls.length > 0) {
+      out.push({
+        role: "assistant",
+        content: pending.text ?? null,
+        tool_calls: pending.toolCalls,
+        ...reasoning ? { reasoning_content: reasoning } : {}
+      });
+    } else if (pending.text !== null) {
+      out.push({ role: "assistant", content: pending.text, ...reasoning ? { reasoning_content: reasoning } : {} });
+    } else if (reasoning) {
+      out.push({ role: "assistant", content: null, reasoning_content: reasoning });
+    }
+    pending = null;
+  };
+  for (const m of messages) {
+    if (m.role === "assistant") {
+      if (!pending) pending = { text: null, toolCalls: [], reasoning: null };
+      if (m.contentType === "reasoning") {
+        pending.reasoning = (pending.reasoning ?? "") + (m.reasoningContent ?? m.text ?? "");
+      } else if (m.contentType === "text") {
+        pending.text = (pending.text ?? "") + (m.text ?? "");
+      } else if (m.contentType === "tool-call") {
+        pending.toolCalls.push({
+          id: m.toolCallId ?? `call_${m.id}`,
+          type: "function",
+          function: { name: m.toolName ?? "unknown", arguments: m.text ?? "" }
+        });
+      }
+    } else {
+      flush();
+      if (m.role === "system") {
+        out.push({ role: m.originalRole === "developer" ? "developer" : "system", content: m.text ?? "" });
+      } else if (m.role === "user") {
+        if (m.rawOpenaiContent || m.imageBase64) {
+          const parts = [];
+          if (m.text) parts.push({ type: "text", text: m.text });
+          if (m.rawOpenaiContent) {
+            parts.push(m.rawOpenaiContent);
+          } else if (m.imageBase64 && m.imageMediaType) {
+            parts.push({ type: "image_url", image_url: { url: `data:${m.imageMediaType};base64,${m.imageBase64}` } });
+          }
+          out.push({ role: "user", content: parts });
+        } else {
+          out.push({ role: "user", content: m.text ?? "" });
+        }
+      } else if (m.role === "tool") {
+        out.push({ role: "tool", tool_call_id: m.toolCallId ?? "", content: m.text ?? "" });
+      }
+    }
+  }
+  flush();
+  return out;
+}
+function injectOpenaiSystem(messages, parts) {
+  if (parts.length === 0) return messages;
+  const extra = parts.join("\n\n");
+  if (messages.length > 0 && (messages[0]?.role === "system" || messages[0]?.role === "developer")) {
+    const head = messages[0];
+    const base = stringContent(head.content);
+    const merged = base ? `${base}
+
+---
+
+${extra}` : extra;
+    return [{ ...head, content: merged }, ...messages.slice(1)];
+  }
+  return [{ role: "system", content: extra }, ...messages];
+}
+function conversationSignalOpenai(body, headerValue) {
+  if (headerValue && headerValue.trim()) return headerValue.trim();
+  const firstUser = body.messages.find((m) => m.role === "user");
+  const seed = firstUser ? stringContent(firstUser.content) : "default";
+  return hashId(seed);
+}
+function stringContent(content) {
+  if (content == null) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((p) => typeof p === "string" ? p : p.type === "text" ? p.text ?? "" : "").join("\n");
+  }
+  return "";
+}
+function firstImagePart(content) {
+  if (!Array.isArray(content)) return void 0;
+  for (const p of content) {
+    if (p && typeof p === "object" && p.type === "image_url") {
+      const iu = p.image_url;
+      const url = iu?.url;
+      if (typeof url === "string") {
+        const parsed = parseDataUrl(url);
+        if (parsed) return { part: p, mediaType: parsed.mediaType, base64: parsed.base64 };
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/wire/responses.ts
+var OPAQUE_ITEM_TYPES = /* @__PURE__ */ new Set([
+  "additional_tools",
+  "mcp_list_tools"
+]);
+function isOpaqueItem(item) {
+  return OPAQUE_ITEM_TYPES.has(item.type);
+}
+function shouldDropAllReasoning() {
+  return (process.env.ACP_REASONING_KEEP ?? "").trim().toLowerCase() === "none";
+}
+function partText(part) {
+  if (part.type === "input_text" || part.type === "output_text") {
+    return typeof part.text === "string" ? part.text : "";
+  }
+  return "";
+}
+function messageContent(content) {
+  return typeof content === "string" ? content : content.map(partText).join("\n");
+}
+function responsesToCore(body) {
+  const msgs = [];
+  const systemParts = [];
+  const preamble = [];
+  const customToolCallIds = /* @__PURE__ */ new Set();
+  const layout = [];
+  let droppedReasoning = 0;
+  const clusters = new ClusterCounter();
+  let idx = 0;
+  if (typeof body.instructions === "string" && body.instructions.trim()) systemParts.push(body.instructions);
+  if (typeof body.input === "string") {
+    const id = clusters.next(deriveMessageId("user", "text", body.input));
+    msgs.push({ id, role: "user", contentType: "text", text: body.input });
+    return { msgs, systemParts, preamble, customToolCallIds, layout, droppedReasoning, stringInput: { original: body.input, coreId: id } };
+  }
+  for (const item of body.input) {
+    let coreId;
+    if (isOpaqueItem(item)) preamble.push(item);
+    switch (item.type) {
+      case "reasoning": {
+        if (shouldDropAllReasoning()) {
+          droppedReasoning++;
+          continue;
+        }
+        const rid = typeof item.id === "string" ? String(item.id) : hashId(JSON.stringify(item));
+        coreId = clusters.next(deriveMessageId("assistant", "reasoning", rid));
+        msgs.push({
+          id: coreId,
+          role: "assistant",
+          contentType: "reasoning",
+          text: rid,
+          rawResponsesItem: item
+        });
+        break;
+      }
+      case "message": {
+        const message = item;
+        const text = messageContent(message.content);
+        if (message.role === "system" || message.role === "developer") {
+          systemParts.push(text);
+          idx++;
+          continue;
+        } else if (message.role === "user" || message.role === "assistant" && text) {
+          const role = message.role;
+          coreId = clusters.next(deriveMessageId(role, "text", text));
+          const imageUrl = Array.isArray(message.content) ? message.content.find((part) => part.type === "input_image" && typeof part.image_url === "string")?.image_url : void 0;
+          const image = typeof imageUrl === "string" ? parseDataUrl(imageUrl) : void 0;
+          msgs.push({
+            id: coreId,
+            role,
+            contentType: "text",
+            text,
+            rawResponsesItem: item,
+            ...image ? { imageMediaType: image.mediaType, imageBase64: image.base64 } : {}
+          });
+        }
+        break;
+      }
+      case "function_call": {
+        const call = item;
+        coreId = clusters.next(deriveMessageId("assistant", "tool-call", call.arguments ?? "", {
+          toolCallId: call.call_id,
+          toolName: call.name
+        }));
+        msgs.push({
+          id: coreId,
+          role: "assistant",
+          contentType: "tool-call",
+          toolName: call.name,
+          toolCallId: call.call_id,
+          text: call.arguments ?? "",
+          rawResponsesItem: item
+        });
+        break;
+      }
+      case "function_call_output": {
+        const output = item;
+        const text = typeof output.output === "string" ? output.output : JSON.stringify(output.output);
+        coreId = clusters.next(deriveMessageId("tool", "tool-result", text, { toolCallId: output.call_id }));
+        msgs.push({ id: coreId, role: "tool", contentType: "tool-result", toolCallId: output.call_id, text, rawResponsesItem: item });
+        break;
+      }
+      case "computer_call":
+      case "computer_call_output":
+      case "file_search_call":
+      case "web_search_call":
+      case "image_generation_call":
+      case "code_interpreter_call":
+      case "mcp_call": {
+        const rid = typeof item.id === "string" ? String(item.id) : hashId(JSON.stringify(item));
+        coreId = clusters.next(deriveMessageId("assistant", "responses-call", rid));
+        msgs.push({ id: coreId, role: "assistant", contentType: "reasoning", text: rid, rawResponsesItem: item });
+        break;
+      }
+      case "custom_tool_call": {
+        const ctc = item;
+        const callId = ctc.call_id ?? `call_${idx}`;
+        customToolCallIds.add(callId);
+        const argText = ctc.input ?? ctc.arguments ?? "";
+        coreId = clusters.next(deriveMessageId("assistant", "tool-call", argText, { toolCallId: callId, toolName: ctc.name ?? "custom" }));
+        msgs.push({ id: coreId, role: "assistant", contentType: "tool-call", toolName: ctc.name ?? "custom", toolCallId: callId, text: argText, rawResponsesItem: item });
+        break;
+      }
+      case "custom_tool_call_output": {
+        const ctco = item;
+        const callId = ctco.call_id ?? `call_${idx}`;
+        customToolCallIds.add(callId);
+        const outText = typeof ctco.output === "string" ? ctco.output : JSON.stringify(ctco.output ?? "");
+        coreId = clusters.next(deriveMessageId("tool", "tool-result", outText, { toolCallId: callId }));
+        msgs.push({ id: coreId, role: "tool", contentType: "tool-result", toolCallId: callId, text: outText, rawResponsesItem: item });
+        break;
+      }
+      default:
+        if (!isOpaqueItem(item)) preamble.push(item);
+        break;
+    }
+    layout.push({ original: item, coreId });
+    idx++;
+  }
+  return { msgs, systemParts, preamble, customToolCallIds, layout, droppedReasoning };
+}
+function patchTextParts(parts, text) {
+  const textIndexes = parts.flatMap(
+    (part, index) => part.type === "input_text" || part.type === "output_text" ? [index] : []
+  );
+  if (textIndexes.length === 0) return [{ type: "input_text", text }, ...parts];
+  const first = textIndexes[0];
+  const remaining = new Set(textIndexes.slice(1));
+  return parts.map((part, index) => {
+    if (index === first) return { ...part, text };
+    if (remaining.has(index)) return { ...part, text: "" };
+    return part;
+  });
+}
+function patchOriginalItem(original, source, next) {
+  if (source.text === next.text && source.toolName === next.toolName && source.toolCallId === next.toolCallId && source.role === next.role && source.contentType === next.contentType) return original;
+  if (original.type === "message") {
+    const message = original;
+    const content = typeof message.content === "string" ? next.text ?? "" : patchTextParts(message.content, next.text ?? "");
+    return { ...message, content };
+  }
+  if (original.type === "function_call") {
+    return {
+      ...original,
+      name: next.toolName ?? String(original.name ?? "unknown"),
+      call_id: next.toolCallId ?? String(original.call_id ?? ""),
+      arguments: next.text ?? ""
+    };
+  }
+  if (original.type === "function_call_output") {
+    return { ...original, call_id: next.toolCallId ?? String(original.call_id ?? ""), output: next.text ?? "" };
+  }
+  return original;
+}
+function patchResponsesInput(projection, messages) {
+  if (projection.stringInput) {
+    const original = projection.msgs.find((message) => message.id === projection.stringInput?.coreId);
+    const next = messages.find((message) => message.id === projection.stringInput?.coreId);
+    if (original && next && messages.length === 1 && next.role === "user" && next.contentType === "text") {
+      return next.text === original.text ? projection.stringInput.original : next.text ?? "";
+    }
+    return coreToResponses(messages, projection.customToolCallIds);
+  }
+  const sourceById = new Map(projection.msgs.map((message) => [message.id, message]));
+  const nextById = new Map(messages.map((message) => [message.id, message]));
+  const slotById = /* @__PURE__ */ new Map();
+  projection.layout.forEach((slot, index) => {
+    if (slot.coreId) slotById.set(slot.coreId, index);
+  });
+  const insertions = /* @__PURE__ */ new Map();
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (sourceById.has(message.id)) continue;
+    let target = projection.layout.length;
+    for (let nextIndex = index + 1; nextIndex < messages.length; nextIndex++) {
+      const slot = slotById.get(messages[nextIndex].id);
+      if (slot !== void 0) {
+        target = slot;
+        break;
+      }
+    }
+    const generated = coreToResponses([message], projection.customToolCallIds);
+    if (generated.length > 0) insertions.set(target, [...insertions.get(target) ?? [], ...generated]);
+  }
+  const out = [];
+  projection.layout.forEach((slot, index) => {
+    out.push(...insertions.get(index) ?? []);
+    if (!slot.coreId) {
+      out.push(slot.original);
+      return;
+    }
+    const source = sourceById.get(slot.coreId);
+    const next = nextById.get(slot.coreId);
+    if (source && next) out.push(patchOriginalItem(slot.original, source, next));
+  });
+  out.push(...insertions.get(projection.layout.length) ?? []);
+  return out;
+}
+function coreToResponses(messages, customToolCallIds = /* @__PURE__ */ new Set()) {
+  const out = [];
+  for (const message of messages) {
+    const biliMessage = message;
+    const raw = biliMessage.rawResponsesItem;
+    if (message.role === "system") {
+      out.push({ type: "message", role: "developer", content: message.text ?? "" });
+    } else if (message.role === "user") {
+      if (raw?.type === "message" && messageContent(raw.content) === (message.text ?? "")) out.push(raw);
+      else out.push({ type: "message", role: "user", content: message.text ?? "" });
+    } else if (message.role === "assistant") {
+      if (message.contentType === "text") {
+        out.push({ type: "message", role: "assistant", content: message.text ?? "" });
+      } else if (message.contentType === "tool-call") {
+        const callId = message.toolCallId ?? `call_${message.id}`;
+        if (customToolCallIds.has(callId)) {
+          out.push({ type: "custom_tool_call", call_id: callId, name: message.toolName ?? "unknown", input: message.text ?? "", status: "completed" });
+        } else {
+          out.push({ type: "function_call", call_id: callId, name: message.toolName ?? "unknown", arguments: message.text ?? "" });
+        }
+      } else if (message.contentType === "reasoning") {
+        if (raw) out.push(raw);
+      }
+    } else if (message.role === "tool") {
+      const callId = message.toolCallId ?? "";
+      if (customToolCallIds.has(callId)) {
+        out.push({ type: "custom_tool_call_output", call_id: callId, output: message.text ?? "" });
+      } else {
+        out.push({ type: "function_call_output", call_id: callId, output: message.text ?? "" });
+      }
+    }
+  }
+  return out;
+}
+function injectResponsesDeveloperMessage(input, content) {
+  const items = typeof input === "string" ? [{ type: "message", role: "user", content: input }] : [...input];
+  let index = 0;
+  while (items[index]?.type === "additional_tools") index++;
+  items.splice(index, 0, { type: "message", role: "developer", content });
+  return items;
+}
+function conversationIdentityResponses(body, headerValue) {
+  if (headerValue?.trim()) return { value: headerValue.trim(), source: "header", clientProvided: true };
+  if (typeof body.session_id === "string" && body.session_id.trim()) {
+    return { value: body.session_id.trim(), source: "body-session", clientProvided: true };
+  }
+  const metadataSession = body.metadata?.session_id;
+  if (typeof metadataSession === "string" && metadataSession.trim()) {
+    return { value: metadataSession.trim(), source: "metadata-session", clientProvided: true };
+  }
+  if (typeof body.previous_response_id === "string" && body.previous_response_id.trim()) {
+    return { value: body.previous_response_id.trim(), source: "previous-response", clientProvided: false };
+  }
+  return { value: hashId(JSON.stringify(body.input ?? [])), source: "content-fingerprint", clientProvided: false };
+}
+function conversationSignalResponses(body, headerValue) {
+  return conversationIdentityResponses(body, headerValue).value;
+}
+export {
+  ClusterCounter,
+  anthropicToCore,
+  buildSystem,
+  conversationIdentityResponses,
+  conversationSignalAnthropic,
+  conversationSignalOpenai,
+  conversationSignalResponses,
+  coreToAnthropic,
+  coreToOpenai,
+  coreToResponses,
+  deriveMessageId,
+  extractSystem,
+  hashId,
+  injectOpenaiSystem,
+  injectResponsesDeveloperMessage,
+  openaiToCore,
+  parseDataUrl,
+  patchResponsesInput,
+  responsesToCore,
+  toCoreMessages
+};
+//# sourceMappingURL=index.js.map