fix(ai): omit the default service tier, reprice cache writes from message_delta, repoint the zai default

packages/ai/.changes/service-tier-default-omitted.md

@@ -0,0 +1 @@
+- The default service tier is no longer sent explicitly on OpenAI Responses and Codex requests (absence means default; strict endpoints such as Copilot reject the field), and Anthropic cache-write pricing now reprices from a message_delta usage breakdown instead of keeping the message_start rate.

packages/ai/src/providers/anthropic.ts

@@ -6,7 +6,11 @@ import type {
 	MessageParam,
 	RawMessageStreamEvent,
 } from "@anthropic-ai/sdk/resources/messages.js";
-import { getAnthropicCacheWriteCost, hasStandardAnthropicCachePricing } from "../cache-pricing.js";
+import {
+	type AnthropicCacheCreationUsage,
+	getAnthropicCacheWriteCost,
+	hasStandardAnthropicCachePricing,
+} from "../cache-pricing.js";
 import { getEnvApiKey } from "../env-api-keys.js";
 import { calculateCost, clampThinkingLevel } from "../models.js";
 import type {
@@ -695,6 +699,16 @@ export const streamAnthropic: StreamFunction<"anthropic-messages", AnthropicOpti
 					if (event.usage.cache_creation_input_tokens != null) {
 						output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
 					}
+					// The SDK's MessageDeltaUsage type omits cache_creation, but the wire carries it.
+					const deltaCacheCreation = (event.usage as { cache_creation?: AnthropicCacheCreationUsage | null })
+						.cache_creation;
+					if (cacheControl && usesAnthropicCachePricing && deltaCacheCreation) {
+						cacheWriteCost = getAnthropicCacheWriteCost(
+							model.cost.input,
+							cacheControl.ttl === "1h" ? "1h" : "5m",
+							deltaCacheCreation,
+						);
+					}
 					output.usage.totalTokens =
 						output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
 					calculateCost(

packages/ai/src/providers/openai-responses.ts

@@ -237,7 +237,9 @@ function buildParams(model: Model<"openai-responses">, context: Context, options
 		params.temperature = options?.temperature;
 	}
 
-	if (options?.serviceTier !== undefined) {
+	// GitHub Copilot rejects the service_tier FIELD itself (400) for every value.
+	// Elsewhere it is always sent: absence means "auto" (project tier), not "default".
+	if (options?.serviceTier !== undefined && model.provider !== "github-copilot") {
 		params.service_tier = options.serviceTier;
 	}
 

packages/ai/test/anthropic-sse-parsing.test.ts

@@ -78,11 +78,13 @@ function createFakeAnthropicClient(response: Response): Anthropic {
 	} as unknown as Anthropic;
 }
 
-function createCacheUsageEvents(cacheCreation: {
-	ephemeral_5m_input_tokens: number;
-	ephemeral_1h_input_tokens: number;
-}): Array<{ event: string; data: string }> {
-	const cacheWriteTokens = cacheCreation.ephemeral_5m_input_tokens + cacheCreation.ephemeral_1h_input_tokens;
+type CacheCreation = { ephemeral_5m_input_tokens: number; ephemeral_1h_input_tokens: number };
+
+function createCacheUsageEvents(
+	cacheCreation: CacheCreation,
+	deltaCacheCreation?: CacheCreation,
+): Array<{ event: string; data: string }> {
+	const tokens = (c: CacheCreation) => c.ephemeral_5m_input_tokens + c.ephemeral_1h_input_tokens;
 	return [
 		{
 			event: "message_start",
@@ -94,7 +96,7 @@ function createCacheUsageEvents(cacheCreation: {
 						input_tokens: 12,
 						output_tokens: 0,
 						cache_read_input_tokens: 0,
-						cache_creation_input_tokens: cacheWriteTokens,
+						cache_creation_input_tokens: tokens(cacheCreation),
 						cache_creation: cacheCreation,
 					},
 				},
@@ -109,7 +111,8 @@ function createCacheUsageEvents(cacheCreation: {
 					input_tokens: 12,
 					output_tokens: 5,
 					cache_read_input_tokens: 0,
-					cache_creation_input_tokens: cacheWriteTokens,
+					cache_creation_input_tokens: tokens(deltaCacheCreation ?? cacheCreation),
+					...(deltaCacheCreation ? { cache_creation: deltaCacheCreation } : {}),
 				},
 			}),
 		},
@@ -153,6 +156,24 @@ describe("Anthropic raw SSE parsing", () => {
 		expect(result.usage.cost.cacheWrite).toBeCloseTo(testCase.expectedCacheWriteCost);
 	});
 
+	it("reprices cache writes from a message_delta usage breakdown", async () => {
+		const model = getModel("anthropic", "claude-haiku-4-5");
+		const response = createSseResponse(
+			createCacheUsageEvents(
+				{ ephemeral_5m_input_tokens: 1000, ephemeral_1h_input_tokens: 0 },
+				{ ephemeral_5m_input_tokens: 0, ephemeral_1h_input_tokens: 2000 },
+			),
+		);
+		const result = await streamAnthropic(
+			model,
+			{ messages: [{ role: "user", content: "Say hello.", timestamp: Date.now() }] },
+			{ client: createFakeAnthropicClient(response), cacheRetention: "long" },
+		).result();
+
+		expect(result.usage.cacheWrite).toBe(2000);
+		// 2000 one-hour tokens at 2x input cost, not the stale 1.25x rate from message_start.
+		expect(result.usage.cost.cacheWrite).toBeCloseTo(0.004, 6);
+	});
 	it("preserves configured cache write pricing for non-Anthropic models", async () => {
 		const model = getModel("minimax", "MiniMax-M2.7-highspeed");
 		const response = createSseResponse(

packages/ai/test/openai-codex-stream.test.ts

@@ -562,6 +562,8 @@ describe("openai-codex streaming", () => {
 	});
 
 	it.each([
+		// "default" must stay on the wire: absence means "auto" (the project tier).
+		["gpt-5.1-codex", "default", 1],
 		["gpt-5.1-codex", "flex", 0.5],
 		["gpt-5.1-codex", "priority", 2],
 		["gpt-5.4", "priority", 2],

packages/ai/test/openai-responses-copilot-provider.test.ts

@@ -212,6 +212,41 @@ describe("openai-responses provider defaults", () => {
 		expect(captured).toEqual({ sessionId: null, clientRequestId: null });
 	});
 
+	it.each([
+		["github-copilot" as const, "auto" as const, false],
+		["github-copilot" as const, "default" as const, false],
+		["openai" as const, "default" as const, true],
+	])("scopes service_tier serialization to the provider (%s, %s)", async (provider, serviceTier, expected) => {
+		const base = getModel("openai", "gpt-5.4");
+		const model = { ...base, provider };
+		const sse = `data: ${JSON.stringify({
+			type: "response.completed",
+			response: {
+				status: "completed",
+				usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2, input_tokens_details: { cached_tokens: 0 } },
+			},
+		})}\n\n`;
+		let wireBody: Record<string, unknown> | undefined;
+		vi.spyOn(globalThis, "fetch").mockImplementation(async (_input, init) => {
+			wireBody = JSON.parse(String(init?.body)) as Record<string, unknown>;
+			return new Response(sse, { status: 200, headers: { "content-type": "text/event-stream" } });
+		});
+
+		const result = await streamOpenAIResponses(
+			model,
+			{ systemPrompt: "sys", messages: [{ role: "user", content: "hi", timestamp: Date.now() }] },
+			{ apiKey: "test-key", serviceTier },
+		).result();
+
+		expect(result.stopReason).toBe("stop");
+		// Copilot rejects the FIELD for every value; elsewhere absence means "auto"
+		// (the project tier), so an explicit "default" must stay on the wire.
+		expect(wireBody && "service_tier" in wireBody).toBe(expected);
+		if (expected) {
+			expect((wireBody as Record<string, unknown>).service_tier).toBe(serviceTier);
+		}
+	});
+
 	it.each([
 		["gpt-5.4", "priority", 2],
 		["gpt-5.5", "priority", 2.5],

packages/coding-agent/.changes/zai-default-model.md

@@ -0,0 +1 @@
+- The zai provider default model now points at glm-5.3; the previous default was removed from the catalog and silently fell back to a template model.

packages/coding-agent/src/core/model-resolver.ts

@@ -33,7 +33,7 @@ export const defaultModelPerProvider: Record<KnownProvider, string> = {
 	xai: "grok-4.20-0309-reasoning",
 	groq: "openai/gpt-oss-120b",
 	cerebras: "gpt-oss-120b",
-	zai: "glm-5.1",
+	zai: "glm-5.3",
 	mistral: "devstral-medium-latest",
 	minimax: "MiniMax-M2.7",
 	"minimax-cn": "MiniMax-M2.7",

packages/coding-agent/test/model-resolver.test.ts

@@ -1,4 +1,4 @@
-import type { Model } from "@earendil-works/pi-ai";
+import { getModels, type KnownProvider, type Model } from "@earendil-works/pi-ai";
 import { describe, expect, test, vi } from "vitest";
 import {
 	defaultModelPerProvider,
@@ -303,8 +303,19 @@ describe("default model selection", () => {
 		expect(defaultModelPerProvider["prime-inference"]).toBe("z-ai/glm-5.2");
 	});
 
+	test("every per-provider default exists in the model catalog", () => {
+		for (const [provider, modelId] of Object.entries(defaultModelPerProvider)) {
+			const models = getModels(provider as KnownProvider);
+			if (models.length === 0) continue;
+			expect(
+				models.map((model) => model.id),
+				`default for ${provider}`,
+			).toContain(modelId);
+		}
+	});
+
 	test("zai, minimax, and cerebras defaults track current models", () => {
-		expect(defaultModelPerProvider.zai).toBe("glm-5.1");
+		expect(defaultModelPerProvider.zai).toBe("glm-5.3");
 		expect(defaultModelPerProvider.minimax).toBe("MiniMax-M2.7");
 		expect(defaultModelPerProvider["minimax-cn"]).toBe("MiniMax-M2.7");
 		expect(defaultModelPerProvider.cerebras).toBe("gpt-oss-120b");