@prometheus-ai/ai 0.5.3 → 0.5.8

package/src/providers/anthropic-messages-server.ts

@@ -25,12 +25,12 @@ import {
 } from "./anthropic-messages-server-schema";
 
 /**
- * Anthropic Messages API (https://docs.anthropic.com/en/api/messages) ↔ @prometheus-ai/ai
+ * Anthropic Messages API (https://docs.anthropic.com/en/api/messages) ↔ Prometheus AI
  * gateway translation. Inbound: foreign HTTP body → prometheus Context. Outbound:
  * prometheus AssistantMessage[Stream] → Anthropic-shaped JSON / SSE.
  */
 
-import type { AuthGatewayParsedRequest as ParsedRequest } from "../auth-gateway/types";
+import type { AuthGatewayStreamControl, AuthGatewayParsedRequest as ParsedRequest } from "../auth-gateway/types";
 
 export type { ParsedRequest };
 
@@ -53,7 +53,7 @@ function warnUnknownBlockType(category: "user" | "assistant", blockType: string)
 	});
 }
 
-// Canonical `ImageContent` only carries base64 + mimeType. When the inbound
+// Prometheus AI's `ImageContent` only carries base64 + mimeType. When the inbound
 // uses `url` or `file_id` sources we surface a text placeholder so the
 // downstream provider still sees a sane history; warn once per source kind.
 const WARNED_NON_BASE64_IMAGE_SOURCES = new Set<string>();
@@ -61,8 +61,10 @@ function warnNonBase64ImageSource(sourceType: string): void {
 	if (WARNED_NON_BASE64_IMAGE_SOURCES.has(sourceType)) return;
 	WARNED_NON_BASE64_IMAGE_SOURCES.add(sourceType);
 	logger.warn(
-		"anthropic-messages: image source surfaced as text placeholder (canonical ImageContent lacks URL channel)",
-		{ sourceType },
+		"anthropic-messages: image source surfaced as text placeholder (Prometheus AI ImageContent lacks URL channel)",
+		{
+			sourceType,
+		},
 	);
 }
 
