experimental-a2 0.0.0

package/dist/ai-server.js

@@ -0,0 +1,494 @@
+import { t as createServer } from "./server-DYsnKTTy.js";
+import { ToolLoopAgent, createAgentUIStream } from "ai";
+//#region src/ai-server.ts
+/**
+* a2/ai/server — the server-only implementation of an a2/ai definition.
+*
+* `createHandlers()` exposes the ordinary A2 handler table;
+* `createAgentServer()` is its batteries-included assembly with createServer.
+*/
+const resolve = async (value, context) => typeof value === "function" ? await value(context) : value;
+const modelName = (model) => {
+	if (typeof model === "string") return model;
+	if ("modelId" in model && typeof model.modelId === "string") return model.modelId;
+	return "custom";
+};
+const errorMessage = (error) => error instanceof Error ? error.message : String(error);
+const addTokenCounts = (left, right) => left === void 0 && right === void 0 ? void 0 : (left ?? 0) + (right ?? 0);
+const addUsage = (left, right) => {
+	return {
+		inputTokens: addTokenCounts(left?.inputTokens, right.inputTokens),
+		inputTokenDetails: {
+			noCacheTokens: addTokenCounts(left?.inputTokenDetails.noCacheTokens, right.inputTokenDetails.noCacheTokens),
+			cacheReadTokens: addTokenCounts(left?.inputTokenDetails.cacheReadTokens, right.inputTokenDetails.cacheReadTokens),
+			cacheWriteTokens: addTokenCounts(left?.inputTokenDetails.cacheWriteTokens, right.inputTokenDetails.cacheWriteTokens)
+		},
+		outputTokens: addTokenCounts(left?.outputTokens, right.outputTokens),
+		outputTokenDetails: {
+			textTokens: addTokenCounts(left?.outputTokenDetails.textTokens, right.outputTokenDetails.textTokens),
+			reasoningTokens: addTokenCounts(left?.outputTokenDetails.reasoningTokens, right.outputTokenDetails.reasoningTokens)
+		},
+		totalTokens: addTokenCounts(left?.totalTokens, right.totalTokens)
+	};
+};
+const isBoundaryChunk = (chunk) => chunk !== void 0 && (chunk.type === "text-end" || chunk.type === "reasoning-end" || chunk.type === "tool-input-available" || chunk.type === "tool-input-error" || chunk.type === "tool-output-available" || chunk.type === "tool-output-error" || chunk.type === "tool-output-denied" || chunk.type === "tool-approval-request" || chunk.type === "finish" || chunk.type === "abort" || chunk.type === "error");
+const nextOrTimer = async (next, delayMs) => {
+	let timer;
+	try {
+		return await Promise.race([next.then((result) => ({
+			type: "next",
+			result
+		})), new Promise((finishTimer) => {
+			timer = setTimeout(() => finishTimer({ type: "timer" }), delayMs);
+			timer.unref?.();
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+};
+async function generateWithAISDK(context) {
+	const { onStepEnd, onStepFinish, ...settings } = context.generation;
+	const userOnStepEnd = onStepEnd ?? onStepFinish;
+	const agentSettings = {
+		...settings,
+		id: context.generationId,
+		model: context.model,
+		tools: context.tools,
+		...context.instructions === void 0 ? {} : { instructions: context.instructions }
+	};
+	const sdkAgent = new ToolLoopAgent(agentSettings);
+	let usage;
+	let finishReason;
+	return {
+		stream: await createAgentUIStream({
+			agent: sdkAgent,
+			uiMessages: context.messages,
+			generateMessageId: () => context.responseMessageId,
+			abortSignal: context.signal,
+			async onStepEnd(step) {
+				usage = addUsage(usage, step.usage);
+				await userOnStepEnd?.(step);
+			},
+			onEnd(event) {
+				finishReason = event.finishReason;
+			}
+		}),
+		completion: () => ({
+			...finishReason === void 0 ? {} : { finishReason },
+			...usage === void 0 ? {} : { usage }
+		})
+	};
+}
+async function* consumeGeneration(options) {
+	const pending = [];
+	let streamedFinishReason;
+	const maxChunks = options.progress?.maxChunks ?? 16;
+	const maxDelayMs = options.progress?.maxDelayMs ?? 30;
+	let lastFlush = Date.now();
+	const chunks = options.source.stream[Symbol.asyncIterator]();
+	let pendingChunk = chunks.next();
+	try {
+		for (;;) {
+			let result;
+			if (pending.length > 0) {
+				const remaining = Math.max(0, maxDelayMs - (Date.now() - lastFlush));
+				const outcome = await nextOrTimer(pendingChunk, remaining);
+				if (outcome.type === "timer") {
+					yield {
+						type: "progress",
+						chunks: pending.splice(0)
+					};
+					lastFlush = Date.now();
+					continue;
+				}
+				result = outcome.result;
+			} else result = await pendingChunk;
+			if (result.done) break;
+			const chunk = result.value;
+			pending.push(chunk);
+			if (chunk.type === "finish") streamedFinishReason = chunk.finishReason;
+			pendingChunk = chunks.next();
+			if (pending.length >= maxChunks || isBoundaryChunk(pending.at(-1))) {
+				yield {
+					type: "progress",
+					chunks: pending.splice(0)
+				};
+				lastFlush = Date.now();
+			}
+		}
+	} catch (error) {
+		if (pending.length > 0) yield {
+			type: "progress",
+			chunks: pending.splice(0)
+		};
+		throw error;
+	}
+	const completion = options.source.completion?.();
+	if (pending.length > 0) yield {
+		type: "progress",
+		chunks: pending.splice(0)
+	};
+	const finishReason = completion?.finishReason ?? streamedFinishReason;
+	yield {
+		type: "finish",
+		...finishReason === void 0 ? {} : { finishReason },
+		...completion?.usage === void 0 ? {} : { usage: completion.usage }
+	};
+}
+const replay = (definition, history) => {
+	let state = definition.reducer.initialState;
+	for (const event of history) state = definition.reducer.fold(state, event);
+	return state;
+};
+const contextMessages = (state) => {
+	const compaction = state.compaction;
+	if (compaction?.status !== "completed" || !compaction.messages) return state.messages;
+	const boundary = state.messages.findIndex((message) => message.id === compaction.throughMessageId);
+	return boundary === -1 ? state.messages : [...compaction.messages, ...state.messages.slice(boundary + 1)];
+};
+const lifecycleEvents = (options) => {
+	const result = [];
+	for (const [chunkIndex, chunk] of options.chunks.entries()) {
+		const resultId = `${options.generationId}:tool-result:${options.sequence}:${chunkIndex}`;
+		if (chunk.type === "tool-input-available") {
+			const payload = {
+				requestId: options.requestId,
+				messageId: options.messageId,
+				generationId: options.generationId,
+				toolCallId: chunk.toolCallId,
+				toolName: chunk.toolName,
+				input: chunk.input,
+				...chunk.dynamic === void 0 ? {} : { dynamic: chunk.dynamic },
+				...chunk.providerExecuted === void 0 ? {} : { providerExecuted: chunk.providerExecuted },
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata },
+				...chunk.toolMetadata === void 0 ? {} : { toolMetadata: chunk.toolMetadata },
+				...chunk.title === void 0 ? {} : { title: chunk.title }
+			};
+			result.push({
+				type: "ai.tool.called",
+				id: `${options.generationId}:tool:${chunk.toolCallId}:called`,
+				payload
+			});
+		} else if (chunk.type === "tool-input-error") {
+			const payload = {
+				requestId: options.requestId,
+				messageId: options.messageId,
+				generationId: options.generationId,
+				toolCallId: chunk.toolCallId,
+				toolName: chunk.toolName,
+				...chunk.dynamic ? { input: chunk.input } : { rawInput: chunk.input },
+				error: chunk.errorText,
+				phase: "input",
+				...chunk.dynamic === void 0 ? {} : { dynamic: chunk.dynamic },
+				...chunk.providerExecuted === void 0 ? {} : { providerExecuted: chunk.providerExecuted },
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata },
+				...chunk.toolMetadata === void 0 ? {} : { toolMetadata: chunk.toolMetadata }
+			};
+			result.push({
+				type: "ai.tool.result",
+				id: resultId,
+				payload
+			});
+		} else if (chunk.type === "tool-output-available") {
+			const payload = {
+				requestId: options.requestId,
+				messageId: options.messageId,
+				generationId: options.generationId,
+				toolCallId: chunk.toolCallId,
+				output: chunk.output,
+				phase: "execution",
+				...chunk.preliminary === void 0 ? {} : { preliminary: chunk.preliminary },
+				...chunk.dynamic === void 0 ? {} : { dynamic: chunk.dynamic },
+				...chunk.providerExecuted === void 0 ? {} : { providerExecuted: chunk.providerExecuted },
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata },
+				...chunk.toolMetadata === void 0 ? {} : { toolMetadata: chunk.toolMetadata }
+			};
+			result.push({
+				type: "ai.tool.result",
+				id: resultId,
+				payload
+			});
+		} else if (chunk.type === "tool-output-error") {
+			const payload = {
+				requestId: options.requestId,
+				messageId: options.messageId,
+				generationId: options.generationId,
+				toolCallId: chunk.toolCallId,
+				error: chunk.errorText,
+				phase: "execution",
+				...chunk.dynamic === void 0 ? {} : { dynamic: chunk.dynamic },
+				...chunk.providerExecuted === void 0 ? {} : { providerExecuted: chunk.providerExecuted },
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata },
+				...chunk.toolMetadata === void 0 ? {} : { toolMetadata: chunk.toolMetadata }
+			};
+			result.push({
+				type: "ai.tool.result",
+				id: resultId,
+				payload
+			});
+		} else if (chunk.type === "tool-output-denied") {
+			const payload = {
+				requestId: options.requestId,
+				messageId: options.messageId,
+				generationId: options.generationId,
+				toolCallId: chunk.toolCallId,
+				denied: true,
+				phase: "execution"
+			};
+			result.push({
+				type: "ai.tool.result",
+				id: resultId,
+				payload
+			});
+		} else if (chunk.type === "tool-approval-request") {
+			const payload = {
+				messageId: options.messageId,
+				generationId: options.generationId,
+				approvalId: chunk.approvalId,
+				toolCallId: chunk.toolCallId,
+				...chunk.isAutomatic === void 0 ? {} : { isAutomatic: chunk.isAutomatic },
+				...chunk.signature === void 0 ? {} : { signature: chunk.signature }
+			};
+			result.push({
+				type: "ai.approval.requested",
+				id: `${options.generationId}:approval:${chunk.approvalId}`,
+				payload
+			});
+		}
+	}
+	return result;
+};
+/**
+* Build the ordinary A2 handler table for the built-in agent protocol.
+* Application handlers can be spread beside this table.
+*/
+function createHandlers(options) {
+	if (options.model === void 0) throw new TypeError("createHandlers requires model");
+	if (options.progress?.maxChunks !== void 0 && (!Number.isInteger(options.progress.maxChunks) || options.progress.maxChunks < 1)) throw new TypeError("progress.maxChunks must be a positive integer");
+	if (options.progress?.maxDelayMs !== void 0 && (!Number.isFinite(options.progress.maxDelayMs) || options.progress.maxDelayMs < 0)) throw new TypeError("progress.maxDelayMs must be a non-negative number");
+	const generationHandler = async (ctx) => {
+		const history = await ctx.history();
+		const requestId = ctx.event.id;
+		const request = ctx.event.payload;
+		if (history.some((event) => event.type === "ai.session.closed")) return;
+		if (history.some((event) => {
+			if (event.type === "ai.generation.completed") return event.payload.requestId === requestId;
+			if (event.type !== "ai.generation.failed") return false;
+			const payload = event.payload;
+			return payload.requestId === requestId && payload.superseded !== true;
+		})) return;
+		const previousStarts = history.filter((event) => event.type === "ai.generation.started" && event.payload.requestId === requestId);
+		const attempt = previousStarts.length + 1;
+		const generationId = `${requestId}:generation:${attempt}`;
+		const responseMessageId = request.responseMessageId ?? (request.reason === "message" ? `${request.messageId}:assistant` : request.messageId);
+		const previous = previousStarts.at(-1);
+		const incompleteId = previous ? previous.payload.generationId : void 0;
+		const promptHistory = incompleteId === void 0 && request.reason !== "retry" ? history : history.filter((event) => !(event.type === "ai.generation.progress" && (incompleteId !== void 0 && event.payload.generationId === incompleteId || request.reason === "retry" && event.payload.responseMessageId === responseMessageId)));
+		let state = replay(options.agent, promptHistory);
+		const resolverContext = {
+			event: ctx.event,
+			state,
+			history,
+			signal: ctx.signal
+		};
+		const resolvedModel = await resolve(options.model, resolverContext);
+		if (resolvedModel === void 0) throw new TypeError("the model resolver returned undefined");
+		const started = {
+			requestId,
+			messageId: request.messageId,
+			generationId,
+			responseMessageId,
+			attempt,
+			model: modelName(resolvedModel)
+		};
+		const startEvents = [];
+		if (previous) {
+			const payload = previous.payload;
+			const superseded = {
+				requestId,
+				messageId: payload.messageId,
+				generationId: payload.generationId,
+				responseMessageId: payload.responseMessageId,
+				error: "generation attempt was superseded after an incomplete run",
+				superseded: true
+			};
+			startEvents.push({
+				type: "ai.generation.failed",
+				id: `${payload.generationId}:superseded`,
+				payload: superseded
+			});
+		}
+		startEvents.push({
+			type: "ai.generation.started",
+			id: generationId,
+			payload: started
+		});
+		await ctx.append(...startEvents);
+		let messages = contextMessages(state);
+		if (options.compaction) {
+			const compactionContext = {
+				...resolverContext,
+				messages
+			};
+			if (await options.compaction.shouldCompact(compactionContext)) {
+				const throughMessageId = messages.at(-1)?.id ?? request.messageId;
+				await ctx.append({
+					type: "ai.compaction.requested",
+					id: `${generationId}:compaction:requested`,
+					payload: {
+						generationId,
+						throughMessageId
+					}
+				});
+				messages = await options.compaction.compact(compactionContext);
+				const completed = {
+					generationId,
+					throughMessageId,
+					messages
+				};
+				await ctx.append({
+					type: "ai.compaction.completed",
+					id: `${generationId}:compaction:completed`,
+					payload: completed
+				});
+				state = {
+					...state,
+					compaction: {
+						status: "completed",
+						...completed
+					}
+				};
+			}
+		}
+		try {
+			const resolvedInstructions = options.instructions === void 0 ? void 0 : await resolve(options.instructions, resolverContext);
+			const generateContext = {
+				request: ctx.event,
+				requestId,
+				generationId,
+				responseMessageId,
+				messages,
+				state,
+				history,
+				signal: ctx.signal,
+				model: resolvedModel,
+				tools: options.tools ?? {},
+				...resolvedInstructions === void 0 ? {} : { instructions: resolvedInstructions },
+				generation: options.generation ?? {}
+			};
+			const updates = consumeGeneration({
+				source: options.generate === void 0 ? await generateWithAISDK(generateContext) : { stream: await options.generate(generateContext) },
+				...options.progress === void 0 ? {} : { progress: options.progress }
+			});
+			let sequence = 0;
+			let finish;
+			for await (const update of updates) {
+				ctx.signal.throwIfAborted();
+				if (update.type === "finish") {
+					finish = update;
+					continue;
+				}
+				const progress = {
+					requestId,
+					messageId: request.messageId,
+					generationId,
+					responseMessageId,
+					sequence,
+					chunks: update.chunks
+				};
+				const extras = lifecycleEvents({
+					requestId,
+					messageId: responseMessageId,
+					generationId,
+					sequence,
+					chunks: update.chunks
+				});
+				await ctx.append({
+					type: "ai.generation.progress",
+					id: `${generationId}:progress:${sequence}`,
+					payload: progress
+				}, ...extras);
+				sequence += 1;
+			}
+			if (!finish) throw new Error("agent generation finished without output");
+			const completed = {
+				requestId,
+				messageId: request.messageId,
+				generationId,
+				responseMessageId,
+				...finish.finishReason === void 0 ? {} : { finishReason: finish.finishReason },
+				...finish.usage === void 0 ? {} : { usage: finish.usage }
+			};
+			const messageCompleted = { messageId: responseMessageId };
+			await ctx.append({
+				type: "ai.generation.completed",
+				id: `${generationId}:completed`,
+				payload: completed
+			}, {
+				type: "ai.message.completed",
+				id: `${generationId}:message:completed`,
+				payload: messageCompleted
+			});
+		} catch (error) {
+			if (ctx.signal.aborted) {
+				const interrupted = {
+					messageId: responseMessageId,
+					generationId,
+					reason: "aborted"
+				};
+				await ctx.append({
+					type: "ai.message.interrupted",
+					id: `${generationId}:interrupted`,
+					payload: interrupted
+				});
+				return;
+			}
+			const failed = {
+				requestId,
+				messageId: request.messageId,
+				generationId,
+				responseMessageId,
+				error: errorMessage(error)
+			};
+			await ctx.append({
+				type: "ai.generation.failed",
+				id: `${generationId}:failed`,
+				payload: failed
+			});
+		}
+	};
+	return { "ai.generation.requested": {
+		abortOn: {
+			"ai.message.interrupted": (event, trigger) => {
+				const responseMessageId = trigger.payload.responseMessageId ?? (trigger.payload.reason === "message" ? `${trigger.payload.messageId}:assistant` : trigger.payload.messageId);
+				return event.payload.messageId === responseMessageId;
+			},
+			"ai.session.closed": true
+		},
+		handler: generationHandler
+	} };
+}
+/** Assemble an A2 server with the built-in agent handlers and app extensions. */
+function createAgentServer(options) {
+	const { agent: definition, model, tools, instructions, generation, generate, compaction, progress, handlers, ...serverOptions } = options;
+	const builtIns = createHandlers({
+		agent: definition,
+		model,
+		...tools === void 0 ? {} : { tools },
+		...instructions === void 0 ? {} : { instructions },
+		...generation === void 0 ? {} : { generation },
+		...generate === void 0 ? {} : { generate },
+		...compaction === void 0 ? {} : { compaction },
+		...progress === void 0 ? {} : { progress }
+	});
+	return createServer({
+		...serverOptions,
+		contract: definition.contract,
+		handlers: {
+			...builtIns,
+			...handlers
+		}
+	});
+}
+//#endregion
+export { createAgentServer, createHandlers };