@oh-my-pi/pi-ai 17.1.7 → 17.1.8

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [17.1.8] - 2026-07-28
+
+### Fixed
+
+- Fixed an HTTP 400 error when resuming or replaying OpenAI history after an interrupted native Computer Use turn.
+- Fixed connection 404 errors when using Google Vertex AI in multi-region locations (eu and us) by correctly resolving regional endpoint (REP) hosts.
+- Fixed a resource leak in SqliteAuthCredentialStore.close() where unclosed prepared statements kept the SQLite connection alive, preventing database file cleanup (especially on Windows where files remained locked).
+
 ## [17.1.7] - 2026-07-27
 
 ### Changed

package/dist/types/utils.d.ts

@@ -15,8 +15,16 @@ export declare function normalizeResponsesToolCallId(id: string, itemPrefix?: Re
 export declare function truncateResponseItemId(id: string, prefix: string): string;
 interface OpenAIResponsesReplaySanitizeOptions {
     supportsImageDetailOriginal?: boolean;
+    supportsComputerUse?: boolean;
 }
 export declare function sanitizeOpenAIResponsesHistoryItemsForReplay(items: Array<Record<string, unknown>>, options?: OpenAIResponsesReplaySanitizeOptions): ResponseInput;
+/** Strip reasoning IDs whose only linked native output is a computer call that will be demoted. */
+export declare function stripOpenAIResponsesComputerLinkedReasoningIdsForReplay(items: ResponseInput): ResponseInput;
+/**
+ * Finalize provisional native-computer reasoning IDs after the complete
+ * Responses input has been rebuilt, model-adapted, and orphan-repaired.
+ */
+export declare function stripUnpairedOpenAIResponsesComputerReasoningIdsForReplay(items: ResponseInput): ResponseInput;
 /**
  * Sanitize assistant-native Responses history for replay.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "17.1.7",
+	"version": "17.1.8",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.1",
-		"@oh-my-pi/pi-catalog": "17.1.7",
-		"@oh-my-pi/pi-utils": "17.1.7",
-		"@oh-my-pi/pi-wire": "17.1.7",
+		"@oh-my-pi/pi-catalog": "17.1.8",
+		"@oh-my-pi/pi-utils": "17.1.8",
+		"@oh-my-pi/pi-wire": "17.1.8",
 		"arktype": "2.2.3",
 		"zod": "^4"
 	},

package/src/auth-storage.ts

@@ -7923,6 +7923,14 @@ export class SqliteAuthCredentialStore implements AuthCredentialStore {
 		this.#updateUsageHistoryStmt.finalize();
 		this.#insertUsageCostStmt.finalize();
 		this.#listUsageCostsStmt.finalize();
+		this.#updateIfMatchesStmt.finalize();
+		this.#updateIfMatchesWithLeaseStmt.finalize();
+		this.#deleteIfMatchesWithLeaseStmt.finalize();
+		this.#deleteCachePrefixStmt.finalize();
+		this.#acquireCredentialRefreshLeaseStmt.finalize();
+		this.#getCredentialRefreshLeaseStmt.finalize();
+		this.#renewCredentialRefreshLeaseStmt.finalize();
+		this.#releaseCredentialRefreshLeaseStmt.finalize();
 		this.#db.close();
 	}
 }

package/src/providers/google-vertex.ts

@@ -1,3 +1,4 @@
+import { resolveVertexEndpointHost } from "@oh-my-pi/pi-catalog/hosts";
 import { $env } from "@oh-my-pi/pi-utils";
 import * as AIError from "../error";
 import type { Context, Model, StreamFunction } from "../types";
@@ -69,7 +70,7 @@ export const streamGoogleVertex: StreamFunction<"google-vertex"> = (
 				// global-only request.
 				const explicitLocation = options?.location;
 				const location = explicitLocation ?? resolveAmbientLocation() ?? "global";
-				const host = resolveEndpointHost(location);
+				const host = resolveVertexEndpointHost(location);
 				const path = `${API_VERSION}/publishers/google/models/${model.id}:streamGenerateContent?alt=sse`;
 				const useGlobalFallback = !explicitLocation && host !== "aiplatform.googleapis.com";
 				return {
@@ -87,7 +88,7 @@ export const streamGoogleVertex: StreamFunction<"google-vertex"> = (
 			const project = resolveProject(options);
 			const location = resolveLocation(options);
 			const accessToken = await getVertexAccessToken({ signal: options?.signal, fetch: options?.fetch });
-			const host = resolveEndpointHost(location);
+			const host = resolveVertexEndpointHost(location);
 			const url = `https://${host}/${API_VERSION}/projects/${project}/locations/${location}/publishers/google/models/${model.id}:streamGenerateContent?alt=sse`;
 			return {
 				params,
@@ -117,9 +118,6 @@ function resolveProject(options?: GoogleVertexOptions): string {
 	return project;
 }
 
-function resolveEndpointHost(location: string): string {
-	return location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`;
-}
 function resolveAmbientLocation(): string | undefined {
 	return $env.GOOGLE_VERTEX_LOCATION || $env.GOOGLE_CLOUD_LOCATION || $env.VERTEX_LOCATION || undefined;
 }

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

@@ -51,6 +51,7 @@ import {
 	normalizeSystemPrompts,
 	sanitizeOpenAIResponsesAssistantFallbackItemsForReplay,
 	sanitizeOpenAIResponsesAssistantHistoryItemsForReplay,
+	stripOpenAIResponsesComputerLinkedReasoningIdsForReplay,
 } from "../utils";
 import { clearStreamingPartialJson, kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols";
 import { AssistantMessageEventStream } from "../utils/event-stream";
@@ -1172,8 +1173,9 @@ export function normalizeCodexToolChoice(
 	return undefined;
 }
 function unrollCodexComputerItems(items: ResponseInput, supportsImageDetailOriginal: boolean): ResponseInput {
+	const replayItems = stripOpenAIResponsesComputerLinkedReasoningIdsForReplay(items);
 	const unrolled: ResponseInput = [];
-	for (const item of items) {
+	for (const item of replayItems) {
 		if (item.type === "computer_call") {
 			const actions = item.actions ?? (item.action ? [item.action] : []);
 			unrolled.push({

package/src/providers/openai-shared.ts

@@ -69,6 +69,7 @@ import {
 	sanitizeOpenAIResponsesAssistantFallbackItemsForReplay,
 	sanitizeOpenAIResponsesAssistantHistoryItemsForReplay,
 	sanitizeOpenAIResponsesHistoryItemsForReplay,
+	stripUnpairedOpenAIResponsesComputerReasoningIdsForReplay,
 } from "../utils";
 import {
 	clearStreamingPartialJson,
@@ -1646,6 +1647,7 @@ export function buildResponsesInput<TApi extends Api>(options: BuildResponsesInp
 			if (historyItems && shouldReplayPayloadItems) {
 				const sanitizedItems = sanitizeOpenAIResponsesHistoryItemsForReplay(filterReasoning(historyItems), {
 					supportsImageDetailOriginal,
+					supportsComputerUse: options.model.supportsComputerUse === true,
 				});
 				messages.push(
 					...adaptResponsesReplayItemsForModel(
@@ -1694,7 +1696,10 @@ export function buildResponsesInput<TApi extends Api>(options: BuildResponsesInp
 			if (historyItems) {
 				const rawSanitizedHistoryItems = sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(
 					filterReasoning(historyItems),
-					{ supportsImageDetailOriginal },
+					{
+						supportsImageDetailOriginal,
+						supportsComputerUse: options.model.supportsComputerUse === true,
+					},
 				);
 				const sanitizedHistoryItems = rawSanitizedHistoryItems
 					? adaptResponsesReplayItemsForModel(
@@ -1755,7 +1760,8 @@ export function buildResponsesInput<TApi extends Api>(options: BuildResponsesInp
 	}
 
 	const withRepairedOutputs = options.repairOrphanOutputs ? repairOrphanResponsesToolOutputs(messages) : messages;
-	return repairOrphanResponsesToolCalls(withRepairedOutputs);
+	const withRepairedCalls = repairOrphanResponsesToolCalls(withRepairedOutputs);
+	return stripUnpairedOpenAIResponsesComputerReasoningIdsForReplay(withRepairedCalls);
 }
 
 type ResponsesReplayAssistantMessage = Omit<ResponseOutputMessage, "id"> & { id?: string };

package/src/stream.ts

@@ -5,7 +5,7 @@ import * as path from "node:path";
 import { scheduler } from "node:timers/promises";
 import { isOfficialAnthropicApiUrl } from "@oh-my-pi/pi-catalog/compat/anthropic";
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
-import { isVertexExpressOpenAIUrl, isVertexRawPredictUrl } from "@oh-my-pi/pi-catalog/hosts";
+import { isVertexExpressOpenAIUrl, isVertexRawPredictUrl, resolveVertexEndpointHost } from "@oh-my-pi/pi-catalog/hosts";
 import {
 	mapEffortToAnthropicAdaptiveEffort,
 	mapEffortToGoogleThinkingLevel,
@@ -662,7 +662,7 @@ function resolveVertexRequest(input: string | URL | Request): string | URL | Req
 			url.includes("{location}") ||
 			url.includes("%7Bproject%7D") ||
 			url.includes("%7Blocation%7D");
-		const host = location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`;
+		const host = resolveVertexEndpointHost(location);
 		const rewritten = hasPlaceholder
 			? url
 					.replace("https://{location}-aiplatform.googleapis.com", `https://${host}`)

package/src/utils.ts

@@ -70,6 +70,7 @@ export function truncateResponseItemId(id: string, prefix: string): string {
 
 interface OpenAIResponsesReplaySanitizeOptions {
 	supportsImageDetailOriginal?: boolean;
+	supportsComputerUse?: boolean;
 }
 
 /**
@@ -100,22 +101,185 @@ function clampReplayItemImageDetail(
 	return changed ? { ...item, content } : item;
 }
 
+function isOpenAIResponsesClientInputBoundary(item: Record<string, unknown>): boolean {
+	if (item.type === "message") return item.role !== "assistant";
+	if (item.type === undefined && typeof item.role === "string") return item.role !== "assistant";
+
+	switch (item.type) {
+		case "input_text":
+		case "input_image":
+		case "input_file":
+		case "input_audio":
+		case "function_call_output":
+		case "custom_tool_call_output":
+		case "computer_call_output":
+		case "local_shell_call_output":
+		case "shell_call_output":
+		case "apply_patch_call_output":
+		case "mcp_approval_response":
+		case "compaction":
+		case "compaction_summary":
+		case "compaction_trigger":
+		case "item_reference":
+			return true;
+		case "additional_tools":
+			return item.role !== "assistant";
+		case "tool_search_output":
+			return item.execution !== "server";
+		default:
+			return false;
+	}
+}
+
+function collectOpenAIResponsesComputerLinkedReasoningItems(
+	items: Array<Record<string, unknown>>,
+	requireLaterOutput: boolean,
+): Set<Record<string, unknown>> {
+	let computerCallsWithLaterOutputs: Set<Record<string, unknown>> | undefined;
+	if (requireLaterOutput) {
+		computerCallsWithLaterOutputs = new Set();
+		const laterComputerOutputCallIds = new Set<string>();
+		for (let index = items.length - 1; index >= 0; index--) {
+			const item = items[index]!;
+			if (item.type === "computer_call_output" && typeof item.call_id === "string") {
+				laterComputerOutputCallIds.add(item.call_id);
+			} else if (
+				item.type === "computer_call" &&
+				typeof item.id === "string" &&
+				typeof item.call_id === "string" &&
+				laterComputerOutputCallIds.has(item.call_id)
+			) {
+				computerCallsWithLaterOutputs.add(item);
+			}
+		}
+	}
+
+	const computerLinkedReasoningItems = new Set<Record<string, unknown>>();
+	const responseReasoningItems: Array<Record<string, unknown>> = [];
+	for (const item of items) {
+		if (isOpenAIResponsesClientInputBoundary(item)) {
+			responseReasoningItems.length = 0;
+		} else if (item.type === "reasoning") {
+			responseReasoningItems.push(item);
+		} else if (
+			item.type === "computer_call" &&
+			typeof item.id === "string" &&
+			(!computerCallsWithLaterOutputs || computerCallsWithLaterOutputs.has(item))
+		) {
+			for (const reasoningItem of responseReasoningItems) computerLinkedReasoningItems.add(reasoningItem);
+		}
+	}
+	return computerLinkedReasoningItems;
+}
+
+const provisionalOpenAIResponsesComputerReasoningItems = new WeakSet<object>();
+
 export function sanitizeOpenAIResponsesHistoryItemsForReplay(
 	items: Array<Record<string, unknown>>,
 	options: OpenAIResponsesReplaySanitizeOptions = {},
 ): ResponseInput {
 	const normalizedCallIds = new Map<string, string>();
 	const supportsImageDetailOriginal = options.supportsImageDetailOriginal !== false;
+	const computerLinkedReasoningItems =
+		options.supportsComputerUse === false
+			? undefined
+			: collectOpenAIResponsesComputerLinkedReasoningItems(items, false);
 	return items.flatMap(item => {
+		const preserveForComputer = computerLinkedReasoningItems?.has(item) === true;
 		const sanitized = sanitizeOpenAIResponsesHistoryItemForReplay(
 			item,
 			normalizedCallIds,
 			supportsImageDetailOriginal,
+			preserveForComputer,
 		);
+		if (preserveForComputer && sanitized?.type === "reasoning") {
+			provisionalOpenAIResponsesComputerReasoningItems.add(sanitized);
+		}
 		return sanitized ? [sanitized] : [];
 	});
 }
 
+function collectOpenAIResponsesReasoningItemsWithSurvivingOutputIds(
+	items: Array<Record<string, unknown>>,
+): Set<Record<string, unknown>> {
+	const retainedReasoningItems = new Set<Record<string, unknown>>();
+	let responseReasoningItems: Array<Record<string, unknown>> = [];
+	let hasSurvivingOutputId = false;
+	const finishResponse = (): void => {
+		if (hasSurvivingOutputId) {
+			for (const reasoningItem of responseReasoningItems) retainedReasoningItems.add(reasoningItem);
+		}
+		responseReasoningItems = [];
+		hasSurvivingOutputId = false;
+	};
+
+	for (const item of items) {
+		if (isOpenAIResponsesClientInputBoundary(item)) {
+			finishResponse();
+		} else if (item.type === "reasoning") {
+			responseReasoningItems.push(item);
+		} else if (item.type !== "computer_call" && typeof item.id === "string") {
+			hasSurvivingOutputId = true;
+		}
+	}
+	finishResponse();
+	return retainedReasoningItems;
+}
+
+/** Strip reasoning IDs whose only linked native output is a computer call that will be demoted. */
+export function stripOpenAIResponsesComputerLinkedReasoningIdsForReplay(items: ResponseInput): ResponseInput {
+	const records = items as unknown as Array<Record<string, unknown>>;
+	const linkedReasoningItems = collectOpenAIResponsesComputerLinkedReasoningItems(records, false);
+	const retainedReasoningItems = collectOpenAIResponsesReasoningItemsWithSurvivingOutputIds(records);
+	let sanitized: ResponseInput | undefined;
+
+	for (let index = 0; index < items.length; index++) {
+		const item = items[index]!;
+		const record = records[index]!;
+		if (
+			item.type !== "reasoning" ||
+			typeof record.id !== "string" ||
+			!linkedReasoningItems.has(record) ||
+			retainedReasoningItems.has(record)
+		) {
+			sanitized?.push(item);
+			continue;
+		}
+		if (!sanitized) sanitized = items.slice(0, index);
+		const { id: _id, ...withoutId } = record;
+		sanitized.push(withoutId as unknown as ResponseInput[number]);
+	}
+	return sanitized ?? items;
+}
+
+/**
+ * Finalize provisional native-computer reasoning IDs after the complete
+ * Responses input has been rebuilt, model-adapted, and orphan-repaired.
+ */
+export function stripUnpairedOpenAIResponsesComputerReasoningIdsForReplay(items: ResponseInput): ResponseInput {
+	const records = items as unknown as Array<Record<string, unknown>>;
+	const linkedReasoningItems = collectOpenAIResponsesComputerLinkedReasoningItems(records, true);
+	let sanitized: ResponseInput | undefined;
+
+	for (let index = 0; index < items.length; index++) {
+		const item = items[index]!;
+		const record = records[index]!;
+		if (
+			item.type !== "reasoning" ||
+			!provisionalOpenAIResponsesComputerReasoningItems.has(item) ||
+			typeof record.id !== "string" ||
+			linkedReasoningItems.has(record)
+		) {
+			sanitized?.push(item);
+			continue;
+		}
+		if (!sanitized) sanitized = items.slice(0, index);
+		const { id: _id, ...withoutId } = record;
+		sanitized.push(withoutId as unknown as ResponseInput[number]);
+	}
+	return sanitized ?? items;
+}
+
 /**
  * Sanitize assistant-native Responses history for replay.
  *
@@ -198,11 +362,13 @@ function sanitizeOpenAIResponsesHistoryItemForReplay(
 	item: Record<string, unknown>,
 	normalizedCallIds: Map<string, string>,
 	supportsImageDetailOriginal: boolean,
+	preserveReasoningItemIds: boolean,
 ): OpenAIResponsesReplayItem | undefined {
 	if (item.type === "item_reference") return undefined;
 	if (item.type === "image_generation_call") return sanitizeOpenAIResponsesImageGenerationCallForReplay(item);
-	if (item.type === "reasoning") return sanitizeOpenAIResponsesReasoningItemForReplay(item);
-
+	if (item.type === "reasoning") {
+		return sanitizeOpenAIResponsesReasoningItemForReplay(item, preserveReasoningItemIds);
+	}
 	// Strip status only from item types whose replay input rejects output
 	// lifecycle metadata. Hosted built-in tool items require status for replay.
 	const { id: _id, ...sanitizedItem } = item;
@@ -220,8 +386,12 @@ function sanitizeOpenAIResponsesHistoryItemForReplay(
 	) as unknown as OpenAIResponsesReplayItem;
 }
 
-function sanitizeOpenAIResponsesReasoningItemForReplay(item: Record<string, unknown>): OpenAIResponsesReplayItem {
+function sanitizeOpenAIResponsesReasoningItemForReplay(
+	item: Record<string, unknown>,
+	preserveItemId: boolean,
+): OpenAIResponsesReplayItem {
 	const sanitizedItem: Record<string, unknown> = { type: "reasoning" };
+	if (preserveItemId && typeof item.id === "string") sanitizedItem.id = item.id;
 	if (Array.isArray(item.summary)) sanitizedItem.summary = item.summary;
 	if (Array.isArray(item.content)) sanitizedItem.content = item.content;
 	if (typeof item.encrypted_content === "string" || item.encrypted_content === null) {