@linxiraos/pi-ai 1.2.1 → 1.3.0

package/src/utils.ts

@@ -1,7 +1,9 @@
 import { $env } from "@linxiraos/pi-utils";
 import type { ResponseInput, ResponseInputItem } from "./providers/openai-responses-wire";
 import { isMalformedToolCallName, redactSensitiveCredentials } from "./providers/transform-messages";
+export { normalizeToolCallId } from "./providers/transform-messages";
 import type { CacheRetention, OpenAIResponsesHistoryPayload, ProviderPayload } from "./types";
+import { invalidToolCallArguments } from "./utils/tool-call-arguments";
 
 type OpenAIResponsesReplayItem = ResponseInput[number];
 const NON_WHITESPACE_RE = /\S/;
@@ -33,11 +35,6 @@ export function normalizeSystemPrompts(systemPrompt: readonly string[] | string
 		.filter(prompt => prompt.trim().length > 0);
 }
 
-export function normalizeToolCallId(id: string): string {
-	const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "_");
-	return sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
-}
-
 type ResponsesToolItemIdPrefix = "fc" | "ctc";
 
 /** Preserve opaque call IDs for Responses replay while normalizing or generating the separate item ID. */
@@ -561,24 +558,44 @@ export function dropMalformedOpenAIResponsesToolCalls<
 }
 
 /**
- * Replay history is immutable and re-sanitized on every request, so remember
- * which `arguments` string each item was already validated with instead of
+ * Replay history is immutable and re-sanitized on every request, so each item
+ * remembers the replay `arguments` derived from its stored value instead of
  * re-parsing every historical call (large write/edit payloads) per request.
+ * Frozen/sealed caller-owned items are never mutated; they re-parse instead.
+ */
+const kReplayArguments = Symbol("openaiResponses.replayArguments");
+
+interface FunctionCallReplayItem extends Record<string, unknown> {
+	[kReplayArguments]?: { raw: unknown; replay: string };
+}
+
+/**
+ * `arguments` to replay for a native `function_call`: the stored string when it
+ * parses, `{}` when absent/blank, else the bounded `{__parseError, __rawJson}`
+ * diagnostic the transcript (and the cold replay path) already carries.
+ *
+ * Unparsable text (stream cut off mid-JSON) 400s the whole request, but dropping
+ * the call orphans its recorded tool result into an assistant note that can end
+ * the request and 400 it again (#15568).
  */
-const validatedReplayArguments = new WeakMap<object, string>();
-
-function hasValidReplayArguments(item: Record<string, unknown>): boolean {
-	const args = item.arguments;
-	if (typeof args !== "string") return false;
-	if (validatedReplayArguments.get(item) === args) return true;
-	if (args.trim().length === 0) return false;
-	try {
-		JSON.parse(args);
-	} catch {
-		return false;
+function replayFunctionCallArguments(item: FunctionCallReplayItem): string {
+	const raw = item.arguments;
+	const cached = item[kReplayArguments];
+	if (cached && cached.raw === raw) return cached.replay;
+	let replay = "{}";
+	if (typeof raw === "string" && raw.trim().length > 0) {
+		try {
+			JSON.parse(raw);
+			replay = raw;
+		} catch (error) {
+			replay = JSON.stringify(invalidToolCallArguments(raw, error));
+		}
 	}
-	validatedReplayArguments.set(item, args);
-	return true;
+	// Non-enumerable: the sanitizer's object rest copy must not carry the cache onto wire items.
+	if (Object.isExtensible(item)) {
+		Object.defineProperty(item, kReplayArguments, { value: { raw, replay }, writable: true });
+	}
+	return replay;
 }
 
 function sanitizeOpenAIResponsesHistoryItemForReplay(
@@ -592,9 +609,6 @@ function sanitizeOpenAIResponsesHistoryItemForReplay(
 	if (isMalformedOpenAIResponsesToolCall(item)) {
 		return undefined;
 	}
-	if (item.type === "function_call") {
-		if (!hasValidReplayArguments(item)) return undefined;
-	}
 	if (item.type === "item_reference") return undefined;
 	if (item.type === "image_generation_call") return sanitizeOpenAIResponsesImageGenerationCallForReplay(item);
 	if (item.type === "reasoning") {
@@ -602,6 +616,7 @@ function sanitizeOpenAIResponsesHistoryItemForReplay(
 	}
 	const { id: _id, ...sanitizedItem } = item;
 	if (item.type === "computer_call" && typeof item.id === "string") sanitizedItem.id = item.id;
+	if (item.type === "function_call") sanitizedItem.arguments = replayFunctionCallArguments(item);
 
 	return clampReplayItemImageDetail(
 		sanitizedItem,