llm-messages 0.5.1 → 0.5.2

package/dist/index.js

@@ -17,6 +17,7 @@ function textOf(content) {
     return content.map((part) => {
       if (typeof part === "string") return part;
       if (isRecord(part) && typeof part.text === "string") return part.text;
+      if (isRecord(part) && part.type === "refusal" && typeof part.refusal === "string") return part.refusal;
       return "";
     }).join("");
   }
@@ -38,17 +39,83 @@ function parseArguments(args, reporter, fnName) {
   );
   return {};
 }
+function stringifyArgumentsObject(value, reporter, provider, part, fnName) {
+  if (value === void 0) return "{}";
+  if (isRecord(value)) {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      reporter.warn(
+        "invalid-json-arguments",
+        `${provider} ${part} '${fnName}' had arguments that could not be serialized as JSON; used an empty object instead.`
+      );
+      return "{}";
+    }
+  }
+  reporter.warn(
+    "invalid-json-arguments",
+    `${provider} ${part} '${fnName}' had arguments that were not an object; used an empty object instead.`
+  );
+  return "{}";
+}
+var OPENAI_FUNCTION_NAME = /^[a-zA-Z0-9_-]{1,64}$/;
+function isProviderFunctionName(value) {
+  return typeof value === "string" && OPENAI_FUNCTION_NAME.test(value);
+}
+function providerFunctionName(value, reporter, provider, part) {
+  if (isProviderFunctionName(value)) return value;
+  reporter.warn(
+    "dropped-metadata",
+    `${provider} ${part} had a missing or invalid function name; used 'unknown_function'.`
+  );
+  return "unknown_function";
+}
+function createToolCallIdGenerator(reservedIds = []) {
+  const reserved = new Set(reservedIds);
+  const used = /* @__PURE__ */ new Set();
+  let counter = 0;
+  const generate = (name) => {
+    let id;
+    do {
+      id = `call_${name.replace(/[^a-zA-Z0-9_-]/g, "_")}_${counter++}`;
+    } while (used.has(id) || reserved.has(id));
+    used.add(id);
+    return id;
+  };
+  return {
+    claim(id, name) {
+      if (used.has(id)) return generate(name);
+      used.add(id);
+      reserved.delete(id);
+      return id;
+    },
+    generate(name) {
+      return generate(name);
+    }
+  };
+}
 function wrapResponse(content) {
   const parsed = tryParseJson(content);
   if (parsed.ok && isRecord(parsed.value)) return parsed.value;
   return { result: content };
 }
