@oh-my-pi/pi-ai 13.12.10 → 13.13.2

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [13.13.2] - 2026-03-18
+### Changed
+
+- Modified tool result handling for aborted assistant messages to preserve existing tool results when already recorded, instead of always replacing them with synthetic 'aborted' results
+
+## [13.13.0] - 2026-03-18
+### Changed
+
+- Changed tool argument validation to always normalize optional null values before type coercion, ensuring consistent handling of LLM-generated 'null' strings
+
+### Fixed
+
+- Fixed tool argument validation to properly handle string 'null' values from LLMs on optional fields by stripping them during normalization
+- Improved type safety of `validateToolCall` and `validateToolArguments` functions by returning properly typed `ToolCall["arguments"]` instead of `any`
+
 ## [13.12.9] - 2026-03-17
 ### Changed
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "13.12.10",
+	"version": "13.13.2",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,7 +41,7 @@
 		"@aws-sdk/client-bedrock-runtime": "^3",
 		"@bufbuild/protobuf": "^2.11",
 		"@google/genai": "^1.43",
-		"@oh-my-pi/pi-utils": "13.12.10",
+		"@oh-my-pi/pi-utils": "13.13.2",
 		"@sinclair/typebox": "^0.34",
 		"@smithy/node-http-handler": "^4.4",
 		"ajv": "^8.18",

package/src/providers/openai-codex-responses.ts

@@ -2134,7 +2134,7 @@ function convertMessages(model: Model<"openai-codex-responses">, context: Contex
 					} satisfies ResponseOutputMessage);
 					continue;
 				}
