pi-sap-aicore 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.1] - 2026-07-01
+
+### Added
+
+- Direct foundation route support for Gemini models deployed through SAP AI Core
+  `foundation-models` with the `gcp-vertexai` executable. The provider now calls
+  SAP AI Core's Vertex-compatible `generateContent` endpoint and replays the
+  non-streaming response into pi stream events.
+- Vertex AI/Gemini message translation for text, images, assistant function-call
+  history, and function-response history on the direct foundation route.
+
+### Changed
+
+- Gemini direct foundation requests set `generationConfig.thinkingConfig.thinkingBudget`
+  to `0` by default so small pi output budgets produce visible text instead of
+  being consumed entirely by hidden thoughts.
+- Refreshed npm dependency lockfile after `npm update` to pick up patched SAP SDK
+  transitive dependencies.
+
 ## [0.3.0] - 2026-07-01
 
 ### Added
@@ -116,7 +135,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   `reasoning_effort` for OpenAI).
 - MIT license and npm packaging.
 
-[Unreleased]: https://github.com/ttiimmaahh/pi-sap-aicore/compare/v0.3.0...HEAD
+[Unreleased]: https://github.com/ttiimmaahh/pi-sap-aicore/compare/v0.3.1...HEAD
+[0.3.1]: https://github.com/ttiimmaahh/pi-sap-aicore/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/ttiimmaahh/pi-sap-aicore/compare/v0.2.2...v0.3.0
 [0.2.2]: https://github.com/ttiimmaahh/pi-sap-aicore/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/ttiimmaahh/pi-sap-aicore/compare/v0.2.0...v0.2.1

package/README.md

@@ -131,11 +131,11 @@ The extension registers **two providers**, both backed by the same service key:
 | | `sap-aicore` (orchestration) | `sap-aicore-foundation` (direct) |
 |---|---|---|
 | SAP deployment | one orchestration deployment fronts **every** model | one foundation deployment **per model** |
-| Models | Claude, GPT-5*, Gemini | GPT/OpenAI (`azure-openai`) and Anthropic/Claude (`aws-bedrock`); Gemini/Vertex mapping is reserved but not implemented yet |
-| Streaming | subject to orchestration's per-model allow-list — new models can 400 `Streaming is not supported` (we fall back to non-streaming) | Azure OpenAI streams natively; AWS Bedrock currently uses non-streaming `/converse` and replays the response into pi stream events |
-| Reasoning effort | tunable (`reasoning_effort` / `thinking`) | model **default** only for Azure; Bedrock/Anthropic thinking controls are not wired yet |
+| Models | Claude, GPT-5*, Gemini | GPT/OpenAI (`azure-openai`), Anthropic/Claude (`aws-bedrock`), and Gemini (`gcp-vertexai`) |
+| Streaming | subject to orchestration's per-model allow-list — new models can 400 `Streaming is not supported` (we fall back to non-streaming) | Azure OpenAI streams natively; AWS Bedrock and Vertex AI currently use non-streaming endpoints and replay responses into pi stream events |
+| Reasoning effort | tunable (`reasoning_effort` / `thinking`) | model **default** only for Azure; Bedrock/Anthropic and Vertex/Gemini thinking controls are not fully wired yet |
 | Content filter / grounding / templating | yes | no — raw model access |
-| SDK / endpoint | `@sap-ai-sdk/orchestration` | `AzureOpenAiChatClient` for `azure-openai`; SAP `/inference/deployments/{id}/converse` for `aws-bedrock` |
+| SDK / endpoint | `@sap-ai-sdk/orchestration` | `AzureOpenAiChatClient` for `azure-openai`; SAP `/inference/deployments/{id}/converse` for `aws-bedrock`; SAP `/inference/deployments/{id}/models/{model}:generateContent` for `gcp-vertexai` |
 
 Both routes appear in the model list simultaneously, so you choose per model. The
 foundation route exists mainly to access new models directly when orchestration
@@ -145,8 +145,7 @@ Azure OpenAI or a newly deployed Claude model on AWS Bedrock).
 **Adding a foundation model:** it needs its own foundation-models deployment in
 SAP AI Core — one per (model, version, resource group). The extension chooses the
 foundation executable from the model id: `gpt-*` → `azure-openai`,
