pi-oxidized 0.1.1

package/.references/pi/packages/ai/test/max-thinking.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { streamSimple as streamSimpleOpenAICodexResponses } from "../src/api/openai-codex-responses.ts";
+import { clampThinkingLevel, getModel, getSupportedThinkingLevels } from "../src/compat.ts";
+import type { Context, Model } from "../src/types.ts";
+
+function mockToken(): string {
+	const payload = Buffer.from(
+		JSON.stringify({ "https://api.openai.com/auth": { chatgpt_account_id: "acc_test" } }),
+		"utf8",
+	).toString("base64");
+	return `aaa.${payload}.bbb`;
+}
+
+describe("max thinking level", () => {
+	it("is opt-in for ordinary reasoning models", () => {
+		const model: Model<"openai-completions"> = {
+			id: "ordinary-reasoning",
+			name: "Ordinary Reasoning",
+			api: "openai-completions",
+			provider: "test",
+			baseUrl: "https://example.com/v1",
+			reasoning: true,
+			input: ["text"],
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			contextWindow: 128000,
+			maxTokens: 4096,
+		};
+
+		expect(getSupportedThinkingLevels(model)).toEqual(["off", "minimal", "low", "medium", "high"]);
+		expect(clampThinkingLevel(model, "max")).toBe("high");
+	});
+
+	it.each(["gpt-5.6-luna", "gpt-5.6-sol", "gpt-5.6-terra"] as const)(
+		"exposes xhigh and max for openai-codex/%s",
+		(modelId) => {
+			const model = getModel("openai-codex", modelId);
+			expect(model).toBeDefined();
+			expect(model?.thinkingLevelMap).toMatchObject({ xhigh: "xhigh", max: "max" });
+			expect(getSupportedThinkingLevels(model!)).toEqual([
+				"off",
+				"minimal",
+				"low",
+				"medium",
+				"high",
+				"xhigh",
+				"max",
+			]);
+		},
+	);
+
+	it("supports a hole between high and max", () => {
+		const model: Model<"openai-completions"> = {
+			id: "high-and-max",
+			name: "High and Max",
+			api: "openai-completions",
+			provider: "test",
+			baseUrl: "https://example.com/v1",
+			reasoning: true,
+			thinkingLevelMap: { xhigh: null, max: "max" },
+			input: ["text"],
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			contextWindow: 128000,
+			maxTokens: 4096,
+		};
+
+		expect(getSupportedThinkingLevels(model)).toEqual(["off", "minimal", "low", "medium", "high", "max"]);
+		expect(clampThinkingLevel(model, "xhigh")).toBe("max");
+	});
+
+	it("sends max to the Codex Responses API", async () => {
+		const model = getModel("openai-codex", "gpt-5.6-sol")!;
+		const context: Context = {
+			systemPrompt: "You are a helpful assistant.",
+			messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+		};
+		let payload: unknown;
+
+		await streamSimpleOpenAICodexResponses(model, context, {
+			apiKey: mockToken(),
+			reasoning: "max",
+			onPayload: (request) => {
+				payload = request;
+				throw new Error("payload captured");
+			},
+		}).result();
+
+		expect(payload).toMatchObject({ reasoning: { effort: "max", summary: "auto" } });
+	});
+});