-				if (block.type === "toolCall" && msg.stopReason !== "error") {
+				if (block.type === "toolCall") {
 					const toolCall = block as ToolCall;
 					const normalized = normalizeResponsesToolCallId(toolCall.id);
 					outputItems.push({

package/src/providers/openai-completions-compat.ts

@@ -43,7 +43,7 @@ export function detectOpenAICompat(model: Model<"openai-completions">): Resolved
 
 	const isCerebras = provider === "cerebras" || baseUrl.includes("cerebras.ai");
 	const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
-	const isOpenRouterKimi = provider === "openrouter" && model.id.includes("moonshotai/kimi");
+	const isKimiModel = model.id.includes("moonshotai/kimi");
 	const isAlibaba = provider === "alibaba-coding-plan" || baseUrl.includes("dashscope");
 	const isQwen = model.id.toLowerCase().includes("qwen");
 
@@ -91,8 +91,8 @@ export function detectOpenAICompat(model: Model<"openai-completions">): Resolved
 		requiresMistralToolIds: isMistral,
 		thinkingFormat: isZai ? "zai" : isAlibaba || isQwen ? "qwen" : "openai",
 		reasoningContentField: "reasoning_content",
-		requiresReasoningContentForToolCalls: isOpenRouterKimi,
-		requiresAssistantContentForToolCalls: isOpenRouterKimi,
+		requiresReasoningContentForToolCalls: isKimiModel,
+		requiresAssistantContentForToolCalls: isKimiModel,
 		openRouterRouting: undefined,
 		vercelGatewayRouting: undefined,
 		supportsStrictMode: detectStrictModeSupport(provider, baseUrl),

package/src/providers/openai-responses-shared.ts

@@ -134,7 +134,7 @@ export function convertResponsesAssistantMessage<TApi extends Api>(
 			continue;
 		}
 
-		if (block.type !== "toolCall" || assistantMsg.stopReason === "error") {
+		if (block.type !== "toolCall") {
 			continue;
 		}
 

package/src/providers/transform-messages.ts

@@ -124,101 +124,105 @@ export function transformMessages<TApi extends Api>(
 	});
 
 	// Second pass: insert synthetic empty tool results for orphaned tool calls
-	// This preserves thinking signatures and satisfies API requirements
+	// and preserve aborted/errored tool results when they were already persisted.
 	const result: Message[] = [];
 	let pendingToolCalls: ToolCall[] = [];
-	// Track tool call status: whether resolved (has result) or aborted (skip real results)
+	let pendingAbortedToolCalls = new Map<string, ToolCall>();
+	let pendingAbortedTimestamp: number | undefined;
+	// Track tool call status: whether resolved (has result) or aborted (synthetic result injected, skip later real results)
 	const toolCallStatus = new Map<string, ToolCallStatus>();
 
+	const flushPendingToolCalls = (timestamp: number): void => {
+		if (pendingToolCalls.length === 0) return;
+		for (const tc of pendingToolCalls) {
+			if (!toolCallStatus.has(tc.id)) {
+				result.push({
+					role: "toolResult",
+					toolCallId: tc.id,
+					toolName: tc.name,
+					content: [{ type: "text", text: "No result provided" }],
+					isError: true,
+					timestamp,
+				} as ToolResultMessage);
+				toolCallStatus.set(tc.id, ToolCallStatus.Resolved);
+			}
+		}
+		pendingToolCalls = [];
+	};
+
+	const flushPendingAbortedToolCalls = (): void => {
+		if (pendingAbortedTimestamp === undefined) return;
+		for (const tc of pendingAbortedToolCalls.values()) {
+			if (!toolCallStatus.has(tc.id)) {
+				result.push({
+					role: "toolResult",
+					toolCallId: tc.id,
+					toolName: tc.name,
+					content: [{ type: "text", text: "aborted" }],
+					isError: true,
+					timestamp: pendingAbortedTimestamp,
+				} as ToolResultMessage);
+				toolCallStatus.set(tc.id, ToolCallStatus.Aborted);
+			}
+		}
+		result.push({
+			role: "developer",
+			content: turnAbortedGuidance,
+			timestamp: pendingAbortedTimestamp + 1,
+		} as DeveloperMessage);
+		pendingAbortedToolCalls = new Map();
+		pendingAbortedTimestamp = undefined;
+	};
+
 	for (let i = 0; i < transformed.length; i++) {
 		const msg = transformed[i];
+		const messageTimestamp = "timestamp" in msg && typeof msg.timestamp === "number" ? msg.timestamp : Date.now();
 
 		if (msg.role === "assistant") {
-			// If we have pending orphaned tool calls from a previous assistant, insert synthetic results now
-			if (pendingToolCalls.length > 0) {
-				for (const tc of pendingToolCalls) {
-					if (!toolCallStatus.has(tc.id)) {
-						result.push({
-							role: "toolResult",
-							toolCallId: tc.id,
-							toolName: tc.name,
-							content: [{ type: "text", text: "No result provided" }],
-							isError: true,
-							timestamp: Date.now(),
-						} as ToolResultMessage);
-						toolCallStatus.set(tc.id, ToolCallStatus.Resolved);
-					}
-				}
-				pendingToolCalls = [];
-			}
+			flushPendingToolCalls(messageTimestamp);
+			flushPendingAbortedToolCalls();
 
-			// For errored/aborted assistant messages: keep tool calls intact,
-			// inject synthetic "aborted" results, and add guidance marker.
-			// This preserves structure so the model knows what was attempted.
 			const assistantMsg = msg as AssistantMessage;
 			const toolCalls = assistantMsg.content.filter(b => b.type === "toolCall") as ToolCall[];
 
 			if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
-				// Push the assistant message with tool calls intact
+				// Keep the assistant message with tool calls intact. If real tool results follow, preserve them;
+				// otherwise synthesize aborted results before the next turn boundary.
 				result.push(msg);
-
-				// Inject synthetic "aborted" results for each tool call
-				for (const tc of toolCalls) {
-					toolCallStatus.set(tc.id, ToolCallStatus.Aborted);
-					result.push({
-						role: "toolResult",
-						toolCallId: tc.id,
-						toolName: tc.name,
-						content: [{ type: "text", text: "aborted" }],
-						isError: true,
-						timestamp: assistantMsg.timestamp,
-					} as ToolResultMessage);
-				}
-
-				// Inject turn-aborted guidance marker as developer message
-				result.push({
-					role: "developer",
-					content: turnAbortedGuidance,
-					timestamp: assistantMsg.timestamp + 1,
-				} as DeveloperMessage);
-
+				pendingAbortedToolCalls = new Map(toolCalls.map(toolCall => [toolCall.id, toolCall] as const));
+				pendingAbortedTimestamp = assistantMsg.timestamp;
 				continue;
 			}
 
-			// Track tool calls from this normal assistant message
 			if (toolCalls.length > 0) {
 				pendingToolCalls = toolCalls;
 			}
 
 			result.push(msg);
 		} else if (msg.role === "toolResult") {
-			// Skip tool results for aborted tool calls (we already injected synthetic ones)
+			if (pendingAbortedToolCalls.has(msg.toolCallId)) {
+				pendingAbortedToolCalls.delete(msg.toolCallId);
+				toolCallStatus.set(msg.toolCallId, ToolCallStatus.Resolved);
+				result.push(msg);
+				continue;
+			}
+
 			if (toolCallStatus.get(msg.toolCallId) === ToolCallStatus.Aborted) continue;
 			toolCallStatus.set(msg.toolCallId, ToolCallStatus.Resolved);
 			result.push(msg);
 		} else if (msg.role === "user" || msg.role === "developer") {
-			// User/developer message interrupts tool flow - insert synthetic results for orphaned calls
-			if (pendingToolCalls.length > 0) {
-				for (const tc of pendingToolCalls) {
-					if (!toolCallStatus.has(tc.id)) {
-						result.push({
-							role: "toolResult",
-							toolCallId: tc.id,
-							toolName: tc.name,
-							content: [{ type: "text", text: "No result provided" }],
-							isError: true,
-							timestamp: Date.now(),
-						} as ToolResultMessage);
-						toolCallStatus.set(tc.id, ToolCallStatus.Resolved);
-					}
-				}
-				pendingToolCalls = [];
-			}
+			flushPendingToolCalls(messageTimestamp);
+			flushPendingAbortedToolCalls();
 			result.push(msg);
 		} else {
+			flushPendingToolCalls(messageTimestamp);
+			flushPendingAbortedToolCalls();
 			result.push(msg);
 		}
 	}
 
+	flushPendingToolCalls(Date.now());
+	flushPendingAbortedToolCalls();
+
 	return result;
 }

package/src/utils/validation.ts

@@ -172,7 +172,14 @@ function tryParseJsonForTypes(value: string, expectedTypes: string[]): { value:
 
 	try {
 		const parsed = JSON.parse(trimmed) as unknown;
-		// Only accept if the parsed type matches what the schema expects
+		// If the string was "null", we parsed it to actual null.
+		// Accept this even if null isn't in expectedTypes - the LLM meant "no value".
+		// normalizeOptionalNullsForSchema will strip it from optional fields, and
+		// AJV will correctly error on required fields.
+		if (parsed === null && trimmed === "null") {
+			return { value: null, changed: true };
+		}
+		// For non-null values, only accept if the parsed type matches what the schema expects
 		if (matchesExpectedType(parsed, expectedTypes)) {
 			return { value: parsed, changed: true };
 		}
@@ -378,7 +385,9 @@ function normalizeOptionalNullsForSchema(schema: unknown, value: unknown): { val
 		if (!(key in nextValue)) continue;
 		const currentValue = nextValue[key];
 
-		if (currentValue === null && !required.has(key)) {
+		// Strip null and the string "null" from optional fields.
+		// The LLM sometimes outputs string "null" to mean "no value".
+		if ((currentValue === null || currentValue === "null") && !required.has(key)) {
 			if (!changed) {
 				nextValue = { ...nextValue };
 				changed = true;
@@ -386,7 +395,6 @@ function normalizeOptionalNullsForSchema(schema: unknown, value: unknown): { val
 			delete nextValue[key];
 			continue;
 		}
-
 		const normalized = normalizeOptionalNullsForSchema(propertySchema, currentValue);
 		if (!normalized.changed) continue;
 
@@ -482,7 +490,7 @@ const MAX_TYPE_COERCION_PASSES = 5;
  * @returns The validated arguments
  * @throws Error if tool is not found or validation fails
  */
-export function validateToolCall(tools: Tool[], toolCall: ToolCall): any {
+export function validateToolCall(tools: Tool[], toolCall: ToolCall): ToolCall["arguments"] {
 	const tool = tools.find(t => t.name === toolCall.name);
 	if (!tool) {
 		throw new Error(`Tool "${toolCall.name}" not found`);
@@ -497,26 +505,26 @@ export function validateToolCall(tools: Tool[], toolCall: ToolCall): any {
  * @returns The validated arguments
  * @throws Error with formatted message if validation fails
  */
-export function validateToolArguments(tool: Tool, toolCall: ToolCall): any {
+export function validateToolArguments(tool: Tool, toolCall: ToolCall): ToolCall["arguments"] {
 	const originalArgs = toolCall.arguments;
 
 	const validate = compileSchema(tool.parameters);
 
-	// Validate the arguments
-	if (validate(originalArgs)) {
-		return originalArgs;
-	}
-
+	// Always normalize first - strip null and string "null" from optional fields.
+	// This handles LLM outputting string "null" to mean "no value" even when
+	// validation would pass (e.g., optional string field where "null" is a valid string).
 	let normalizedArgs: unknown = originalArgs;
 	let changed = false;
 
-	const optionalNullNormalization = normalizeOptionalNullsForSchema(tool.parameters, normalizedArgs);
-	if (optionalNullNormalization.changed) {
-		normalizedArgs = optionalNullNormalization.value;
+	const initialNormalization = normalizeOptionalNullsForSchema(tool.parameters, normalizedArgs);
+	if (initialNormalization.changed) {
+		normalizedArgs = initialNormalization.value;
 		changed = true;
-		if (validate(normalizedArgs)) {
-			return normalizedArgs;
-		}
+	}
+
+	// Validate after normalization
+	if (validate(normalizedArgs)) {
+		return normalizedArgs as ToolCall["arguments"];
 	}
 
 	for (let pass = 0; pass < MAX_TYPE_COERCION_PASSES; pass += 1) {
@@ -532,7 +540,7 @@ export function validateToolArguments(tool: Tool, toolCall: ToolCall): any {
 		}
 
 		if (validate(normalizedArgs)) {
-			return normalizedArgs;
+			return normalizedArgs as ToolCall["arguments"];
 		}
 	}