-`anthropic--*` → `aws-bedrock`, and `gemini-*` → `gcp-vertexai` (reserved; adapter
-not implemented yet). Then add its `id` to the per-machine extension overlay at
+`anthropic--*` → `aws-bedrock`, and `gemini-*` → `gcp-vertexai`. Then add its `id` to the per-machine extension overlay at
 `~/.pi/agent/pi-sap-aicore/models.json`:
 
 ```json
@@ -336,9 +335,10 @@ future, our `pickReasoning` probe is wired and ready in `stream.ts`.
 the direct Azure OpenAI SDK pinned to API version `2024-10-21`, which has no
 `reasoning_effort` field — so gpt-5\* reason at their **default** effort and pi's
 thinking-level cycle is a no-op there. Anthropic/Claude models use SAP's AWS
-Bedrock `/converse` endpoint; model-default reasoning works, but explicit Claude
-thinking controls are not wired yet. Use the orchestration route if you need
-explicit effort control.
+Bedrock `/converse` endpoint; Gemini models use SAP's Vertex AI `generateContent`
+endpoint with `thinkingBudget: 0` by default so small pi output budgets produce
+visible text instead of only hidden thoughts. Use the orchestration route if you
+need explicit effort control.
 
 To override budgets per model, edit `thinkingLevelMap` on the relevant entry in
 `~/.pi/agent/pi-sap-aicore/models.json`.
@@ -466,6 +466,8 @@ npmjs.com:
     ├── stream-foundation.ts              # foundation dispatcher
     ├── stream-foundation-azure-openai.ts # AzureOpenAiChatClient adapter with native streaming
     ├── stream-foundation-bedrock.ts      # AWS Bedrock /converse adapter for Anthropic foundation deployments
+    ├── stream-foundation-vertexai.ts     # Vertex AI generateContent adapter for Gemini foundation deployments
     ├── translate-foundation.ts           # pi Context ↔ Azure OpenAI message shape
-    └── translate-foundation-bedrock.ts   # pi Context ↔ Bedrock Converse message shape
+    ├── translate-foundation-bedrock.ts   # pi Context ↔ Bedrock Converse message shape
+    └── translate-foundation-vertexai.ts  # pi Context ↔ Vertex AI generateContent message shape
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-sap-aicore",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "SAP AI Core (orchestration + foundation) provider for the pi coding agent",
   "license": "MIT",
   "author": "Tim Pearson (https://github.com/ttiimmaahh)",

package/src/stream-foundation-vertexai.ts

@@ -0,0 +1,214 @@
+import { randomUUID } from "node:crypto";
+
+import {
+	type Api,
+	type AssistantMessage,
+	type AssistantMessageEventStream,
+	calculateCost,
+	type Context,
+	createAssistantMessageEventStream,
+	type Model,
+	type SimpleStreamOptions,
+} from "@earendil-works/pi-ai";
+import { executeRequest } from "@sap-ai-sdk/core";
+
+import { resolveFoundationDeploymentId } from "./foundation-deployment.ts";
+import {
+	debugLog,
+	ensureServiceKey,
+	formatError,
+	mapUsage,
+	resolveResourceGroup,
+} from "./stream.ts";
+import { mapFinishReason } from "./translate.ts";
+import { piContextToVertexGenerateContent } from "./translate-foundation-vertexai.ts";
+
+type VertexGenerateContentResponse = {
+	candidates?: Array<{
+		content?: {
+			role?: string;
+			parts?: Array<{
+				text?: string;
+				functionCall?: { name?: string; args?: unknown };
+			}>;
+		};
+		finishReason?: string;
+	}>;
+	usageMetadata?: {
+		promptTokenCount?: number;
+		candidatesTokenCount?: number;
+		thoughtsTokenCount?: number;
+		totalTokenCount?: number;
+	};
+};
+
+export function streamSapFoundationVertexAi(
+	model: Model<Api>,
+	context: Context,
+	options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+	const stream = createAssistantMessageEventStream();
+	const output: AssistantMessage = {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		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(),
+	};
+
+	(async () => {
+		const requestId = randomUUID();
+		try {
+			stream.push({ type: "start", partial: output });
+
+			const serviceKey = ensureServiceKey(options?.apiKey);
+			process.env.AICORE_SERVICE_KEY = serviceKey.raw;
+			const resourceGroup = resolveResourceGroup(serviceKey);
+			const deploymentId = await resolveFoundationDeploymentId({
+				modelId: model.id,
+				executableId: "gcp-vertexai",
+				resourceGroup,
+			});
+
+			const translated = piContextToVertexGenerateContent(context);
+			const maxOutputTokens = options?.maxTokens ?? model.maxTokens;
+			const request = {
+				...translated,
+				generationConfig: {
+					maxOutputTokens,
+					...(options?.temperature !== undefined
+						? { temperature: options.temperature }
+						: {}),
+					// Gemini 3.x can spend small max-token budgets entirely on
+					// thinking. Keep foundation route responsive by default; use
+					// orchestration once SAP exposes/validates richer thinking controls.
+					thinkingConfig: { thinkingBudget: 0 },
+				},
+			};
+
+			debugLog({
+				requestId,
+				kind: "request",
+				provider: "foundation-gcp-vertexai",
+				model: model.id,
+				resourceGroup,
+				deploymentId,
+				params: request.generationConfig,
+				messageRoles: request.contents.map((m) => m.role),
+				messages: request.contents,
+			});
+
+			const response = await executeRequest(
+				{
+					url: `/inference/deployments/${deploymentId}/models/${model.id}:generateContent`,
+					resourceGroup,
+				},
+				request,
+				{ signal: options?.signal },
+			);
+
+			const data = response.data as VertexGenerateContentResponse;
+			replayVertexGenerateContentResponse(stream, output, data);
+
+			if (data.usageMetadata) {
+				output.usage = mapUsage({
+					prompt_tokens: data.usageMetadata.promptTokenCount ?? 0,
+					completion_tokens:
+						(data.usageMetadata.candidatesTokenCount ?? 0) +
+						(data.usageMetadata.thoughtsTokenCount ?? 0),
+				});
+				calculateCost(model, output.usage);
+			}
+
+			const finishReason = data.candidates?.[0]?.finishReason;
+			output.stopReason = mapFinishReason(
+				finishReason === "MAX_TOKENS" ? "length" : finishReason,
+			);
+			stream.push({
+				type: "done",
+				reason: output.stopReason as "stop" | "length" | "toolUse",
+				message: output,
+			});
+			stream.end();
+		} catch (error) {
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = formatError(error);
+			debugLog({
+				requestId,
+				kind: "error",
+				provider: "foundation-gcp-vertexai",
+				model: model.id,
+				stopReason: output.stopReason,
+				error: output.errorMessage,
+			});
+			stream.push({
+				type: "error",
+				reason: output.stopReason as "error" | "aborted",
+				error: output,
+			});
+			stream.end();
+		}
+	})();
+
+	return stream;
+}
+
+function replayVertexGenerateContentResponse(
+	stream: AssistantMessageEventStream,
+	output: AssistantMessage,
+	data: VertexGenerateContentResponse,
+): void {
+	const parts = data.candidates?.[0]?.content?.parts ?? [];
+	for (const part of parts) {
+		if (typeof part.text === "string" && part.text.length > 0) {
+			const contentIndex = output.content.length;
+			output.content.push({ type: "text", text: "" });
+			stream.push({ type: "text_start", contentIndex, partial: output });
+			const block = output.content[contentIndex];
+			if (block?.type === "text") block.text = part.text;
+			stream.push({
+				type: "text_delta",
+				contentIndex,
+				delta: part.text,
+				partial: output,
+			});
+			stream.push({
+				type: "text_end",
+				contentIndex,
+				content: part.text,
+				partial: output,
+			});
+		}
+
+		if (part.functionCall) {
+			const contentIndex = output.content.length;
+			const toolCall = {
+				type: "toolCall" as const,
+				id: randomUUID(),
+				name: part.functionCall.name ?? "",
+				arguments:
+					part.functionCall.args && typeof part.functionCall.args === "object"
+						? (part.functionCall.args as Record<string, unknown>)
+						: {},
+			};
+			output.content.push(toolCall);
+			stream.push({ type: "toolcall_start", contentIndex, partial: output });
+			stream.push({
+				type: "toolcall_end",
+				contentIndex,
+				toolCall,
+				partial: output,
+			});
+		}
+	}
+}

package/src/stream-foundation.ts

@@ -9,6 +9,7 @@ import type {
 import { foundationExecutableForModel } from "./foundation-executables.ts";
 import { streamSapFoundationAzureOpenAi } from "./stream-foundation-azure-openai.ts";
 import { streamSapFoundationBedrock } from "./stream-foundation-bedrock.ts";
+import { streamSapFoundationVertexAi } from "./stream-foundation-vertexai.ts";
 
 export function streamSapFoundation(
 	model: Model<Api>,
@@ -22,10 +23,6 @@ export function streamSapFoundation(
 		case "aws-bedrock":
 			return streamSapFoundationBedrock(model, context, options);
 		case "gcp-vertexai":
-			throw new Error(
-				`SAP AI Core foundation executable '${executable}' is mapped for '${model.id}', ` +
-					"but the Vertex AI/Gemini foundation adapter has not been implemented yet. " +
-					"Use sap-aicore orchestration for this model until the gcp-vertexai adapter is added.",
-			);
+			return streamSapFoundationVertexAi(model, context, options);
 	}
 }

package/src/translate-foundation-vertexai.ts

@@ -0,0 +1,125 @@
+import type {
+	AssistantMessage,
+	Context,
+	Message,
+	TextContent,
+	ToolResultMessage,
+	UserMessage,
+} from "@earendil-works/pi-ai";
+
+export type VertexPart =
+	| { text: string }
+	| { inlineData: { mimeType: string; data: string } }
+	| { functionCall: { name: string; args: unknown } }
+	| { functionResponse: { name: string; response: Record<string, unknown> } };
+
+export type VertexContent = {
+	role: "user" | "model";
+	parts: VertexPart[];
+};
+
+export function piContextToVertexGenerateContent(context: Context): {
+	systemInstruction?: { parts: Array<{ text: string }> };
+	contents: VertexContent[];
+} {
+	const contents: VertexContent[] = [];
+
+	for (const msg of context.messages) {
+		const translated = piMessageToVertexContent(msg);
+		if (translated) contents.push(translated);
+	}
+
+	return {
+		...(context.systemPrompt
+			? { systemInstruction: { parts: [{ text: context.systemPrompt }] } }
+			: {}),
+		contents: coalesceAdjacentContents(contents),
+	};
+}
+
+function piMessageToVertexContent(msg: Message): VertexContent | undefined {
+	switch (msg.role) {
+		case "user":
+			return piUserToVertexContent(msg);
+		case "assistant":
+			return piAssistantToVertexContent(msg);
+		case "toolResult":
+			return piToolResultToVertexContent(msg);
+	}
+}
+
+function piUserToVertexContent(msg: UserMessage): VertexContent {
+	if (typeof msg.content === "string") {
+		return { role: "user", parts: [{ text: msg.content }] };
+	}
+
+	const parts = msg.content.map((part): VertexPart => {
+		if (part.type === "text") return { text: part.text };
+		return { inlineData: { mimeType: part.mimeType, data: part.data } };
+	});
+
+	return { role: "user", parts: parts.length > 0 ? parts : [{ text: " " }] };
+}
+
+function piAssistantToVertexContent(msg: AssistantMessage): VertexContent {
+	const parts: VertexPart[] = [];
+	for (const block of msg.content) {
+		if (block.type === "text" && block.text) {
+			parts.push({ text: block.text });
+		} else if (block.type === "toolCall") {
+			parts.push({
+				functionCall: { name: block.name, args: block.arguments },
+			});
+		}
+	}
+	return { role: "model", parts: parts.length > 0 ? parts : [{ text: " " }] };
+}
+
+function piToolResultToVertexContent(msg: ToolResultMessage): VertexContent {
+	return {
+		role: "user",
+		parts: [
+			{
+				functionResponse: {
+					name: msg.toolName ?? msg.toolCallId,
+					response: {
+						content: toolResultText(msg) || " ",
+						...(msg.isError ? { error: true } : {}),
+					},
+				},
+			},
+			...toolResultImagesAsUserParts(msg),
+		],
+	};
+}
+
+function toolResultText(msg: ToolResultMessage): string {
+	return msg.content
+		.filter((part): part is TextContent => part.type === "text")
+		.map((part) => part.text)
+		.join("\n");
+}
+
+function toolResultImagesAsUserParts(msg: ToolResultMessage): VertexPart[] {
+	return msg.content
+		.filter(
+			(part): part is { type: "image"; data: string; mimeType: string } =>
+				part.type === "image",
+		)
+		.map((part) => ({
+			inlineData: { mimeType: part.mimeType, data: part.data },
+		}));
+}
+
+function coalesceAdjacentContents(contents: VertexContent[]): VertexContent[] {
+	const result: VertexContent[] = [];
+	for (const content of contents) {
+		const previous = result[result.length - 1];
+		if (previous && previous.role === content.role) {
+			previous.parts.push(...content.parts);
+		} else {
+			result.push({ role: content.role, parts: [...content.parts] });
+		}
+	}
+	return result;
+}