@lostgradient/cinder 0.5.0 → 0.6.0

package/dist/server/index-49we2xfs.js

@@ -0,0 +1,344 @@
+import {
+  isCanonicalToolResultPayload,
+  toJSONValue
+} from "./index.server-n5cdmsz4.js";
+import {
+  appendMessages,
+  assertConversationSafe,
+  createConversationHistory,
+  getOrderedMessages,
+  isStreamingMessage
+} from "./index.server-rjap4k7y.js";
+import"./index.server-0v6na3yp.js";
+
+// ../../node_modules/conversationalist/dist/adapters/gemini/index.js
+var DEFAULT_FILE_MIME_TYPE = "application/octet-stream";
+var MIME_TYPE_BY_EXTENSION = {
+  bmp: "image/bmp",
+  gif: "image/gif",
+  heic: "image/heic",
+  heif: "image/heif",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  png: "image/png",
+  svg: "image/svg+xml",
+  webp: "image/webp"
+};
+function inferMimeType(url) {
+  const trimmed = url.split("#")[0]?.split("?")[0] ?? "";
+  const dotIndex = trimmed.lastIndexOf(".");
+  if (dotIndex === -1)
+    return;
+  return MIME_TYPE_BY_EXTENSION[trimmed.slice(dotIndex + 1).toLowerCase()];
+}
+function resolveMimeType(url, explicit) {
+  return explicit ?? inferMimeType(url) ?? DEFAULT_FILE_MIME_TYPE;
+}
+function normalizeGeminiResponse(toolResult) {
+  if (toolResult.outcome === "success") {
+    if (toolResult.content !== null && typeof toolResult.content === "object")
+      return toolResult.content;
+    return { result: toolResult.content };
+  }
+  return {
+    outcome: toolResult.outcome,
+    content: toolResult.content,
+    ...toolResult.error ? { error: toolResult.error } : {},
+    ...toolResult.action ? { action: toolResult.action } : {}
+  };
+}
+function toGeminiParts(content) {
+  if (typeof content === "string")
+    return content ? [{ text: content }] : [];
+  const parts = [];
+  for (const part of content)
+    if (part.type === "text") {
+      if (part.text)
+        parts.push({ text: part.text });
+    } else if (part.type === "image") {
+      const url = part.url ?? "";
+      if (url.startsWith("data:")) {
+        const matches = url.match(/^data:([^;]+);base64,(.+)$/);
+        if (matches)
+          parts.push({ inlineData: {
+            mimeType: matches[1],
+            data: matches[2]
+          } });
+      } else {
+        const fileData = {
+          fileUri: url,
+          mimeType: resolveMimeType(url, part.mimeType)
+        };
+        parts.push({ fileData });
+      }
+    }
+  return parts;
+}
+function toFunctionCallPart(toolCall) {
+  let args;
+  if (typeof toolCall.arguments === "string")
+    try {
+      const parsed = JSON.parse(toolCall.arguments);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+        args = parsed;
+      else
+        args = { _value: parsed };
+    } catch {
+      args = { _raw: toolCall.arguments };
+    }
+  else if (toolCall.arguments && typeof toolCall.arguments === "object" && !Array.isArray(toolCall.arguments))
+    args = toolCall.arguments;
+  else
+    args = { _value: toolCall.arguments };
+  return { functionCall: {
+    name: toolCall.name,
+    args
+  } };
+}
+function toFunctionResponsePart(toolResult, functionName) {
+  return { functionResponse: {
+    name: functionName,
+    response: normalizeGeminiResponse(toolResult)
+  } };
+}
+function extractSystemInstruction(messages) {
+  const systemMessages = messages.filter((m) => (m.role === "system" || m.role === "developer") && !m.hidden && !isStreamingMessage(m));
+  if (systemMessages.length === 0)
+    return;
+  const parts = [];
+  for (const msg of systemMessages)
+    parts.push(...toGeminiParts(msg.content));
+  if (parts.length === 0)
+    return;
+  return {
+    role: "user",
+    parts
+  };
+}
+function toGeminiMessages(conversation) {
+  assertConversationSafe(conversation);
+  const ordered = getOrderedMessages(conversation);
+  const systemInstruction = extractSystemInstruction(ordered);
+  const toolCallNames = /* @__PURE__ */ new Map;
+  for (const message of ordered)
+    if (message.role === "tool-call" && message.toolCall)
+      toolCallNames.set(message.toolCall.id, message.toolCall.name);
+  const contents = [];
+  let currentRole = null;
+  let currentParts = [];
+  const flushCurrent = () => {
+    if (currentRole && currentParts.length > 0) {
+      contents.push({
+        role: currentRole,
+        parts: currentParts
+      });
+      currentParts = [];
+    }
+    currentRole = null;
+  };
+  for (const message of ordered) {
+    if (message.hidden)
+      continue;
+    if (isStreamingMessage(message))
+      continue;
+    if (message.role === "system" || message.role === "developer")
+      continue;
+    if (message.role === "snapshot")
+      continue;
+    let targetRole;
+    let parts;
+    if (message.role === "user") {
+      targetRole = "user";
+      parts = toGeminiParts(message.content);
+    } else if (message.role === "assistant") {
+      targetRole = "model";
+      parts = toGeminiParts(message.content);
+    } else if (message.role === "tool-call" && message.toolCall) {
+      targetRole = "model";
+      parts = [toFunctionCallPart(message.toolCall)];
+    } else if (message.role === "tool-result" && message.toolResult) {
+      targetRole = "user";
+      const functionName = toolCallNames.get(message.toolResult.callId) ?? "unknown";
+      parts = [toFunctionResponsePart(message.toolResult, functionName)];
+    } else
+      continue;
+    if (parts.length === 0)
+      continue;
+    if (currentRole === targetRole)
+      currentParts.push(...parts);
+    else {
+      flushCurrent();
+      currentRole = targetRole;
+      currentParts = parts;
+    }
+  }
+  flushCurrent();
+  const result = { contents };
+  if (systemInstruction !== undefined)
+    result.systemInstruction = systemInstruction;
+  return result;
+}
+function parseFunctionArguments(args) {
+  if (Object.keys(args).length === 1 && Object.hasOwn(args, "_value"))
+    return toJSONValue(args["_value"]);
+  if (Object.keys(args).length === 1 && Object.hasOwn(args, "_raw") && typeof args["_raw"] === "string")
+    return args["_raw"];
+  return toJSONValue(args);
+}
+function parseFunctionResponse(callId, response) {
+  const value = toJSONValue(response);
+  if (isCanonicalToolResultPayload(value))
+    return {
+      callId,
+      outcome: value.outcome,
+      content: value.content,
+      ...value.error ? { error: value.error } : {},
+      ...value.action ? { action: value.action } : {},
+      ...typeof value.inputDigest === "string" ? { inputDigest: value.inputDigest } : {},
+      ...typeof value.outputDigest === "string" ? { outputDigest: value.outputDigest } : {}
+    };
+  if (value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 1 && Object.hasOwn(value, "result"))
+    return {
+      callId,
+      outcome: "success",
+      content: toJSONValue(value.result)
+    };
+  return {
+    callId,
+    outcome: "success",
+    content: value
+  };
+}
+function toContentFromGeminiPart(part) {
+  if ("text" in part)
+    return part.text;
+  if ("inlineData" in part)
+    return [{
+      type: "image",
+      url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`,
+      mimeType: part.inlineData.mimeType
+    }];
+  return [{
+    type: "image",
+    url: part.fileData.fileUri,
+    mimeType: part.fileData.mimeType
+  }];
+}
+function toSystemInstructionContent(parts) {
+  const contentParts = [];
+  for (const part of parts)
+    if ("text" in part)
+      contentParts.push({
+        type: "text",
+        text: part.text
+      });
+    else if ("inlineData" in part)
+      contentParts.push({
+        type: "image",
+        url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`,
+        mimeType: part.inlineData.mimeType
+      });
+    else if ("fileData" in part)
+      contentParts.push({
+        type: "image",
+        url: part.fileData.fileUri,
+        mimeType: part.fileData.mimeType
+      });
+  if (contentParts.length === 0)
+    return;
+  if (contentParts.length === 1 && contentParts[0]?.type === "text")
+    return contentParts[0].text ?? "";
+  return contentParts;
+}
+function toMessageInputs(payload) {
+  const inputs = [];
+  let syntheticToolCallCount = 0;
+  const pendingToolCalls = /* @__PURE__ */ new Map;
+  const queueToolCall = (name, callId) => {
+    const queued = pendingToolCalls.get(name) ?? [];
+    queued.push(callId);
+    pendingToolCalls.set(name, queued);
+  };
+  const dequeueToolCall = (name) => {
+    const queued = pendingToolCalls.get(name);
+    if (!queued || queued.length === 0)
+      return;
+    const [callId, ...rest] = queued;
+    if (rest.length === 0)
+      pendingToolCalls.delete(name);
+    else
+      pendingToolCalls.set(name, rest);
+    return callId;
+  };
+  const systemContent = payload.systemInstruction ? toSystemInstructionContent(payload.systemInstruction.parts) : undefined;
+  if (systemContent !== undefined)
+    inputs.push({
+      role: "system",
+      content: systemContent
+    });
+  for (const content of payload.contents) {
+    const role = content.role === "model" ? "assistant" : "user";
+    for (const part of content.parts) {
+      if ("functionCall" in part) {
+        const callId = `gemini-call-${++syntheticToolCallCount}`;
+        queueToolCall(part.functionCall.name, callId);
+        inputs.push({
+          role: "tool-call",
+          content: "",
+          toolCall: {
+            id: callId,
+            name: part.functionCall.name,
+            arguments: parseFunctionArguments(part.functionCall.args)
+          }
+        });
+        continue;
+      }
+      if ("functionResponse" in part) {
+        const callId = dequeueToolCall(part.functionResponse.name) ?? `gemini-call-${++syntheticToolCallCount}`;
+        inputs.push({
+          role: "tool-result",
+          content: "",
+          toolResult: parseFunctionResponse(callId, part.functionResponse.response)
+        });
+        continue;
+      }
+      inputs.push({
+        role,
+        content: toContentFromGeminiPart(part)
+      });
+    }
+  }
+  return inputs;
+}
+function fromGeminiMessages(payload) {
+  let conversation = createConversationHistory();
+  const inputs = toMessageInputs(payload);
+  if (inputs.length > 0)
+    conversation = appendMessages(conversation, ...inputs);
+  return conversation;
+}
+function appendGeminiMessages(conversation, payload) {
+  const inputs = toMessageInputs(payload);
+  if (inputs.length === 0)
+    return conversation;
+  return appendMessages(conversation, ...inputs);
+}
+var geminiConversationAdapter = {
+  export(conversation) {
+    return toGeminiMessages(conversation);
+  },
+  import(payload) {
+    return fromGeminiMessages(payload);
+  },
+  append(conversation, payload) {
+    return appendGeminiMessages(conversation, payload);
+  }
+};
+export {
+  toGeminiMessages,
+  geminiConversationAdapter,
+  fromGeminiMessages,
+  appendGeminiMessages
+};
+
+//# debugId=A9243EAE4BC9430164756E2164756E21