package/.references/pi/packages/ai/test/mistral-reasoning-mode.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import { getModel, streamSimple } from "../src/compat.ts";
+import type { Context, Model, SimpleStreamOptions } from "../src/types.ts";
+
+interface MistralPayload {
+	promptMode?: "reasoning";
+	reasoningEffort?: "none" | "high";
+	promptCacheKey?: string;
+}
+
+function makeContext(): Context {
+	return {
+		messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+	};
+}
+
+async function capturePayload(
+	model: Model<"mistral-conversations">,
+	options?: SimpleStreamOptions,
+): Promise<MistralPayload> {
+	let capturedPayload: MistralPayload | undefined;
+	const payloadCaptureModel: Model<"mistral-conversations"> = {
+		...model,
+		baseUrl: "http://127.0.0.1:9",
+	};
+
+	const stream = streamSimple(payloadCaptureModel, makeContext(), {
+		...options,
+		apiKey: "fake-key",
+		onPayload: (payload) => {
+			capturedPayload = payload as MistralPayload;
+			return payload;
+		},
+	});
+
+	await stream.result();
+
+	if (!capturedPayload) {
+		throw new Error("Expected payload to be captured before request failure");
+	}
+
+	return capturedPayload;
+}
+
+describe("Mistral reasoning mode selection", () => {
+	it("uses reasoning_effort for Mistral Small 4", async () => {
+		const payload = await capturePayload(getModel("mistral", "mistral-small-2603"), { reasoning: "medium" });
+
+		expect(payload.reasoningEffort).toBe("high");
+		expect(payload.promptMode).toBeUndefined();
+	});
+
+	it("omits reasoning controls for Mistral Small 4 when thinking is off", async () => {
+		const payload = await capturePayload(getModel("mistral", "mistral-small-2603"));
+
+		expect(payload.reasoningEffort).toBeUndefined();
+		expect(payload.promptMode).toBeUndefined();
+	});
+
+	it("uses prompt_mode for Magistral reasoning models", async () => {
+		const payload = await capturePayload(getModel("mistral", "magistral-medium-latest"), { reasoning: "medium" });
+
+		expect(payload.promptMode).toBe("reasoning");
+		expect(payload.reasoningEffort).toBeUndefined();
+	});
+
+	it("uses reasoning_effort for Mistral Medium 3.5", async () => {
+		const payload = await capturePayload(getModel("mistral", "mistral-medium-3.5"), { reasoning: "medium" });
+
+		expect(payload.reasoningEffort).toBe("high");
+		expect(payload.promptMode).toBeUndefined();
+	});
+
+	it("omits reasoning controls for Mistral Medium 3.5 when thinking is off", async () => {
+		const payload = await capturePayload(getModel("mistral", "mistral-medium-3.5"));
+
+		expect(payload.reasoningEffort).toBeUndefined();
+		expect(payload.promptMode).toBeUndefined();
+	});
+
+	it("uses the session id as prompt cache key", async () => {
+		const payload = await capturePayload(getModel("mistral", "mistral-large-latest"), {
+			sessionId: "session-123",
+		});
+
+		expect(payload.promptCacheKey).toBe("session-123");
+	});
+
+	it("omits prompt cache key when cache retention is disabled", async () => {
+		const payload = await capturePayload(getModel("mistral", "mistral-large-latest"), {
+			sessionId: "session-123",
+			cacheRetention: "none",
+		});
+
+		expect(payload.promptCacheKey).toBeUndefined();
+	});
+});

package/.references/pi/packages/ai/test/mistral-tool-schema.test.ts

@@ -0,0 +1,60 @@
+import { Type } from "typebox";
+import { describe, expect, it } from "vitest";
+import { complete, getModel } from "../src/compat.ts";
+import type { Context, Model } from "../src/types.ts";
+
+interface MistralToolPayload {
+	tools?: Array<{
+		type: "function";
+		function: {
+			name: string;
+			parameters: Record<string, unknown>;
+		};
+	}>;
+}
+
+describe("Mistral tool schema serialization", () => {
+	it("strips TypeBox symbol keys before the SDK validates tool schemas", async () => {
+		const model: Model<"mistral-conversations"> = {
+			...getModel("mistral", "devstral-medium-latest"),
+			baseUrl: "http://127.0.0.1:9",
+		};
+		const parameters = Type.Object({
+			nested: Type.Object({
+				value: Type.String(),
+			}),
+		});
+		const context: Context = {
+			messages: [{ role: "user", content: "Hi", timestamp: Date.now() }],
+			tools: [
+				{
+					name: "inspect_schema",
+					description: "Inspect the schema",
+					parameters,
+				},
+			],
+		};
+		let capturedPayload: MistralToolPayload | undefined;
+
+		const response = await complete(model, context, {
+			apiKey: "fake-key",
+			onPayload: (payload) => {
+				capturedPayload = payload as MistralToolPayload;
+				return payload;
+			},
+		});
+
+		expect(capturedPayload?.tools).toHaveLength(1);
+		const payloadParameters = capturedPayload?.tools?.[0]?.function.parameters;
+		expect(payloadParameters).toBeDefined();
+		expect(Object.getOwnPropertySymbols(payloadParameters ?? {})).toHaveLength(0);
+		const properties = payloadParameters?.properties;
+		expect(properties).toBeTruthy();
+		expect(Object.getOwnPropertySymbols((properties as Record<string, unknown>) ?? {})).toHaveLength(0);
+		const nested = (properties as Record<string, unknown> | undefined)?.nested;
+		expect(nested).toBeTruthy();
+		expect(Object.getOwnPropertySymbols((nested as Record<string, unknown>) ?? {})).toHaveLength(0);
+		expect(response.stopReason).toBe("error");
+		expect(response.errorMessage).not.toContain("Input validation failed");
+	});
+});