@@ -151,7 +153,7 @@ function walkUserContent(
 			}
 		} else if (block.type === "tool_result") {
 			// Anthropic permits tool_result blocks to follow plain text/image
-			// siblings in the same user message. @prometheus-ai/ai's history is a flat
+			// siblings in the same user message. Prometheus AI's history is a flat
 			// sequence of typed messages, so flush the accumulated parts as a
 			// separate UserMessage before emitting the ToolResultMessage.
 			flush();
@@ -255,7 +257,7 @@ function readCacheControl(value: unknown): AnthropicCacheControl | undefined {
 
 /**
  * Anthropic clients annotate caching breakpoints per block via
- * `cache_control: { type: "ephemeral", ttl?: "1h"|"5m" }`. @prometheus-ai/ai's
+ * `cache_control: { type: "ephemeral", ttl?: "1h"|"5m" }`. Prometheus AI's
  * `cacheRetention` is per-request, not per-block, and its anthropic provider
  * re-applies breakpoints itself on the rebuilt outbound wire. Scan every
  * block once and return the strongest retention requested: any `ttl: "1h"`
@@ -324,7 +326,7 @@ export function parseRequest(body: unknown, headers?: Headers): ParsedRequest {
 	const toolChoice = mapToolChoice(data.tool_choice as AnthropicToolChoice | undefined);
 	if (toolChoice !== undefined) options.toolChoice = toolChoice;
 	// `disable_parallel_tool_use === true` means the client wants the model to
-	// emit at most one tool call per turn; map to @prometheus-ai/ai's negated boolean.
+	// emit at most one tool call per turn; map to Prometheus AI's negated boolean.
 	// Leave undefined when the field is absent or explicitly `false` so we
 	// don't override provider defaults.
 	if (data.tool_choice?.disable_parallel_tool_use === true) {
@@ -464,7 +466,7 @@ export function encodeResponse(message: AssistantMessage, requestedModelId: stri
 		model: requestedModelId,
 		content: encodeContentBlocks(message),
 		stop_reason: mapStopReasonOut(message.stopReason),
-		// TODO: surface the matched stop sequence once @prometheus-ai/ai's
+		// TODO: surface the matched stop sequence once Prometheus AI's
 		// `AssistantMessage.stopReason` carries the matched string. Intentionally
 		// `null` for now (Anthropic schema allows it).
 		stop_sequence: null,
@@ -489,17 +491,44 @@ interface OpenBlock {
 	kind: BlockKind;
 }
 
+// Keepalive cadence for the SSE encoder. Anthropic's API pings periodically;
+// without frames between message_start and the first content block (slow first
+// token) SDK first-event/idle watchdogs classify the stream as stalled.
+const STREAM_PING_INTERVAL_MS = 15_000;
+
+const ZERO_WIRE_USAGE: Record<string, unknown> = {
+	input_tokens: 0,
+	output_tokens: 0,
+	cache_read_input_tokens: 0,
+	cache_creation_input_tokens: 0,
+};
+
 export function encodeStream(
 	events: AssistantMessageEventStream,
 	requestedModelId: string,
+	_options?: ParsedRequest["options"],
+	control?: AuthGatewayStreamControl,
 ): ReadableStream<Uint8Array> {
+	let pingTimer: NodeJS.Timeout | undefined;
+	let cancelled = control?.signal?.aborted === true;
+	const markCancelled = () => {
+		cancelled = true;
+	};
+	control?.signal?.addEventListener("abort", markCancelled, { once: true });
+	const stopPings = () => {
+		if (pingTimer !== undefined) {
+			clearInterval(pingTimer);
+			pingTimer = undefined;
+		}
+	};
 	return new ReadableStream<Uint8Array>({
 		async start(controller) {
 			const messageId = newMessageId();
 			let started = false;
+			let lastPartial: AssistantMessage | undefined;
 			const open = new Map<number, OpenBlock>();
 
-			const ensureStart = (partial: AssistantMessage) => {
+			const ensureStart = (partial: AssistantMessage | undefined) => {
 				if (started) return;
 				started = true;
 				controller.enqueue(
@@ -513,9 +542,9 @@ export function encodeStream(
 							content: [],
 							stop_reason: null,
 							// TODO: same as encodeResponse — surface matched stop sequence
-							// once @prometheus-ai/ai propagates it.
+							// once Prometheus AI propagates it.
 							stop_sequence: null,
-							usage: encodeUsage(partial),
+							usage: partial ? encodeUsage(partial) : ZERO_WIRE_USAGE,
 						},
 					}),
 				);
@@ -527,8 +556,26 @@ export function encodeStream(
 				open.delete(index);
 			};
 
+			pingTimer = setInterval(() => {
+				try {
+					if (cancelled) {
+						stopPings();
+						return;
+					}
+					controller.enqueue(sseFrame("ping", { type: "ping" }));
+				} catch {
+					// Controller already closed/errored (client gone); stop the timer.
+					stopPings();
+				}
+			}, STREAM_PING_INTERVAL_MS);
+
 			try {
+				if (cancelled) {
+					controller.close();
+					return;
+				}
 				for await (const ev of events) {
+					if (cancelled) return;
 					switch (ev.type) {
 						case "start":
 							ensureStart(ev.partial);
@@ -627,7 +674,7 @@ export function encodeStream(
 							controller.enqueue(
 								sseFrame("message_delta", {
 									type: "message_delta",
-									// TODO: surface matched stop sequence once @prometheus-ai/ai
+									// TODO: surface matched stop sequence once Prometheus AI
 									// propagates it on the `done` event.
 									delta: { stop_reason: mapStopReasonOut(ev.reason), stop_sequence: null },
 									usage: encodeUsage(ev.message),
@@ -647,20 +694,41 @@ export function encodeStream(
 						}
 					}
 				}
-				// stream ended without explicit done; close gracefully
+				// Stream ended without an explicit done: emit a complete envelope
+				// (message_start + message_delta carrying a stop_reason) so strict
+				// clients don't reject the response as a protocol error.
+				ensureStart(lastPartial);
 				for (const idx of [...open.keys()]) closeBlock(idx);
-				controller.enqueue(sseFrame("message_stop", { type: "message_stop" }));
-				controller.close();
-			} catch (err) {
 				controller.enqueue(
-					sseFrame("error", {
-						type: "error",
-						error: { type: "api_error", message: err instanceof Error ? err.message : String(err) },
+					sseFrame("message_delta", {
+						type: "message_delta",
+						delta: { stop_reason: "end_turn", stop_sequence: null },
+						usage: lastPartial ? encodeUsage(lastPartial) : ZERO_WIRE_USAGE,
 					}),
 				);
+				controller.enqueue(sseFrame("message_stop", { type: "message_stop" }));
 				controller.close();
+			} catch (err) {
+				if (!cancelled) {
+					controller.enqueue(
+						sseFrame("error", {
+							type: "error",
+							error: { type: "api_error", message: err instanceof Error ? err.message : String(err) },
+						}),
+					);
+					controller.close();
+				}
+			} finally {
+				control?.signal?.removeEventListener("abort", markCancelled);
+				stopPings();
 			}
 		},
+		cancel(reason) {
+			cancelled = true;
+			control?.signal?.removeEventListener("abort", markCancelled);
+			control?.onCancel?.(reason);
+			stopPings();
+		},
 	});
 }
 

package/src/providers/anthropic-wire.ts

@@ -1,12 +1,12 @@
 /**
  * Anthropic Messages API wire types.
  *
- * Hand-maintained against https://docs.anthropic.com/en/api/messages so @prometheus-ai/ai
+ * Hand-maintained against https://docs.anthropic.com/en/api/messages so Prometheus AI
  * does not depend on `@anthropic-ai/sdk` for type information. Only the shapes
  * this package actually reads or writes are modeled; fields we never touch are
  * intentionally omitted. Names mirror the SDK so call sites read the same.
  *
- * Unlike the SDK, beta fields @prometheus-ai/ai uses (`speed`, `context_management`,
+ * Unlike the SDK, beta fields Prometheus AI uses (`speed`, `context_management`,
  * `output_config.effort`/`task_budget`, `thinking.display`, cache-control
  * `scope`, tool `strict`/`eager_input_streaming`, mid-conversation `system`
  * role) are first-class here instead of being patched in via casts.
@@ -188,7 +188,8 @@ export type StopReason =
 	| "tool_use"
 	| "pause_turn"
 	| "refusal"
-	| "sensitive";
+	| "sensitive"
+	| "model_context_window_exceeded";
 
 export type CacheCreation = {
 	ephemeral_5m_input_tokens?: number | null;