🐛 fix(ai): harden Pi compatibility loader

package.json

@@ -84,14 +84,14 @@
     "typebox": "catalog:"
   },
   "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.82.1",
     "@j178/prek": "0.4.6",
     "@types/node": "^26.1.1",
     "@zendev-lab/spark-daemon-client": "workspace:*",
     "@zendev-lab/spark-system": "workspace:*",
     "dependency-cruiser": "^18.1.0",
     "es-toolkit": "catalog:",
     "esbuild": "^0.28.0",
-    "jiti": "2.7.0",
     "jscpd": "^5.0.12",
     "knip": "^6.27.0",
     "p-retry": "catalog:",

packages/spark-ai/src/baidu-oneapi-compat-extension.test.ts

@@ -10,7 +10,11 @@ import { expect, test } from "vitest";
 
 import registerBaiduOneApiCompatibilityExtension from "./baidu-oneapi-compat-extension.ts";
 import registerBaiduOneApiProvider from "./baidu-oneapi-provider.ts";
-import { type BaiduOneApiStream, createBaiduOneApiProviderAdapter } from "./baidu-oneapi.ts";
+import {
+  type BaiduOneApiStream,
+  createBaiduOneApiProviderAdapter,
+  silenceOpenAiSdkTransportLogs,
+} from "./baidu-oneapi.ts";
 import { SparkProviderRegistry } from "./provider-registry.ts";
 
 const BAIDU_MODEL_IDS = [
@@ -95,6 +99,62 @@ test("Pi compatibility and Spark-native adapters expose the same Baidu model cat
   expect(piProvider?.api).toBe("baidu-oneapi");
 });
 
+test("OpenAI SDK log suppression spans lazy setup and concurrent streams", async () => {
+  const previousOpenAiLog = process.env.OPENAI_LOG;
+  process.env.OPENAI_LOG = "debug";
+  const first = Promise.withResolvers<AssistantMessage>();
+  const second = Promise.withResolvers<AssistantMessage>();
+  const third = Promise.withResolvers<AssistantMessage>();
+  const pending = [first.promise, second.promise, third.promise];
+  const transport: ProviderStreams = {
+    stream: (model) => deferredResultStream(model, pending.shift()!),
+    streamSimple: (model) => deferredResultStream(model, pending.shift()!),
+  };
+  const silenced = silenceOpenAiSdkTransportLogs(transport);
+  const model = testModel("gpt-5.6-sol");
+
+  try {
+    const firstStream = silenced.streamSimple(model, { messages: [], tools: [] });
+    const secondStream = silenced.streamSimple(model, { messages: [], tools: [] });
+    expect(process.env.OPENAI_LOG).toBe("off");
+
+    first.resolve(terminalMessage(model));
+    await firstStream.result();
+    await Promise.resolve();
+    expect(process.env.OPENAI_LOG).toBe("off");
+
+    second.resolve(terminalMessage(model));
+    await secondStream.result();
+    await Promise.resolve();
+    expect(process.env.OPENAI_LOG).toBe("debug");
+
+    const thirdStream = silenced.streamSimple(model, { messages: [], tools: [] });
+    process.env.OPENAI_LOG = "info";
+    third.resolve(terminalMessage(model));
+    await thirdStream.result();
+    await Promise.resolve();
+    expect(process.env.OPENAI_LOG).toBe("info");
+  } finally {
+    const terminal = terminalMessage(model);
+    first.resolve(terminal);
+    second.resolve(terminal);
+    third.resolve(terminal);
+    await Promise.allSettled([first.promise, second.promise, third.promise]);
+    if (previousOpenAiLog === undefined) delete process.env.OPENAI_LOG;
+    else process.env.OPENAI_LOG = previousOpenAiLog;
+  }
+});
+
+function deferredResultStream(
+  model: Model<Api>,
+  result: Promise<AssistantMessage>,
+): ReturnType<ProviderStreams["stream"]> {
+  return {
+    async *[Symbol.asyncIterator]() {},
+    result: () => result,
+  } as unknown as ReturnType<ProviderStreams["stream"]>;
+}
+
 test("Baidu Responses uses one top-level instructions value and leaves caller overrides intact", async () => {
   const contexts: Context[] = [];
   const payloads: unknown[] = [];

packages/spark-ai/src/baidu-oneapi-compat-extension.ts

@@ -1,12 +1,10 @@
-import { anthropicMessagesApi, lazyApi } from "@earendil-works/pi-ai/compat";
+import { anthropicMessagesApi, openAIResponsesApi } from "@earendil-works/pi-ai/compat";
 
 import { createBaiduOneApiProviderAdapter, silenceOpenAiSdkTransportLogs } from "./baidu-oneapi.ts";
 
 const piBaiduOneApiProvider = createBaiduOneApiProviderAdapter({
   anthropicMessages: anthropicMessagesApi(),
-  openAIResponses: lazyApi(async () =>
-    silenceOpenAiSdkTransportLogs(await import("@earendil-works/pi-ai/api/openai-responses")),
-  ),
+  openAIResponses: silenceOpenAiSdkTransportLogs(openAIResponsesApi()),
 });
 
 export default function registerBaiduOneApiCompatibilityExtension(

packages/spark-ai/src/baidu-oneapi.ts

@@ -99,6 +99,11 @@ const CLAUDE_OPUS_COST = {
   cacheWrite: 6.875,
 };
 
+// The compat factory imports the transport after stream() returns, so the process-wide
+// OpenAI log guard must remain active until the lazy stream reaches a terminal result.
+let openAiSdkLogGuardDepth = 0;
+let openAiSdkPreviousLogLevel: string | undefined;
+
 export function silenceOpenAiSdkTransportLogs(transport: ProviderStreams): ProviderStreams {
   return {
     stream: (model, context, options) =>
@@ -108,16 +113,45 @@ export function silenceOpenAiSdkTransportLogs(transport: ProviderStreams): Provi
   };
 }
 
-function withOpenAiSdkLoggingDisabled<T>(start: () => T): T {
-  const previous = process.env.OPENAI_LOG;
-  process.env.OPENAI_LOG = "off";
+function withOpenAiSdkLoggingDisabled<T extends BaiduOneApiStream>(start: () => T): T {
+  const release = acquireOpenAiSdkLogGuard();
+  let stream: T;
+  try {
+    stream = start();
+  } catch (error) {
+    release();
+    throw error;
+  }
   try {
-    // pi-ai creates the OpenAI client synchronously before returning its event stream.
-    return start();
-  } finally {
-    if (previous === undefined) delete process.env.OPENAI_LOG;
-    else process.env.OPENAI_LOG = previous;
+    void stream.result().then(release, release);
+  } catch (error) {
+    release();
+    throw error;
   }
+  return stream;
+}
+
+function acquireOpenAiSdkLogGuard(): () => void {
+  if (openAiSdkLogGuardDepth === 0) {
+    openAiSdkPreviousLogLevel = process.env.OPENAI_LOG;
+    process.env.OPENAI_LOG = "off";
+  }
+  openAiSdkLogGuardDepth += 1;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    openAiSdkLogGuardDepth -= 1;
+    if (openAiSdkLogGuardDepth > 0) return;
+    if (process.env.OPENAI_LOG === "off") {
+      if (openAiSdkPreviousLogLevel === undefined) {
+        Reflect.deleteProperty(process.env, "OPENAI_LOG");
+      } else {
+        process.env.OPENAI_LOG = openAiSdkPreviousLogLevel;
+      }
+    }
+    openAiSdkPreviousLogLevel = undefined;
+  };
 }
 
 function mapThinkingEffort(