package/dist/server/index-8fhvxk30.js

@@ -0,0 +1,265 @@
+import {
+  isCanonicalToolResultPayload,
+  parseJSONValue
+} from "./index.server-n5cdmsz4.js";
+import {
+  appendMessages,
+  assertConversationSafe,
+  createConversationHistory,
+  getOrderedMessages,
+  isStreamingMessage
+} from "./index.server-rjap4k7y.js";
+import"./index.server-0v6na3yp.js";
+
+// ../../node_modules/conversationalist/dist/adapters/openai/index.js
+function toOpenAIContent(content, options = {}) {
+  if (typeof content === "string")
+    return content;
+  const allowImages = options.allowImages ?? true;
+  const parts = [];
+  for (const part of content)
+    if (part.type === "text")
+      parts.push({
+        type: "text",
+        text: part.text ?? ""
+      });
+    else if (part.type === "image" && allowImages)
+      parts.push({
+        type: "image_url",
+        image_url: { url: part.url ?? "" }
+      });
+  if (parts.length === 0)
+    return "";
+  if (parts.length === 1 && parts[0]?.type === "text")
+    return parts[0].text;
+  return allowImages ? parts : parts;
+}
+function toOpenAITextContent(content) {
+  return toOpenAIContent(content, { allowImages: false });
+}
+function toOpenAIToolCall(toolCall) {
+  return {
+    id: toolCall.id,
+    type: "function",
+    function: {
+      name: toolCall.name,
+      arguments: typeof toolCall.arguments === "string" ? toolCall.arguments : JSON.stringify(toolCall.arguments)
+    }
+  };
+}
+function convertMessage(message) {
+  if (message.hidden)
+    return null;
+  if (isStreamingMessage(message))
+    return null;
+  switch (message.role) {
+    case "system":
+    case "developer":
+      return {
+        role: "system",
+        content: toOpenAITextContent(message.content)
+      };
+    case "user":
+      return {
+        role: "user",
+        content: toOpenAIContent(message.content)
+      };
+    case "assistant":
+      return {
+        role: "assistant",
+        content: toOpenAITextContent(message.content)
+      };
+    case "tool-call":
+      if (!message.toolCall)
+        return null;
+      return {
+        role: "assistant",
+        content: null,
+        tool_calls: [toOpenAIToolCall(message.toolCall)]
+      };
+    case "tool-result":
+      if (!message.toolResult)
+        return null;
+      return {
+        role: "tool",
+        content: stringifyToolResult(message.toolResult),
+        tool_call_id: message.toolResult.callId
+      };
+    case "snapshot":
+      return null;
+  }
+}
+function stringifyToolResult(result) {
+  const payload = result.outcome === "success" ? result.content : {
+    outcome: result.outcome,
+    content: result.content,
+    ...result.error ? { error: result.error } : {},
+    ...result.action ? { action: result.action } : {}
+  };
+  if (typeof payload === "string")
+    return payload;
+  return JSON.stringify(payload);
+}
+function toConversationContent(content) {
+  if (content === null)
+    return;
+  if (typeof content === "string")
+    return content;
+  const parts = content.map((part) => part.type === "text" ? {
+    type: "text",
+    text: part.text
+  } : {
+    type: "image",
+    url: part.image_url.url
+  });
+  if (parts.length === 0)
+    return "";
+  if (parts.length === 1 && parts[0]?.type === "text")
+    return parts[0].text ?? "";
+  return parts;
+}
+function parseToolArguments(value) {
+  return parseJSONValue(value) ?? value;
+}
+function parseToolResult(callId, content) {
+  const serialized = typeof content === "string" ? content : content.map((part) => part.text).join(`
+
+`);
+  const parsed = parseJSONValue(serialized);
+  if (parsed !== undefined && isCanonicalToolResultPayload(parsed))
+    return {
+      callId,
+      outcome: parsed.outcome,
+      content: parsed.content,
+      ...parsed.error ? { error: parsed.error } : {},
+      ...parsed.action ? { action: parsed.action } : {},
+      ...typeof parsed.inputDigest === "string" ? { inputDigest: parsed.inputDigest } : {},
+      ...typeof parsed.outputDigest === "string" ? { outputDigest: parsed.outputDigest } : {}
+    };
+  return {
+    callId,
+    outcome: "success",
+    content: parsed ?? serialized
+  };
+}
+function toMessageInputs(messages) {
+  const inputs = [];
+  for (const message of messages)
+    switch (message.role) {
+      case "system":
+        inputs.push({
+          role: "system",
+          content: toConversationContent(message.content) ?? ""
+        });
+        break;
+      case "user":
+        inputs.push({
+          role: "user",
+          content: toConversationContent(message.content) ?? ""
+        });
+        break;
+      case "assistant": {
+        const assistantContent = toConversationContent(message.content);
+        if (assistantContent !== undefined && (typeof assistantContent === "string" ? assistantContent.length > 0 : assistantContent.length > 0))
+          inputs.push({
+            role: "assistant",
+            content: assistantContent
+          });
+        for (const toolCall of message.tool_calls ?? [])
+          inputs.push({
+            role: "tool-call",
+            content: "",
+            toolCall: {
+              id: toolCall.id,
+              name: toolCall.function.name,
+              arguments: parseToolArguments(toolCall.function.arguments)
+            }
+          });
+        break;
+      }
+      case "tool":
+        inputs.push({
+          role: "tool-result",
+          content: "",
+          toolResult: parseToolResult(message.tool_call_id, message.content)
+        });
+        break;
+    }
+  return inputs;
+}
+function toOpenAIMessages(conversation) {
+  assertConversationSafe(conversation);
+  const messages = [];
+  for (const message of getOrderedMessages(conversation)) {
+    const converted = convertMessage(message);
+    if (converted)
+      messages.push(converted);
+  }
+  return messages;
+}
+function toOpenAIMessagesGrouped(conversation) {
+  assertConversationSafe(conversation);
+  const messages = [];
+  let pendingToolCalls = [];
+  for (const message of getOrderedMessages(conversation)) {
+    if (message.hidden)
+      continue;
+    if (isStreamingMessage(message))
+      continue;
+    if (message.role === "tool-call" && message.toolCall) {
+      pendingToolCalls.push(toOpenAIToolCall(message.toolCall));
+      continue;
+    }
+    if (pendingToolCalls.length > 0) {
+      messages.push({
+        role: "assistant",
+        content: null,
+        tool_calls: pendingToolCalls
+      });
+      pendingToolCalls = [];
+    }
+    const converted = convertMessage(message);
+    if (converted && message.role !== "tool-call")
+      messages.push(converted);
+  }
+  if (pendingToolCalls.length > 0)
+    messages.push({
+      role: "assistant",
+      content: null,
+      tool_calls: pendingToolCalls
+    });
+  return messages;
+}
+function fromOpenAIMessages(messages) {
+  let conversation = createConversationHistory();
+  const inputs = toMessageInputs(messages);
+  if (inputs.length > 0)
+    conversation = appendMessages(conversation, ...inputs);
+  return conversation;
+}
+function appendOpenAIMessages(conversation, messages) {
+  const inputs = toMessageInputs(messages);
+  if (inputs.length === 0)
+    return conversation;
+  return appendMessages(conversation, ...inputs);
+}
+var openAIConversationAdapter = {
+  export(conversation, options = {}) {
+    return options.groupToolCalls === false ? toOpenAIMessages(conversation) : toOpenAIMessagesGrouped(conversation);
+  },
+  import(messages) {
+    return fromOpenAIMessages(messages);
+  },
+  append(conversation, messages) {
+    return appendOpenAIMessages(conversation, messages);
+  }
+};
+export {
+  toOpenAIMessagesGrouped,
+  toOpenAIMessages,
+  openAIConversationAdapter,
+  fromOpenAIMessages,
+  appendOpenAIMessages
+};
+
+//# debugId=0A5BA28B9394E94C64756E2164756E21