Release v0.23.2

Fixed Claude models via GitHub Copilot re-answering all previous prompts.

fixes #209

packages/ai/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mariozechner/pi-ai",
-	"version": "0.23.1",
+	"version": "0.23.2",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./dist/index.js",

packages/ai/src/models.generated.ts

@@ -364,6 +364,23 @@ export const MODELS = {
 		} satisfies Model<"anthropic-messages">,
 	},
 	"google": {
+		"gemini-3-flash-preview": {
+			id: "gemini-3-flash-preview",
+			name: "Gemini 3 Flash Preview",
+			api: "google-generative-ai",
+			provider: "google",
+			baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+			reasoning: true,
+			input: ["text", "image"],
+			cost: {
+				input: 0.15,
+				output: 0.6,
+				cacheRead: 0.0375,
+				cacheWrite: 0,
+			},
+			contextWindow: 1048576,
+			maxTokens: 65536,
+		} satisfies Model<"google-generative-ai">,
 		"gemini-2.5-flash-preview-05-20": {
 			id: "gemini-2.5-flash-preview-05-20",
 			name: "Gemini 2.5 Flash Preview 05-20",
@@ -2805,6 +2822,23 @@ export const MODELS = {
 		} satisfies Model<"openai-completions">,
 	},
 	"openrouter": {
+		"google/gemini-3-flash-preview": {
+			id: "google/gemini-3-flash-preview",
+			name: "Google: Gemini 3 Flash Preview",
+			api: "openai-completions",
+			provider: "openrouter",
+			baseUrl: "https://openrouter.ai/api/v1",
+			reasoning: true,
+			input: ["text", "image"],
+			cost: {
+				input: 0.5,
+				output: 3,
+				cacheRead: 0.049999999999999996,
+				cacheWrite: 0,
+			},
+			contextWindow: 1048576,
+			maxTokens: 65535,
+		} satisfies Model<"openai-completions">,
 		"mistralai/mistral-small-creative": {
 			id: "mistralai/mistral-small-creative",
 			name: "Mistral: Mistral Small Creative",

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

@@ -302,13 +302,11 @@ function createClient(model: Model<"openai-completions">, context: Context, apiK
 	const headers = { ...model.headers };
 	if (model.provider === "github-copilot") {
 		// Copilot expects X-Initiator to indicate whether the request is user-initiated
-		// or agent-initiated (e.g. follow-up after assistant/tool messages). If there is
-		// no prior message, default to user-initiated.
+		// or agent-initiated. It's an agent call if ANY message in history has assistant/tool role.
 		const messages = context.messages || [];
-		const lastMessage = messages[messages.length - 1];
-		const isAgentCall = lastMessage ? lastMessage.role !== "user" : false;
-		const initiatorValue = isAgentCall ? "agent" : "user";
-		headers["X-Initiator"] = initiatorValue;
+		const isAgentCall = messages.some((msg) => msg.role === "assistant" || msg.role === "toolResult");
+		headers["X-Initiator"] = isAgentCall ? "agent" : "user";
+		headers["Openai-Intent"] = "conversation-edits";
 	}
 
 	return new OpenAI({
@@ -431,9 +429,15 @@ function convertMessages(
 
 			const textBlocks = msg.content.filter((b) => b.type === "text") as TextContent[];
 			if (textBlocks.length > 0) {
-				assistantMsg.content = textBlocks.map((b) => {
-					return { type: "text", text: sanitizeSurrogates(b.text) };
-				});
+				// GitHub Copilot requires assistant content as a string, not an array.
+				// Sending as array causes Claude models to re-answer all previous prompts.
+				if (model.provider === "github-copilot") {
+					assistantMsg.content = textBlocks.map((b) => sanitizeSurrogates(b.text)).join("");
+				} else {
+					assistantMsg.content = textBlocks.map((b) => {
+						return { type: "text", text: sanitizeSurrogates(b.text) };
+					});
+				}
 			}
 
 			// Handle thinking blocks

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

@@ -310,13 +310,11 @@ function createClient(model: Model<"openai-responses">, context: Context, apiKey
 	const headers = { ...model.headers };
 	if (model.provider === "github-copilot") {
 		// Copilot expects X-Initiator to indicate whether the request is user-initiated
-		// or agent-initiated (e.g. follow-up after assistant/tool messages). If there is
-		// no prior message, default to user-initiated.
+		// or agent-initiated. It's an agent call if ANY message in history has assistant/tool role.
 		const messages = context.messages || [];
-		const lastMessage = messages[messages.length - 1];
-		const isAgentCall = lastMessage ? lastMessage.role !== "user" : false;
-		const initiatorValue = isAgentCall ? "agent" : "user";
-		headers["X-Initiator"] = initiatorValue;
+		const isAgentCall = messages.some((msg) => msg.role === "assistant" || msg.role === "toolResult");
+		headers["X-Initiator"] = isAgentCall ? "agent" : "user";
+		headers["Openai-Intent"] = "conversation-edits";
 	}
 
 	return new OpenAI({

packages/ai/test/copilot-initiator.test.ts

@@ -93,7 +93,7 @@ async function consumeStream(stream: AsyncIterable<unknown>): Promise<void> {
 	}
 }
 
-describe("GitHub Copilot X-Initiator Header", () => {
+describe("GitHub Copilot Headers", () => {
 	beforeEach(() => {
 		lastOpenAIConfig = undefined;
 	});
@@ -136,171 +136,201 @@ describe("GitHub Copilot X-Initiator Header", () => {
 		provider: "openai",
 	};
 
-	it("completions: sets X-Initiator: user when last message is from user (Copilot)", async () => {
-		const context: Context = {
-			messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
-		};
+	const assistantMessage = {
+		role: "assistant" as const,
+		content: [],
+		api: "openai-completions" as const,
+		provider: "github-copilot" as const,
+		model: "gpt-4",
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop" as const,
+		timestamp: Date.now(),
+	};
 
-		const stream = streamOpenAICompletions(copilotCompletionsModel, context, { apiKey: "test-key" });
-		await consumeStream(stream);
+	const toolResultMessage = {
+		role: "toolResult" as const,
+		content: [],
+		toolCallId: "1",
+		toolName: "test",
+		isError: false,
+		timestamp: Date.now(),
+	};
 
-		expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("user");
+	describe("completions API", () => {
+		it("sets X-Initiator: user for first message (no history)", async () => {
+			const context: Context = {
+				messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+			};
+
+			const stream = streamOpenAICompletions(copilotCompletionsModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
+
+			expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("user");
+		});
+
+		it("sets X-Initiator: agent when assistant message exists in history", async () => {
+			const context: Context = {
+				messages: [{ role: "user", content: "Hello", timestamp: Date.now() }, assistantMessage],
+			};
+
+			const stream = streamOpenAICompletions(copilotCompletionsModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
+
+			expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("agent");
+		});
+
+		it("sets X-Initiator: agent when toolResult exists in history", async () => {
+			const context: Context = {
+				messages: [{ role: "user", content: "Hello", timestamp: Date.now() }, toolResultMessage],
+			};
+
+			const stream = streamOpenAICompletions(copilotCompletionsModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
+
+			expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("agent");
+		});
+
+		it("sets X-Initiator: agent for multi-turn conversation (last is user, but assistant in history)", async () => {
+			const context: Context = {
+				messages: [
+					{ role: "user", content: "Hello", timestamp: Date.now() },
+					assistantMessage,
+					{ role: "user", content: "Tell me a joke", timestamp: Date.now() },
+				],
+			};
+
+			const stream = streamOpenAICompletions(copilotCompletionsModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
+
+			expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("agent");
+		});
+
+		it("sets X-Initiator: user when there are no messages", async () => {
+			const context: Context = {
+				messages: [],
+			};
+
+			const stream = streamOpenAICompletions(copilotCompletionsModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
+
+			expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("user");
+		});
+
+		it("sets Openai-Intent: conversation-edits", async () => {
+			const context: Context = {
+				messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+			};
+
+			const stream = streamOpenAICompletions(copilotCompletionsModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
+
+			expect(lastOpenAIConfig?.defaultHeaders?.["Openai-Intent"]).toBe("conversation-edits");
+		});
+
+		it("does NOT set Copilot headers for non-Copilot providers", async () => {
+			const context: Context = {
+				messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+			};
+
+			const stream = streamOpenAICompletions(otherCompletionsModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
+
+			expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBeUndefined();
+			expect(lastOpenAIConfig?.defaultHeaders?.["Openai-Intent"]).toBeUndefined();
+		});
 	});
 
-	it("completions: sets X-Initiator: agent when last message is from assistant (Copilot)", async () => {
-		const context: Context = {
-			messages: [
-				{ role: "user", content: "Hello", timestamp: Date.now() },
-				{
-					role: "assistant",
-					content: [],
-					api: "openai-completions",
-					provider: "github-copilot",
-					model: "gpt-4",
-					usage: {
-						input: 0,
-						output: 0,
-						cacheRead: 0,
-						cacheWrite: 0,
-						totalTokens: 0,
-						cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-					},
-					stopReason: "stop",
-					timestamp: Date.now(),
-				},
-			],
-		};
+	describe("responses API", () => {
+		it("sets X-Initiator: user for first message (no history)", async () => {
+			const context: Context = {
+				messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+			};
 
-		const stream = streamOpenAICompletions(copilotCompletionsModel, context, { apiKey: "test-key" });
-		await consumeStream(stream);
+			const stream = streamOpenAIResponses(copilotResponsesModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
 
-		expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("agent");
-	});
+			expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("user");
+		});
 
-	it("completions: sets X-Initiator: agent when last message is from toolResult (Copilot)", async () => {
-		const context: Context = {
-			messages: [
-				{ role: "user", content: "Hello", timestamp: Date.now() },
-				{
-					role: "toolResult",
-					content: [],
-					toolCallId: "1",
-					toolName: "test",
-					isError: false,
-					timestamp: Date.now(),
-				},
-			],
-		};
+		it("sets X-Initiator: agent when assistant message exists in history", async () => {
+			const context: Context = {
+				messages: [
+					{ role: "user", content: "Hello", timestamp: Date.now() },
+					{ ...assistantMessage, api: "openai-responses" as const, model: "gpt-5.1-codex" },
+				],
+			};
 
-		const stream = streamOpenAICompletions(copilotCompletionsModel, context, { apiKey: "test-key" });
-		await consumeStream(stream);
+			const stream = streamOpenAIResponses(copilotResponsesModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
 
-		expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("agent");
-	});
+			expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("agent");
+		});
 
-	it("completions: defaults to X-Initiator: user when there are no messages (Copilot)", async () => {
-		const context: Context = {
-			messages: [],
-		};
+		it("sets X-Initiator: agent when toolResult exists in history", async () => {
+			const context: Context = {
+				messages: [{ role: "user", content: "Hello", timestamp: Date.now() }, toolResultMessage],
+			};
 
-		const stream = streamOpenAICompletions(copilotCompletionsModel, context, { apiKey: "test-key" });
-		await consumeStream(stream);
+			const stream = streamOpenAIResponses(copilotResponsesModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
 
-		expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("user");
-	});
+			expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("agent");
+		});
 
-	it("completions: does NOT set X-Initiator for non-Copilot providers", async () => {
-		const context: Context = {
-			messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
-		};
+		it("sets X-Initiator: agent for multi-turn conversation (last is user, but assistant in history)", async () => {
+			const context: Context = {
+				messages: [
+					{ role: "user", content: "Hello", timestamp: Date.now() },
+					{ ...assistantMessage, api: "openai-responses" as const, model: "gpt-5.1-codex" },
+					{ role: "user", content: "Tell me a joke", timestamp: Date.now() },
+				],
+			};
 
-		const stream = streamOpenAICompletions(otherCompletionsModel, context, { apiKey: "test-key" });
-		await consumeStream(stream);
+			const stream = streamOpenAIResponses(copilotResponsesModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
 
-		expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBeUndefined();
-	});
+			expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("agent");
+		});
 
-	it("responses: sets X-Initiator: user when last message is from user (Copilot)", async () => {
-		const context: Context = {
-			messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
-		};
+		it("sets X-Initiator: user when there are no messages", async () => {
+			const context: Context = {
+				messages: [],
+			};
 
-		const stream = streamOpenAIResponses(copilotResponsesModel, context, { apiKey: "test-key" });
-		await consumeStream(stream);
+			const stream = streamOpenAIResponses(copilotResponsesModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
 
-		expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("user");
-	});
+			expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("user");
+		});
 
-	it("responses: sets X-Initiator: agent when last message is from assistant (Copilot)", async () => {
-		const context: Context = {
-			messages: [
-				{ role: "user", content: "Hello", timestamp: Date.now() },
-				{
-					role: "assistant",
-					content: [],
-					api: "openai-responses",
-					provider: "github-copilot",
-					model: "gpt-5.1-codex",
-					usage: {
-						input: 0,
-						output: 0,
-						cacheRead: 0,
-						cacheWrite: 0,
-						totalTokens: 0,
-						cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-					},
-					stopReason: "stop",
-					timestamp: Date.now(),
-				},
-			],
-		};
+		it("sets Openai-Intent: conversation-edits", async () => {
+			const context: Context = {
+				messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+			};
 
-		const stream = streamOpenAIResponses(copilotResponsesModel, context, { apiKey: "test-key" });
-		await consumeStream(stream);
+			const stream = streamOpenAIResponses(copilotResponsesModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
 
-		expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("agent");
-	});
+			expect(lastOpenAIConfig?.defaultHeaders?.["Openai-Intent"]).toBe("conversation-edits");
+		});
 
-	it("responses: sets X-Initiator: agent when last message is from toolResult (Copilot)", async () => {
-		const context: Context = {
-			messages: [
-				{ role: "user", content: "Hello", timestamp: Date.now() },
-				{
-					role: "toolResult",
-					content: [],
-					toolCallId: "1",
-					toolName: "test",
-					isError: false,
-					timestamp: Date.now(),
-				},
-			],
-		};
+		it("does NOT set Copilot headers for non-Copilot providers", async () => {
+			const context: Context = {
+				messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+			};
 
-		const stream = streamOpenAIResponses(copilotResponsesModel, context, { apiKey: "test-key" });
-		await consumeStream(stream);
+			const stream = streamOpenAIResponses(otherResponsesModel, context, { apiKey: "test-key" });
+			await consumeStream(stream);
 
-		expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("agent");
-	});
-
-	it("responses: defaults to X-Initiator: user when there are no messages (Copilot)", async () => {
-		const context: Context = {
-			messages: [],
-		};
-
-		const stream = streamOpenAIResponses(copilotResponsesModel, context, { apiKey: "test-key" });
-		await consumeStream(stream);
-
-		expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBe("user");
-	});
-
-	it("responses: does NOT set X-Initiator for non-Copilot providers", async () => {
-		const context: Context = {
-			messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
-		};
-
-		const stream = streamOpenAIResponses(otherResponsesModel, context, { apiKey: "test-key" });
-		await consumeStream(stream);
-
-		expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBeUndefined();
+			expect(lastOpenAIConfig?.defaultHeaders?.["X-Initiator"]).toBeUndefined();
+			expect(lastOpenAIConfig?.defaultHeaders?.["Openai-Intent"]).toBeUndefined();
+		});
 	});
 });