-function unwrapResponse(response) {
-  const keys = Object.keys(response);
-  if (keys.length === 1 && keys[0] === "result" && typeof response.result === "string") {
-    return response.result;
+function unwrapResponse(response, reporter, provider = "Provider", part = "response") {
+  if (response === void 0) return "{}";
+  if (isRecord(response)) {
+    const keys = Object.keys(response);
+    if (keys.length === 1 && keys[0] === "result" && typeof response.result === "string") {
+      return response.result;
+    }
+  }
+  try {
+    return JSON.stringify(response) ?? "{}";
+  } catch {
+    reporter?.warn(
+      "dropped-content",
+      `${provider} ${part} response could not be serialized as JSON; used an empty object instead.`
+    );
+    return "{}";
   }
-  return JSON.stringify(response);
 }
 
 // src/image.ts
@@ -267,6 +334,7 @@ function splitSystem(messages, reporter) {
 }
 
 // src/providers/anthropic.ts
+var nonEmptyString = (value) => typeof value === "string" && value.length > 0;
 function toAnthropic(messages, options = {}) {
   const reporter = new Reporter(options);
   const { system, rest } = splitSystem(messages, reporter);
@@ -328,7 +396,7 @@ function userContent(content, reporter) {
     }
     reporter.warn("dropped-content", "Dropped an unsupported user content part.");
   }
-  return blocks;
+  return blocks.length > 0 ? blocks : "";
 }
 function assistantContent(message, reporter) {
   warnDroppedName("Assistant", message.name, "Anthropic", reporter);
@@ -368,17 +436,59 @@ function mergeConsecutive(messages, reporter) {
   return result;
 }
 function asBlocks(content) {
-  if (typeof content !== "string") return content;
+  if (Array.isArray(content)) return content.filter(isRecord);
+  if (typeof content !== "string") return [];
   return content ? [{ type: "text", text: content }] : [];
 }
+function warnMalformedBlocks(content, reporter) {
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (!isRecord(block)) {
+        reporter.warn("dropped-content", "Dropped a malformed Anthropic content block.");
+      }
+    }
+    return;
+  }
+  if (typeof content !== "string") {
+    reporter.warn("dropped-content", "Dropped malformed Anthropic message content.");
+  }
+}
+function isSupportedUserBlock(block) {
+  return block.type === "text" && typeof block.text === "string" || block.type === "tool_result" || imageFromAnthropic(block) !== null || mediaFromAnthropic(block) !== null;
+}
+function isSupportedAssistantBlock(block) {
+  return block.type === "text" && typeof block.text === "string" || block.type === "tool_use";
+}
+function warnUnsupportedBlocks(blocks, role, reporter) {
+  const isSupported = role === "user" ? isSupportedUserBlock : isSupportedAssistantBlock;
+  for (const block of blocks) {
+    if (isSupported(block)) continue;
+    reporter.warn("dropped-content", `Dropped unsupported Anthropic ${role} content block '${String(block.type)}'.`);
+  }
+}
 function fromAnthropic(conversation, options = {}) {
   const reporter = new Reporter(options);
   const out = [];
-  if (conversation.system) {
-    out.push({ role: "system", content: textOf(conversation.system) });
+  const root = isRecord(conversation) ? conversation : {};
+  const system = textOf(root.system);
+  if (system) {
+    out.push({ role: "system", content: system });
   }
-  for (const message of conversation.messages) {
+  const messages = Array.isArray(root.messages) ? root.messages : [];
+  const ids = createToolCallIdGenerator(anthropicProviderIds(root));
+  const pendingToolUseIds = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (!isRecord(message)) {
+      reporter.warn("dropped-content", "Dropped a malformed Anthropic message.");
+      continue;
+    }
+    if (message.role !== "user" && message.role !== "assistant") {
+      reporter.warn("dropped-content", `Dropped an Anthropic message with unsupported role '${String(message.role)}'.`);
+      continue;
+    }
+    warnMalformedBlocks(message.content, reporter);
     const blocks = asBlocks(message.content);
+    warnUnsupportedBlocks(blocks, message.role, reporter);
     if (message.role === "user") {
       if (blocks.length === 0) {
         out.push({ role: "user", content: "" });
@@ -397,9 +507,28 @@ function fromAnthropic(conversation, options = {}) {
           continue;
         }
         flushContent();
+        const rawToolUseId = block.tool_use_id;
+        const hasToolUseId = nonEmptyString(rawToolUseId);
+        const matchedToolCallId = hasToolUseId ? takePendingToolUseId(pendingToolUseIds, rawToolUseId) : void 0;
+        const toolCallId = matchedToolCallId ?? (hasToolUseId ? ids.claim(rawToolUseId, "tool_result") : ids.generate("tool_result"));
+        if (!hasToolUseId) {
+          reporter.warn(
+            "unmapped-tool-result",
+            `Anthropic tool_result had no usable tool_use_id; generated '${toolCallId}'.`
+          );
+        } else if (!matchedToolCallId) {
+          const unmappedMessage = toolCallId === rawToolUseId ? `Anthropic tool_result '${rawToolUseId}' had no matching tool_use; kept the result id.` : `Anthropic tool_result '${rawToolUseId}' had no matching tool_use; generated '${toolCallId}'.`;
+          reporter.warn("unmapped-tool-result", unmappedMessage);
+          if (toolCallId !== rawToolUseId) {
+            reporter.warn(
+              "generated-id",
+              `Anthropic tool_result '${rawToolUseId}' reused an existing id; generated '${toolCallId}'.`
+            );
+          }
+        }
         out.push({
           role: "tool",
-          tool_call_id: String(block.tool_use_id ?? ""),
+          tool_call_id: toolCallId,
           content: textOf(block.content),
           ...typeof block.is_error === "boolean" ? { is_error: block.is_error } : {}
         });
@@ -413,13 +542,57 @@ function fromAnthropic(conversation, options = {}) {
     if (toolUses.length > 0) {
       assistant.tool_calls = toolUses.map((block) => {
         const b = block;
-        return { id: b.id, type: "function", function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) } };
+        const name = providerFunctionName(b.name, reporter, "Anthropic", "tool_use");
+        const providedId = nonEmptyString(b.id) ? b.id : void 0;
+        const id = providedId ? ids.claim(providedId, name) : ids.generate(name);
+        if (!providedId) {
+          reporter.warn("generated-id", `Anthropic tool_use '${name}' had no id; generated '${id}'.`);
+        } else if (id !== providedId) {
+          reporter.warn("generated-id", `Anthropic tool_use '${name}' reused id '${providedId}'; generated '${id}'.`);
+        }
+        if (providedId) pushPendingToolUseId(pendingToolUseIds, providedId, id);
+        return {
+          id,
+          type: "function",
+          function: {
+            name,
+            arguments: stringifyArgumentsObject(b.input, reporter, "Anthropic", "tool_use", name)
+          }
+        };
       });
     }
     out.push(assistant);
   }
   return out;
 }
+function pushPendingToolUseId(pending, providerId, normalizedId) {
+  const ids = pending.get(providerId);
+  if (ids) ids.push(normalizedId);
+  else pending.set(providerId, [normalizedId]);
+}
+function takePendingToolUseId(pending, providerId) {
+  const ids = pending.get(providerId);
+  const id = ids?.shift();
+  if (ids?.length === 0) pending.delete(providerId);
+  return id;
+}
+function anthropicProviderIds(conversation) {
+  const ids = [];
+  const root = isRecord(conversation) ? conversation : {};
+  const messages = Array.isArray(root.messages) ? root.messages : [];
+  for (const message of messages) {
+    if (!isRecord(message)) continue;
+    for (const block of asBlocks(message.content)) {
+      if (block.type === "tool_use" && nonEmptyString(block.id)) {
+        ids.push(block.id);
+      }
+      if (block.type === "tool_result" && nonEmptyString(block.tool_use_id)) {
+        ids.push(block.tool_use_id);
+      }
+    }
+  }
+  return ids;
+}
 function userContentToOpenAI(blocks, reporter) {
   const hasMedia = blocks.some((block) => imageFromAnthropic(block) !== null || mediaFromAnthropic(block) !== null);
   if (!hasMedia) return textOf(blocks);
@@ -441,10 +614,11 @@ function userContentToOpenAI(blocks, reporter) {
       parts.push({ type: "text", text: block.text });
     }
   }
-  return parts;
+  return parts.length > 0 ? parts : "";
 }
 
 // src/providers/gemini.ts
+var nonEmptyString2 = (value) => typeof value === "string" && value.length > 0;
 function toGemini(messages, options = {}) {
   const reporter = new Reporter(options);
   const { system, rest } = splitSystem(messages, reporter);
@@ -475,8 +649,9 @@ function toGemini(messages, options = {}) {
             `Tool message name '${tool.name}' differs from matching tool call '${matchingName}'; used the tool-call function name for Gemini.`
           );
         }
-        const name = matchingName ?? tool.name;
-        if (!name) {
+        const hasStandaloneName = nonEmptyString2(tool.name);
+        const name = matchingName ?? (hasStandaloneName ? tool.name : tool.tool_call_id);
+        if (!matchingName && !hasStandaloneName) {
           reporter.warn(
             "unmapped-tool-result",
             `Tool result '${tool.tool_call_id}' has no matching call; used the id as the function name.`
@@ -564,31 +739,51 @@ function mergeConsecutive2(contents, reporter) {
 function fromGemini(conversation, options = {}) {
   const reporter = new Reporter(options);
   const out = [];
-  if (conversation.systemInstruction) {
-    const text = textOf(conversation.systemInstruction.parts);
+  const root = isRecord(conversation) ? conversation : {};
+  const systemInstruction = isRecord(root.systemInstruction) ? root.systemInstruction : void 0;
+  if (systemInstruction) {
+    const text = textOf(systemInstruction.parts);
     if (text) out.push({ role: "system", content: text });
   }
   const pending = [];
-  let counter = 0;
-  const generateId = (name) => `call_${name.replace(/[^a-zA-Z0-9_-]/g, "_")}_${counter++}`;
-  for (const content of conversation.contents) {
-    const parts = Array.isArray(content.parts) ? content.parts : [];
+  const contents = Array.isArray(root.contents) ? root.contents : [];
+  const ids = createToolCallIdGenerator(geminiProviderIds(root));
+  for (const content of contents) {
+    if (!isRecord(content)) {
+      reporter.warn("dropped-content", "Dropped a malformed Gemini content entry.");
+      continue;
+    }
     if (content.role === "model") {
+      const parts2 = geminiParts(content, reporter);
       const textPieces = [];
       const toolCalls = [];
-      for (const part of parts) {
+      for (const part of parts2) {
         if (isRecord(part) && isRecord(part.functionCall)) {
           const fc = part.functionCall;
-          const id = fc.id ?? generateId(fc.name);
-          if (!fc.id) reporter.warn("generated-id", `Gemini functionCall '${fc.name}' had no id; generated '${id}'.`);
+          const name = providerFunctionName(fc.name, reporter, "Gemini", "functionCall");
+          const providedId = nonEmptyString2(fc.id) ? fc.id : void 0;
+          const id = providedId ? ids.claim(providedId, name) : ids.generate(name);
+          if (!providedId) {
+            reporter.warn("generated-id", `Gemini functionCall '${name}' had no id; generated '${id}'.`);
+          } else if (id !== providedId) {
+            reporter.warn(
+              "generated-id",
+              `Gemini functionCall '${name}' reused id '${providedId}'; generated '${id}'.`
+            );
+          }
           toolCalls.push({
             id,
             type: "function",
-            function: { name: fc.name, arguments: JSON.stringify(fc.args ?? {}) }
+            function: {
+              name,
+              arguments: stringifyArgumentsObject(fc.args, reporter, "Gemini", "functionCall", name)
+            }
           });
-          pending.push({ id, name: fc.name });
+          pending.push({ id, name, ...providedId ? { providerId: providedId } : {} });
         } else if (isRecord(part) && typeof part.text === "string") {
           textPieces.push(part.text);
+        } else {
+          reporter.warn("dropped-content", "Dropped an unsupported Gemini model content part.");
         }
       }
       const text = textPieces.join("");
@@ -597,17 +792,45 @@ function fromGemini(conversation, options = {}) {
       out.push(assistant);
       continue;
     }
-    const contentParts = [];
+    if (content.role !== void 0 && content.role !== "user") {
+      reporter.warn(
+        "dropped-content",
+        `Dropped a Gemini content entry with unsupported role '${String(content.role)}'.`
+      );
+      continue;
+    }
+    const parts = geminiParts(content, reporter);
+    let contentParts = [];
     let hasMedia = false;
+    let sawUserContent = false;
+    const flushContent = () => {
+      if (!sawUserContent) return;
+      if (contentParts.length === 0) {
+        out.push({ role: "user", content: "" });
+      } else if (hasMedia) {
+        out.push({ role: "user", content: contentParts });
+      } else {
+        const text = textOf(contentParts);
+        out.push({ role: "user", content: text });
+      }
+      contentParts = [];
+      hasMedia = false;
+      sawUserContent = false;
+    };
     for (const part of parts) {
       if (isRecord(part) && isRecord(part.functionResponse)) {
         const fr = part.functionResponse;
-        const { id, matched } = resolveResponseId(fr, pending, reporter, generateId);
+        const response = Object.prototype.hasOwnProperty.call(fr, "response") ? fr.response : {};
+        const responseId = nonEmptyString2(fr.id) ? fr.id : void 0;
+        const matchedName = responseId ? pending.find((pendingCall) => pendingCall.providerId === responseId || pendingCall.id === responseId)?.name : void 0;
+        const name = geminiFunctionResponseName(fr.name, matchedName, reporter);
+        const { id, matched } = resolveResponseId({ id: fr.id, name }, pending, reporter, ids);
+        flushContent();
         out.push({
           role: "tool",
           tool_call_id: id,
-          content: unwrapResponse(fr.response ?? {}),
-          ...matched ? {} : { name: fr.name }
+          content: unwrapResponse(response, reporter, "Gemini", "functionResponse"),
+          ...matched ? {} : { name }
         });
         continue;
       }
@@ -615,6 +838,7 @@ function fromGemini(conversation, options = {}) {
       if (image) {
         contentParts.push(imageToOpenAI(image));
         hasMedia = true;
+        sawUserContent = true;
         continue;
       }
       const media = mediaFromGemini(part);
@@ -623,29 +847,74 @@ function fromGemini(conversation, options = {}) {
         if (openaiPart) {
           contentParts.push(openaiPart);
           hasMedia = true;
+        } else {
+          reporter.warn(
+            "dropped-content",
+            `A Gemini ${media.modality} ${media.source.kind} has no OpenAI Chat Completions equivalent; dropped.`
+          );
         }
+        sawUserContent = true;
         continue;
       }
       if (isRecord(part) && typeof part.text === "string") {
         contentParts.push({ type: "text", text: part.text });
+        sawUserContent = true;
+        continue;
       }
+      reporter.warn("dropped-content", "Dropped an unsupported Gemini user content part.");
     }
-    if (contentParts.length > 0) {
-      if (hasMedia) {
-        out.push({ role: "user", content: contentParts });
-      } else {
-        const text = textOf(contentParts);
-        out.push({ role: "user", content: text });
-      }
-    }
+    flushContent();
   }
   return out;
 }
-function resolveResponseId(response, pending, reporter, generateId) {
-  if (response.id) {
-    const index2 = pending.findIndex((p) => p.id === response.id);
-    if (index2 >= 0) pending.splice(index2, 1);
-    return { id: response.id, matched: index2 >= 0 };
+function geminiParts(content, reporter) {
+  if (Array.isArray(content.parts)) return content.parts;
+  reporter.warn("dropped-content", "Dropped malformed Gemini content parts.");
+  return [];
+}
+function geminiFunctionResponseName(value, matchedName, reporter) {
+  if (matchedName && value === void 0) return matchedName;
+  if (matchedName && !isProviderFunctionName(value)) {
+    reporter.warn(
+      "dropped-metadata",
+      `Gemini functionResponse had a missing or invalid function name; used matching functionCall '${matchedName}'.`
+    );
+    return matchedName;
+  }
+  return providerFunctionName(value, reporter, "Gemini", "functionResponse");
+}
+function resolveResponseId(response, pending, reporter, ids) {
+  const responseId = nonEmptyString2(response.id) ? response.id : void 0;
+  if (response.id !== void 0 && typeof response.id !== "string") {
+    reporter.warn(
+      "dropped-metadata",
+      `Gemini functionResponse for '${response.name}' had a non-string id; ignored it.`
+    );
+  }
+  if (responseId) {
+    const index2 = pending.findIndex((p) => p.providerId === responseId || p.id === responseId);
+    if (index2 >= 0) {
+      const [match] = pending.splice(index2, 1);
+      if (response.name !== match.name) {
+        reporter.warn(
+          "dropped-metadata",
+          `Gemini functionResponse '${responseId}' name '${response.name}' differed from matching functionCall '${match.name}'; used the call id mapping.`
+        );
+      }
+      return { id: match.id, matched: true };
+    }
+    reporter.warn(
+      "unmapped-tool-result",
+      `Gemini functionResponse '${responseId}' for '${response.name}' had no matching call; kept the response id.`
+    );
+    const id2 = ids.claim(responseId, response.name);
+    if (id2 !== responseId) {
+      reporter.warn(
+        "generated-id",
+        `Gemini functionResponse '${responseId}' for '${response.name}' reused an existing id; generated '${id2}'.`
+      );
+    }
+    return { id: id2, matched: false };
   }
   const index = pending.findIndex((p) => p.name === response.name);
   if (index >= 0) {
@@ -653,13 +922,31 @@ function resolveResponseId(response, pending, reporter, generateId) {
     pending.splice(index, 1);
     return { id: id2, matched: true };
   }
-  const id = generateId(response.name);
+  const id = ids.generate(response.name);
   reporter.warn(
     "unmapped-tool-result",
     `Gemini functionResponse for '${response.name}' had no matching call; generated '${id}'.`
   );
   return { id, matched: false };
 }
+function geminiProviderIds(conversation) {
+  const ids = [];
+  const root = isRecord(conversation) ? conversation : {};
+  const contents = Array.isArray(root.contents) ? root.contents : [];
+  for (const content of contents) {
+    if (!isRecord(content)) continue;
+    const parts = Array.isArray(content.parts) ? content.parts : [];
+    for (const part of parts) {
+      if (isRecord(part) && isRecord(part.functionCall) && nonEmptyString2(part.functionCall.id)) {
+        ids.push(part.functionCall.id);
+      }
+      if (isRecord(part) && isRecord(part.functionResponse) && nonEmptyString2(part.functionResponse.id)) {
+        ids.push(part.functionResponse.id);
+      }
+    }
+  }
+  return ids;
+}
 
 // src/convert.ts
 function convert(conversation, route, options = {}) {
@@ -693,6 +980,42 @@ function fromCanonical(canonical, to, options) {
 
 // src/response.ts
 var num = (value) => typeof value === "number" ? value : 0;
+var nonEmptyString3 = (value) => typeof value === "string" && value.length > 0;
+function responseRoot(body, reporter, provider) {
+  if (isRecord(body)) return body;
+  reporter.warn("dropped-content", `Dropped malformed ${provider} response body; expected an object.`);
+  return {};
+}
+function responseArrayField(root, field, reporter, context, noun) {
+  const value = root[field];
+  if (value === void 0) {
+    reporter.warn("dropped-content", `${context} missing ${field} array; no ${noun} were read.`);
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    reporter.warn("dropped-content", `Dropped malformed ${context} ${field}; expected an array.`);
+    return [];
+  }
+  return value;
+}
+function firstResponseRecord(items, reporter, provider, noun) {
+  if (items.length === 0) return {};
+  if (isRecord(items[0])) return items[0];
+  reporter.warn("dropped-content", `Dropped malformed ${provider} response ${noun}; expected an object.`);
+  return {};
+}
+function responseRecordField(root, field, reporter, context, noun) {
+  const value = root[field];
+  if (value === void 0) {
+    reporter.warn("dropped-content", `${context} missing ${field} object; no ${noun} were read.`);
+    return {};
+  }
+  if (!isRecord(value)) {
+    reporter.warn("dropped-content", `Dropped malformed ${context} ${field}; expected an object.`);
+    return {};
+  }
+  return value;
+}
 function buildMessage(text, toolCalls) {
   const message = { role: "assistant", content: text ? text : null };
   if (toolCalls.length > 0) message.tool_calls = toolCalls;
@@ -701,6 +1024,97 @@ function buildMessage(text, toolCalls) {
 function finalReason(mapped, toolCalls) {
   return toolCalls.length > 0 ? "tool_calls" : mapped;
 }
+function normalizeProviderArguments(value, reporter, provider, part, fnName) {
+  if (typeof value !== "string") return stringifyArgumentsObject(value, reporter, provider, part, fnName);
+  const parsed = tryParseJson(value);
+  if (parsed.ok && isRecord(parsed.value)) return value;
+  reporter.warn(
+    "invalid-json-arguments",
+    `${provider} ${part} '${fnName}' had arguments that were not a JSON object string; used an empty object instead.`
+  );
+  return "{}";
+}
+function normalizeOpenAIToolCalls(value, reporter) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    reporter.warn("dropped-content", "Dropped malformed OpenAI Chat Completions tool_calls; expected an array.");
+    return [];
+  }
+  const toolCalls = [];
+  const ids = createToolCallIdGenerator(
+    value.flatMap(
+      (call) => isRecord(call) && (call.type === void 0 || call.type === "function") && nonEmptyString3(call.id) ? [call.id] : []
+    )
+  );
+  for (const call of value) {
+    if (!isRecord(call)) {
+      reporter.warn("dropped-content", "Dropped malformed OpenAI Chat Completions tool_call; expected an object.");
+      continue;
+    }
+    if (call.type !== void 0 && call.type !== "function") {
+      reporter.warn(
+        "dropped-content",
+        `OpenAI Chat Completions tool_call type '${String(call.type)}' is not supported; dropped.`
+      );
+      continue;
+    }
+    const fn = isRecord(call.function) ? call.function : {};
+    const name = providerFunctionName(fn.name, reporter, "OpenAI Chat Completions", "tool_call.function");
+    const providedId = nonEmptyString3(call.id) ? call.id : void 0;
+    const id = providedId ? ids.claim(providedId, name) : ids.generate(name);
+    if (!providedId) {
+      reporter.warn("generated-id", `OpenAI Chat Completions tool_call '${name}' had no id; generated '${id}'.`);
+    } else if (id !== providedId) {
+      reporter.warn(
+        "generated-id",
+        `OpenAI Chat Completions tool_call '${name}' reused id '${providedId}'; generated '${id}'.`
+      );
+    }
+    const args = normalizeProviderArguments(
+      fn.arguments,
+      reporter,
+      "OpenAI Chat Completions",
+      "tool_call.function",
+      name
+    );
+    toolCalls.push({ id, type: "function", function: { name, arguments: args } });
+  }
+  return toolCalls;
+}
+function normalizeOpenAIFunctionCall(value, reporter) {
+  if (!isRecord(value)) return [];
+  const name = providerFunctionName(value.name, reporter, "OpenAI Chat Completions", "function_call");
+  const id = `call_${name.replace(/[^a-zA-Z0-9_-]/g, "_")}_0`;
+  reporter.warn("generated-id", `OpenAI Chat Completions function_call '${name}' had no id; generated '${id}'.`);
+  const args = normalizeProviderArguments(value.arguments, reporter, "OpenAI Chat Completions", "function_call", name);
+  return [{ id, type: "function", function: { name, arguments: args } }];
+}
+function openAIChatContentText(content, reporter) {
+  if (typeof content === "string") return content;
+  if (content === null || content === void 0) return "";
+  if (!Array.isArray(content)) {
+    reporter.warn("dropped-content", "Dropped malformed OpenAI Chat Completions response content.");
+    return "";
+  }
+  const pieces = [];
+  for (const part of content) {
+    if (typeof part === "string") {
+      pieces.push(part);
+    } else if (isRecord(part) && typeof part.text === "string") {
+      pieces.push(part.text);
+    } else if (isRecord(part) && part.type === "refusal" && typeof part.refusal === "string") {
+      pieces.push(part.refusal);
+    } else {
+      reporter.warn("dropped-content", "Dropped unsupported OpenAI Chat Completions response content part.");
+    }
+  }
+  return pieces.join("");
+}
+function openAIChatMessageText(message, reporter) {
+  const content = openAIChatContentText(message.content, reporter);
+  if (content) return content;
+  return typeof message.refusal === "string" ? message.refusal : content;
+}
 var OPENAI_FINISH = {
   stop: "stop",
   length: "length",
@@ -708,16 +1122,27 @@ var OPENAI_FINISH = {
   content_filter: "content_filter",
   function_call: "tool_calls"
 };
-function responseFromOpenAI(body) {
-  const root = isRecord(body) ? body : {};
-  const choice = Array.isArray(root.choices) && isRecord(root.choices[0]) ? root.choices[0] : {};
-  const message = isRecord(choice.message) ? choice.message : {};
-  const text = typeof message.content === "string" ? message.content : textOf(message.content);
-  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+function responseFromOpenAI(body, options = {}) {
+  const reporter = new Reporter(options);
+  const isObjectBody = isRecord(body);
+  const root = isObjectBody ? body : responseRoot(body, reporter, "OpenAI Chat Completions");
+  const choices = isObjectBody ? responseArrayField(root, "choices", reporter, "OpenAI Chat Completions response", "choices") : [];
+  const hasChoiceRecord = choices.length > 0 && isRecord(choices[0]);
+  const choice = firstResponseRecord(choices, reporter, "OpenAI Chat Completions", "choice");
+  const message = hasChoiceRecord ? responseRecordField(
+    choice,
+    "message",
+    reporter,
+    "OpenAI Chat Completions response choice",
+    "message content or tool calls"
+  ) : {};
+  const text = openAIChatMessageText(message, reporter);
+  const toolCalls = normalizeOpenAIToolCalls(message.tool_calls, reporter);
+  const normalizedToolCalls = toolCalls.length > 0 ? toolCalls : normalizeOpenAIFunctionCall(message.function_call, reporter);
   const usage = isRecord(root.usage) ? root.usage : {};
   return {
-    message: buildMessage(text, toolCalls),
-    finishReason: finalReason(OPENAI_FINISH[String(choice.finish_reason)] ?? "unknown", toolCalls),
+    message: buildMessage(text, normalizedToolCalls),
+    finishReason: finalReason(OPENAI_FINISH[String(choice.finish_reason)] ?? "unknown", normalizedToolCalls),
     usage: { inputTokens: num(usage.prompt_tokens), outputTokens: num(usage.completion_tokens) }
   };
 }
@@ -725,35 +1150,85 @@ var OPENAI_RESPONSES_INCOMPLETE = {
   max_output_tokens: "length",
   content_filter: "content_filter"
 };
+function openAIResponsesContentText(content, reporter) {
+  if (content === void 0) return "";
+  if (!Array.isArray(content)) {
+    reporter.warn("dropped-content", "Dropped malformed OpenAI Responses message content.");
+    return "";
+  }
+  const pieces = [];
+  for (const part of content) {
+    if (!isRecord(part)) {
+      reporter.warn("dropped-content", "Dropped malformed OpenAI Responses message content part.");
+    } else if (typeof part.text === "string" && (part.type === "output_text" || part.type === "text")) {
+      pieces.push(part.text);
+    } else if (part.type === "refusal" && typeof part.refusal === "string") {
+      pieces.push(part.refusal);
+    } else {
+      reporter.warn("dropped-content", "Dropped unsupported OpenAI Responses message content part.");
+    }
+  }
+  return pieces.join("");
+}
 function responseApiFinishReason(root) {
   if (root.status === "completed") return "stop";
   if (root.status !== "incomplete") return "unknown";
   const details = isRecord(root.incomplete_details) ? root.incomplete_details : {};
   return OPENAI_RESPONSES_INCOMPLETE[String(details.reason)] ?? "unknown";
 }
-function responseFromOpenAIResponses(body) {
-  const root = isRecord(body) ? body : {};
-  const output = Array.isArray(root.output) ? root.output : [];
+function openAIResponsesOutput(root, reporter) {
+  if (root.output === void 0) {
+    reporter.warn(
+      "dropped-content",
+      "OpenAI Responses response missing top-level output array; no output items were read."
+    );
+    return [];
+  }
+  if (!Array.isArray(root.output)) {
+    reporter.warn("dropped-content", "Dropped malformed OpenAI Responses top-level output; expected an array.");
+    return [];
+  }
+  return root.output;
+}
+function responseFromOpenAIResponses(body, options = {}) {
+  const reporter = new Reporter(options);
+  const isObjectBody = isRecord(body);
+  const root = isObjectBody ? body : responseRoot(body, reporter, "OpenAI Responses");
+  const output = isObjectBody ? openAIResponsesOutput(root, reporter) : [];
   const textPieces = [];
   const toolCalls = [];
-  let counter = 0;
+  const ids = createToolCallIdGenerator(
+    output.flatMap((item) => {
+      if (!isRecord(item) || item.type !== "function_call") return [];
+      if (nonEmptyString3(item.call_id)) return [item.call_id];
+      return nonEmptyString3(item.id) ? [item.id] : [];
+    })
+  );
   for (const item of output) {
-    if (!isRecord(item)) continue;
+    if (!isRecord(item)) {
+      reporter.warn("dropped-content", "Dropped malformed OpenAI Responses output item.");
+      continue;
+    }
     if (item.type === "message") {
-      const content = Array.isArray(item.content) ? item.content : [];
-      for (const part of content) {
-        if (!isRecord(part)) continue;
-        if (typeof part.text === "string" && (part.type === "output_text" || part.type === "text")) {
-          textPieces.push(part.text);
-        } else if (part.type === "refusal" && typeof part.refusal === "string") {
-          textPieces.push(part.refusal);
-        }
+      textPieces.push(openAIResponsesContentText(item.content, reporter));
+    } else if (item.type === "function_call") {
+      const name = providerFunctionName(item.name, reporter, "OpenAI Responses", "function_call");
+      const callId = nonEmptyString3(item.call_id) ? item.call_id : void 0;
+      const itemId = nonEmptyString3(item.id) ? item.id : void 0;
+      const id = callId ?? itemId;
+      const toolCallId = id ? ids.claim(id, name) : ids.generate(name);
+      if (!callId && !itemId) {
+        reporter.warn("generated-id", `OpenAI Responses function_call '${name}' had no id; generated '${toolCallId}'.`);
+      } else if (toolCallId !== id) {
+        reporter.warn(
+          "generated-id",
+          `OpenAI Responses function_call '${name}' reused id '${id}'; generated '${toolCallId}'.`
+        );
       }
-    } else if (item.type === "function_call" && typeof item.name === "string") {
-      const name = item.name;
-      const id = typeof item.call_id === "string" ? item.call_id : typeof item.id === "string" ? item.id : `call_${name.replace(/[^a-zA-Z0-9_-]/g, "_")}_${counter++}`;
-      const args = typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? {});
-      toolCalls.push({ id, type: "function", function: { name, arguments: args } });
+      const args = normalizeProviderArguments(item.arguments, reporter, "OpenAI Responses", "function_call", name);
+      toolCalls.push({ id: toolCallId, type: "function", function: { name, arguments: args } });
+    } else {
+      reporter.warn("dropped-content", `Dropped unsupported OpenAI Responses output item '${String(item.type)}'.`);
     }
   }
   const usage = isRecord(root.usage) ? root.usage : {};
@@ -771,21 +1246,47 @@ var ANTHROPIC_FINISH = {
   refusal: "content_filter",
   pause_turn: "unknown"
 };
-function responseFromAnthropic(body) {
-  const root = isRecord(body) ? body : {};
-  const blocks = Array.isArray(root.content) ? root.content : [];
+function responseFromAnthropic(body, options = {}) {
+  const reporter = new Reporter(options);
+  const isObjectBody = isRecord(body);
+  const root = isObjectBody ? body : responseRoot(body, reporter, "Anthropic");
+  const blocks = isObjectBody ? responseArrayField(root, "content", reporter, "Anthropic response", "content blocks") : [];
   const textPieces = [];
   const toolCalls = [];
+  const ids = createToolCallIdGenerator(
+    blocks.flatMap(
+      (block) => isRecord(block) && block.type === "tool_use" && nonEmptyString3(block.id) ? [block.id] : []
+    )
+  );
   for (const block of blocks) {
-    if (!isRecord(block)) continue;
+    if (!isRecord(block)) {
+      reporter.warn("dropped-content", "Dropped a malformed Anthropic response content block.");
+      continue;
+    }
     if (block.type === "text" && typeof block.text === "string") {
       textPieces.push(block.text);
-    } else if (block.type === "tool_use" && typeof block.name === "string") {
+    } else if (block.type === "tool_use") {
+      const name = providerFunctionName(block.name, reporter, "Anthropic", "tool_use");
+      const providedId = nonEmptyString3(block.id) ? block.id : void 0;
+      const id = providedId ? ids.claim(providedId, name) : ids.generate(name);
+      if (!providedId) {
+        reporter.warn("generated-id", `Anthropic tool_use '${name}' had no id; generated '${id}'.`);
+      } else if (id !== providedId) {
+        reporter.warn("generated-id", `Anthropic tool_use '${name}' reused id '${providedId}'; generated '${id}'.`);
+      }
       toolCalls.push({
-        id: typeof block.id === "string" ? block.id : "",
+        id,
         type: "function",
-        function: { name: block.name, arguments: JSON.stringify(block.input ?? {}) }
+        function: {
+          name,
+          arguments: stringifyArgumentsObject(block.input, reporter, "Anthropic", "tool_use", name)
+        }
       });
+    } else {
+      reporter.warn(
+        "dropped-content",
+        `Anthropic response content block '${String(block.type)}' is not supported; dropped.`
+      );
     }
   }
   const usage = isRecord(root.usage) ? root.usage : {};
@@ -800,30 +1301,63 @@ var GEMINI_FINISH = {
   MAX_TOKENS: "length",
   SAFETY: "content_filter",
   RECITATION: "content_filter",
-  MALFORMED_FUNCTION_CALL: "content_filter"
+  BLOCKLIST: "content_filter",
+  PROHIBITED_CONTENT: "content_filter",
+  SPII: "content_filter",
+  MALFORMED_FUNCTION_CALL: "content_filter",
+  MODEL_ARMOR: "content_filter",
+  IMAGE_SAFETY: "content_filter",
+  IMAGE_PROHIBITED_CONTENT: "content_filter",
+  IMAGE_RECITATION: "content_filter"
 };
 function responseFromGemini(body, options = {}) {
   const reporter = new Reporter(options);
-  const root = isRecord(body) ? body : {};
-  const candidate = Array.isArray(root.candidates) && isRecord(root.candidates[0]) ? root.candidates[0] : {};
+  const isObjectBody = isRecord(body);
+  const root = isObjectBody ? body : responseRoot(body, reporter, "Gemini");
+  const candidates = isObjectBody ? responseArrayField(root, "candidates", reporter, "Gemini response", "candidates") : [];
+  const hasCandidateRecord = candidates.length > 0 && isRecord(candidates[0]);
+  const candidate = firstResponseRecord(candidates, reporter, "Gemini", "candidate");
   const content = isRecord(candidate.content) ? candidate.content : {};
-  const parts = Array.isArray(content.parts) ? content.parts : [];
+  if (hasCandidateRecord && !isRecord(candidate.content)) {
+    reporter.warn("dropped-content", "Dropped malformed Gemini response candidate content; expected an object.");
+  }
+  const parts = hasCandidateRecord && isRecord(candidate.content) ? responseArrayField(content, "parts", reporter, "Gemini response candidate content", "content parts") : [];
   const textPieces = [];
   const toolCalls = [];
-  let counter = 0;
+  const ids = createToolCallIdGenerator(
+    parts.flatMap(
+      (part) => isRecord(part) && isRecord(part.functionCall) && nonEmptyString3(part.functionCall.id) ? [part.functionCall.id] : []
+    )
+  );
   for (const part of parts) {
-    if (!isRecord(part)) continue;
+    if (!isRecord(part)) {
+      reporter.warn("dropped-content", "Dropped a malformed Gemini response content part.");
+      continue;
+    }
     if (isRecord(part.functionCall)) {
       const call = part.functionCall;
-      const name = typeof call.name === "string" ? call.name : "function";
-      let id = call.id;
-      if (!id) {
-        id = `call_${name.replace(/[^a-zA-Z0-9_-]/g, "_")}_${counter++}`;
+      const name = providerFunctionName(call.name, reporter, "Gemini", "functionCall");
+      const providedId = nonEmptyString3(call.id) ? call.id : void 0;
+      const id = providedId ? ids.claim(providedId, name) : ids.generate(name);
+      if (!providedId) {
         reporter.warn("generated-id", `Gemini functionCall '${name}' had no id; generated '${id}'.`);
+      } else if (id !== providedId) {
+        reporter.warn("generated-id", `Gemini functionCall '${name}' reused id '${providedId}'; generated '${id}'.`);
       }
-      toolCalls.push({ id, type: "function", function: { name, arguments: JSON.stringify(call.args ?? {}) } });
+      toolCalls.push({
+        id,
+        type: "function",
+        function: {
+          name,
+          arguments: stringifyArgumentsObject(call.args, reporter, "Gemini", "functionCall", name)
+        }
+      });
+    } else if (part.thought === true) {
+      reporter.warn("dropped-content", "Dropped a Gemini thought (reasoning) response part.");
     } else if (typeof part.text === "string") {
       textPieces.push(part.text);
+    } else {
+      reporter.warn("dropped-content", "Dropped an unsupported Gemini response content part.");
     }
   }
   const usage = isRecord(root.usageMetadata) ? root.usageMetadata : {};
@@ -836,17 +1370,31 @@ function responseFromGemini(body, options = {}) {
 function normalizeResponse(body, route, options = {}) {
   switch (route.from) {
     case "openai":
-      return responseFromOpenAI(body);
+      return responseFromOpenAI(body, options);
     case "openai-responses":
-      return responseFromOpenAIResponses(body);
+      return responseFromOpenAIResponses(body, options);
     case "anthropic":
-      return responseFromAnthropic(body);
+      return responseFromAnthropic(body, options);
     case "gemini":
       return responseFromGemini(body, options);
     default:
       throw new Error(`Unknown source provider: ${String(route.from)}`);
   }
 }
+
+// src/types.ts
+var warningCodes = Object.freeze([
+  "generated-id",
+  "unmapped-tool-result",
+  "merged-role",
+  "dropped-content",
+  "dropped-metadata",
+  "invalid-json-arguments",
+  "system-midstream",
+  "gemini-url-image",
+  "gemini-url-media",
+  "unsupported-modality"
+]);
 export {
   convert,
   fromAnthropic,
@@ -859,6 +1407,7 @@ export {
   responseFromOpenAIResponses,
   toAnthropic,
   toDataUrl,
-  toGemini
+  toGemini,
+  warningCodes
 };
 //# sourceMappingURL=index.js.map