@f5-sales-demo/pi-ai 19.90.1 → 19.91.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/pi-ai",
-	"version": "19.90.1",
+	"version": "19.91.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -41,11 +41,11 @@
 		"generate-models": "bun scripts/generate-models.ts"
 	},
 	"dependencies": {
-		"@anthropic-ai/sdk": "^0.78",
+		"@anthropic-ai/sdk": "^0.115",
 		"@aws-sdk/client-bedrock-runtime": "^3",
 		"@bufbuild/protobuf": "^2.11",
-		"@google/genai": "^1.43",
-		"@f5-sales-demo/pi-utils": "19.90.1",
+		"@google/genai": "^2.13",
+		"@f5-sales-demo/pi-utils": "19.91.0",
 		"@sinclair/typebox": "^0.34",
 		"@smithy/node-http-handler": "^4.4",
 		"ajv": "^8.20",

package/src/providers/anthropic.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import * as tls from "node:tls";
 import Anthropic, { type ClientOptions as AnthropicSdkClientOptions } from "@anthropic-ai/sdk";
 import type {
+	CitationsDelta,
 	ContentBlockParam,
 	MessageCreateParamsStreaming,
 	MessageParam,
@@ -30,6 +31,7 @@ import type {
 	ToolCall,
 	ToolResultMessage,
 	Usage,
+	WebCitation,
 } from "../types";
 import { isAnthropicOAuthToken, normalizeToolCallId, resolveCacheRetention } from "../utils";
 import { createAbortSourceTracker } from "../utils/abort";
@@ -629,6 +631,24 @@ export function isProviderRetryableError(error: unknown): boolean {
 	);
 }
 
+/**
+ * Map an Anthropic `citations_delta` citation to a `WebCitation`.
+ *
+ * Only web-search citations are carried: the char/page/content-block locations belong to the
+ * document-citations API, which cites user-supplied documents rather than search results and has
+ * no source URL to render as a chip.
+ */
+function mapAnthropicWebCitation(citation: CitationsDelta["citation"]): WebCitation | undefined {
+	if (citation.type !== "web_search_result_location") return undefined;
+	return {
+		type: "web_search_result_location",
+		url: citation.url,
+		...(citation.title ? { title: citation.title } : {}),
+		...(citation.cited_text ? { citedText: citation.cited_text } : {}),
+		...(citation.encrypted_index ? { encryptedIndex: citation.encrypted_index } : {}),
+	};
+}
+
 function createEmptyUsage(premiumRequests?: number): Usage {
 	return {
 		input: 0,
@@ -737,6 +757,19 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				const anthropicRequest = client.messages.create({ ...params, stream: true }, { signal: requestSignal });
 				let streamedReplayUnsafeContent = false;
 
+				// SERVER-SIDE tools (Anthropic's built-in web search) are executed by the provider,
+				// so their blocks are deliberately NOT pushed into `output.content`: there is nothing
+				// for the agent loop to dispatch, and keeping their `encrypted_content` out of history
+				// avoids the byte-exact echo requirement that would 400 a follow-up turn. They are
+				// tracked here only long enough to report progress — keyed by the stream's block index
+				// (to accumulate the query) and by tool id (to name the matching result block).
+				// Declared inside the retry loop so a replayed attempt starts clean.
+				const serverToolUses = new Map<
+					number,
+					{ id: string; name: string; partialJson: string; inlineInput: unknown }
+				>();
+				const serverToolNames = new Map<string, string>();
+
 				try {
 					const { data: anthropicStream } = await anthropicRequest.withResponse();
 					const firstEventWatchdog = createFirstEventWatchdog(firstEventTimeoutMs, () =>
@@ -825,6 +858,30 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 									contentIndex: output.content.length - 1,
 									partial: output,
 								});
+							} else if (event.content_block.type === "server_tool_use") {
+								// Progress-only: remember the call so its query can be reported once the
+								// input JSON has finished streaming (see content_block_stop).
+								serverToolUses.set(event.index, {
+									id: event.content_block.id,
+									name: event.content_block.name,
+									partialJson: "",
+									// Nothing obliges the provider to stream the input as deltas — it may
+									// arrive whole right here. Kept as the fallback for the query.
+									inlineInput: event.content_block.input,
+								});
+								serverToolNames.set(event.content_block.id, event.content_block.name);
+							} else if (event.content_block.type === "web_search_tool_result") {
+								const toolId = event.content_block.tool_use_id;
+								const content = event.content_block.content;
+								stream.push({
+									type: "server_tool_end",
+									toolName: serverToolNames.get(toolId) ?? "web_search",
+									toolId,
+									...(Array.isArray(content)
+										? { resultCount: content.length }
+										: { errorCode: content.error_code }),
+									partial: output,
+								});
 							}
 						} else if (event.type === "content_block_delta") {
 							if (event.delta.type === "text_delta") {
@@ -852,17 +909,31 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 									});
 								}
 							} else if (event.delta.type === "input_json_delta") {
+								const serverToolUse = serverToolUses.get(event.index);
+								if (serverToolUse) {
+									// A server-side tool's input (the search query). Accumulated but not
+									// streamed as a toolcall_delta — there is no toolCall block to attach to.
+									serverToolUse.partialJson += event.delta.partial_json;
+								} else {
+									const index = blocks.findIndex(b => b.index === event.index);
+									const block = blocks[index];
+									if (block && block.type === "toolCall") {
+										block.partialJson += event.delta.partial_json;
+										block.arguments = parseStreamingJson(block.partialJson);
+										stream.push({
+											type: "toolcall_delta",
+											contentIndex: index,
+											delta: event.delta.partial_json,
+											partial: output,
+										});
+									}
+								}
+							} else if (event.delta.type === "citations_delta") {
 								const index = blocks.findIndex(b => b.index === event.index);
 								const block = blocks[index];
-								if (block && block.type === "toolCall") {
-									block.partialJson += event.delta.partial_json;
-									block.arguments = parseStreamingJson(block.partialJson);
-									stream.push({
-										type: "toolcall_delta",
-										contentIndex: index,
-										delta: event.delta.partial_json,
-										partial: output,
-									});
+								const citation = mapAnthropicWebCitation(event.delta.citation);
+								if (block && block.type === "text" && citation) {
+									block.citations = [...(block.citations ?? []), citation];
 								}
 							} else if (event.delta.type === "signature_delta") {
 								const index = blocks.findIndex(b => b.index === event.index);
@@ -873,6 +944,28 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 								}
 							}
 						} else if (event.type === "content_block_stop") {
+							const serverToolUse = serverToolUses.get(event.index);
+							if (serverToolUse) {
+								// The query has finished streaming, so the activity row can name what is
+								// being searched for. Reported here rather than at content_block_start
+								// because that is the first moment the query is known — and it still lands
+								// well before the provider's search completes.
+								serverToolUses.delete(event.index);
+								const streamed = parseStreamingJson(serverToolUse.partialJson) as
+									| { query?: unknown }
+									| undefined;
+								const inline = serverToolUse.inlineInput as { query?: unknown } | undefined;
+								const rawQuery = typeof streamed?.query === "string" ? streamed.query : inline?.query;
+								const query = typeof rawQuery === "string" && rawQuery.length > 0 ? rawQuery : undefined;
+								stream.push({
+									type: "server_tool_start",
+									toolName: serverToolUse.name,
+									toolId: serverToolUse.id,
+									...(query === undefined ? {} : { query }),
+									partial: output,
+								});
+								continue;
+							}
 							const index = blocks.findIndex(b => b.index === event.index);
 							const block = blocks[index];
 							if (block) {
@@ -1426,16 +1519,10 @@ function buildParams(
 		const effort =
 			options.effort ?? (requestedEffort ? mapEffortToAnthropicAdaptiveEffort(model, requestedEffort) : undefined);
 
-		// The pinned @anthropic-ai/sdk (0.78) types `OutputConfig.effort` as
-		// 'low'|'medium'|'high'|'max' — it predates `xhigh`, which the live API
-		// accepts (verified: its 400 enumerates "'low', 'medium', 'high', 'xhigh'
-		// or 'max'"). Cast until the SDK pin is bumped; the wire value is valid.
-		const outputConfigEffort = effort as NonNullable<MessageCreateParamsStreaming["output_config"]>["effort"];
-
 		if (mode === "anthropic-adaptive") {
 			params.thinking = { type: "adaptive" };
 			if (effort) {
-				params.output_config = { effort: outputConfigEffort };
+				params.output_config = { effort };
 			}
 		} else {
 			params.thinking = {
@@ -1443,7 +1530,7 @@ function buildParams(
 				budget_tokens: options.thinkingBudgetTokens || 1024,
 			};
 			if (mode === "anthropic-budget-effort" && effort) {
-				params.output_config = { effort: outputConfigEffort };
+				params.output_config = { effort };
 			}
 		}
 		// Anthropic requires temperature=1 when thinking is enabled; override any

package/src/types.ts

@@ -252,10 +252,33 @@ export interface TextSignatureV1 {
 	phase?: "commentary" | "final_answer";
 }
 
+/**
+ * A structured citation annotating a span of assistant text, produced by a provider's
+ * SERVER-SIDE search tool (Anthropic `citations_delta` → `web_search_result_location`).
+ *
+ * Carries the source title/url so hosts can render precise "Sources" chips instead of
+ * regex-scraping URLs out of the prose.
+ */
+export interface WebCitation {
+	type: "web_search_result_location";
+	url: string;
+	title?: string;
+	/** The span of source material the assistant drew on. */
+	citedText?: string;
+	/**
+	 * Opaque provider index for the cited result. Retained for fidelity only — it is never
+	 * re-sent, because echoing a provider's encrypted citation fields back on a later turn
+	 * must be byte-exact or the request is rejected.
+	 */
+	encryptedIndex?: string;
+}
+
 export interface TextContent {
 	type: "text";
 	text: string;
 	textSignature?: string; // e.g., for OpenAI responses, message metadata (legacy id string or TextSignatureV1 JSON)
+	/** Structured citations for this span, when the provider ran a server-side search. */
+	citations?: WebCitation[];
 }
 
 export interface ThinkingContent {
@@ -429,6 +452,32 @@ export type AssistantMessageEvent =
 	| { type: "toolcall_start"; contentIndex: number; partial: AssistantMessage }
 	| { type: "toolcall_delta"; contentIndex: number; delta: string; partial: AssistantMessage }
 	| { type: "toolcall_end"; contentIndex: number; toolCall: ToolCall; partial: AssistantMessage }
+	/**
+	 * A provider-SIDE tool (e.g. Anthropic's built-in web search) started running.
+	 *
+	 * Purely a progress signal so hosts can show a live activity row — the provider executes
+	 * these itself, so unlike `toolcall_*` there is nothing for the agent loop to dispatch and
+	 * no content block is added to the message.
+	 */
+	| {
+			type: "server_tool_start";
+			contentIndex?: undefined;
+			toolName: string;
+			toolId: string;
+			/** The search query, when the provider streamed one. */
+			query?: string;
+			partial: AssistantMessage;
+	  }
+	/** A provider-side tool finished: either it returned results, or it failed. */
+	| {
+			type: "server_tool_end";
+			contentIndex?: undefined;
+			toolName: string;
+			toolId: string;
+			resultCount?: number;
+			errorCode?: string;
+			partial: AssistantMessage;
+	  }
 	| {
 			type: "done";
 			contentIndex?: undefined;