@oh-my-pi/pi-ai 18.2.0 → 18.2.1

package/src/utils/schema/wire.ts

@@ -7,6 +7,7 @@
  */
 
 import type { Type } from "@oh-my-pi/omptype";
+import { structuredCloneJSON } from "@oh-my-pi/pi-utils";
 import type { Tool, TSchema } from "../../types";
 import { upgradeJsonSchemaTo202012 } from "./draft";
 import { stamp } from "./stamps";
@@ -107,7 +108,7 @@ function arkJsonAstToWire(value: unknown): unknown {
 	return {};
 }
 
-/** Symbol-stamped caches keyed by schema object identity. */
+/** `stamp` cache keys; the entries themselves live in a weak side table keyed by schema identity. */
 const kJsonWireSchema = Symbol("pi.schema.json.wire");
 const kArkWireSchema = Symbol("pi.schema.ark.wire");
 const kStrippedSchema = Symbol("pi.schema.descriptions.stripped");
@@ -602,7 +603,9 @@ export function toolWireSchema(tool: Tool): Record<string, unknown> {
 	const params: TSchema = tool.parameters;
 	if (isArkSchema(params)) return arkToWireSchema(params);
 	return stamp(params as Record<string, unknown>, kJsonWireSchema, p => {
-		const raw = isArkJsonAst(p) ? arkJsonAstToWire(p) : p;
+		// Legacy schemas may carry non-cloneable metadata (helper functions); the JSON
+		// fallback drops it the same way the wire serializer always has.
+		const raw = isArkJsonAst(p) ? arkJsonAstToWire(p) : structuredCloneJSON(p);
 		const upgraded = upgradeJsonSchemaTo202012(raw) as Record<string, unknown>;
 		return postProcessJsonSchema(upgraded);
 	});
@@ -663,10 +666,9 @@ function stripSchemaDescriptionsInPlace(node: unknown): void {
 
 /**
  * Return a deep clone of `schema` with every `description` annotation removed.
- * The result is memoized on the input via a non-enumerable symbol (`stamp`) so
- * repeated provider requests reuse the same stripped object; the input is never
- * mutated, so the stamped `toolWireSchema` cache stays intact for
- * system-prompt/UI rendering.
+ * The result is memoized against the input (`stamp`) so repeated provider
+ * requests reuse the same stripped object; the input is never mutated, so the
+ * memoized `toolWireSchema` result stays intact for system-prompt/UI rendering.
  */
 export function stripSchemaDescriptions(schema: Record<string, unknown>): Record<string, unknown> {
 	return stamp(schema, kStrippedSchema, source => {
@@ -682,7 +684,7 @@ export function stripSchemaDescriptions(schema: Record<string, unknown>): Record
  * Used when the full tool catalog is rendered into the system prompt instead, so
  * the descriptions ride the wire once (in the prompt) rather than duplicated on
  * every tool definition. Parameters are resolved to wire JSON Schema and cloned,
- * leaving the original tool objects and the stamped schema cache untouched.
+ * leaving the original tool objects and the memoized schema cache untouched.
  */
 export function stripToolDescriptions(tools: readonly Tool[]): Tool[] {
 	return tools.map(tool => ({

package/src/utils.ts

@@ -45,8 +45,10 @@ export function normalizeResponsesToolCallId(
 	id: string,
 	itemPrefix: ResponsesToolItemIdPrefix = "fc",
 ): { callId: string; itemId: string } {
-	const [callId, itemId] = id.split("|");
-	if (callId && itemId) {
+	const sep = id.search(/[\n|]/);
+	if (sep > 0) {
+		const callId = id.slice(0, sep);
+		const itemId = id.slice(sep + 1);
 		return { callId, itemId: normalizeResponsesItemId(itemId, itemPrefix) };
 	}
 	const hash = Bun.hash(id).toString(36);
@@ -324,6 +326,15 @@ export function stripUnpairedOpenAIResponsesComputerReasoningIdsForReplay(items:
  * Returns `undefined` for hidden-empty turns that only contain reasoning and an
  * empty assistant message, allowing callers to rebuild visible transcript
  * history instead of replaying stale native state.
+ *
+ * When the turn does carry replayable output, whitespace-only assistant
+ * messages are dropped rather than replayed. gpt-5.6 Codex ends a turn whose
+ * text all landed in the `commentary` phase with an empty `final_answer`
+ * message; replaying that item verbatim seeds the next turn with an empty slot
+ * the model then fills - `""` → `"\n\n"` → stray words → non-Latin residue -
+ * and each contaminated item is replayed in turn, so the drift compounds until
+ * the visible answer collapses. Codex CLI replays the empty item too
+ * (openai/codex#32389); this is the layer where omp can refuse to.
  */
 export function sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(
 	items: Array<Record<string, unknown>>,
@@ -331,34 +342,68 @@ export function sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(
 ): ResponseInput | undefined {
 	const sanitized = sanitizeOpenAIResponsesHistoryItemsForReplay(items, options);
 	let hasReplayableAssistantOutput = false;
+	let hasEmptyAssistantMessage = false;
 
 	for (const item of sanitized) {
 		if (item.type === "reasoning") continue;
-		if (item.type !== "message" || item.role !== "assistant") {
-			hasReplayableAssistantOutput = true;
-			break;
+		if (isEmptyAssistantMessage(item)) {
+			hasEmptyAssistantMessage = true;
+			continue;
 		}
-		if (typeof item.content === "string") {
-			if (NON_WHITESPACE_RE.test(item.content)) {
-				hasReplayableAssistantOutput = true;
-				break;
-			}
+		hasReplayableAssistantOutput = true;
+	}
+
+	if (!hasReplayableAssistantOutput) return undefined;
+	if (!hasEmptyAssistantMessage) return sanitized;
+	return dropEmptyAssistantMessagesForReplay(sanitized);
+}
+
+function isEmptyAssistantMessage(item: OpenAIResponsesReplayItem): boolean {
+	if (item.type !== "message" || item.role !== "assistant") return false;
+	if (typeof item.content === "string") return !NON_WHITESPACE_RE.test(item.content);
+	for (const part of item.content) {
+		if (part.type === "output_text" && NON_WHITESPACE_RE.test(part.text)) return false;
+		if (part.type === "refusal" && NON_WHITESPACE_RE.test(part.refusal)) return false;
+	}
+	return true;
+}
+
+/**
+ * Remove whitespace-only assistant messages plus any reasoning item left with
+ * no output to introduce: a reasoning item is only meaningful ahead of the
+ * output it produced, and a dangling one is rejected by the Responses API when
+ * it carries an id.
+ */
+function dropEmptyAssistantMessagesForReplay(items: ResponseInput): ResponseInput {
+	const kept: ResponseInput = [];
+	let pendingReasoning: ResponseInput = [];
+	let removedAssistantMessage = false;
+	const flushReasoning = (): void => {
+		kept.push(...pendingReasoning);
+		pendingReasoning = [];
+	};
+	for (const item of items) {
+		if (isOpenAIResponsesClientInputBoundary(item as unknown as Record<string, unknown>)) {
+			pendingReasoning = [];
+			removedAssistantMessage = false;
+			kept.push(item);
 			continue;
 		}
-		for (const part of item.content) {
-			if (part.type === "output_text" && NON_WHITESPACE_RE.test(part.text)) {
-				hasReplayableAssistantOutput = true;
-				break;
-			}
-			if (part.type === "refusal" && NON_WHITESPACE_RE.test(part.refusal)) {
-				hasReplayableAssistantOutput = true;
-				break;
-			}
+		if (item.type === "reasoning") {
+			if (removedAssistantMessage) pendingReasoning = [];
+			removedAssistantMessage = false;
+			pendingReasoning.push(item);
+			continue;
 		}
-		if (hasReplayableAssistantOutput) break;
+		if (isEmptyAssistantMessage(item)) {
+			removedAssistantMessage = true;
+			continue;
+		}
+		flushReasoning();
+		removedAssistantMessage = false;
+		kept.push(item);
 	}
-
-	return hasReplayableAssistantOutput ? sanitized : undefined;
+	return kept;
 }
 
 /**