@agentloop/core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1152 @@
+//#region src/content.ts
+/** Create a {@link TextPart}. */
+function text(value) {
+	return {
+		type: "text",
+		text: value
+	};
+}
+/** Create a {@link JsonPart}. */
+function json(value) {
+	return {
+		type: "json",
+		json: value
+	};
+}
+/** Create a {@link BlobPart}. */
+function blob(data, mediaType) {
+	return {
+		type: "blob",
+		data,
+		mediaType
+	};
+}
+/** Create a {@link URLPart}. */
+function url(value, mediaType) {
+	return {
+		type: "url",
+		url: value,
+		...mediaType != null && { mediaType }
+	};
+}
+//#endregion
+//#region src/message.ts
+/** Create a {@link SystemMessage}. Accepts a string or content array. */
+function system(content) {
+	return {
+		role: "system",
+		content: typeof content === "string" ? [text(content)] : content
+	};
+}
+/** Create a {@link UserMessage}. Accepts a string or content array. */
+function user(content) {
+	return {
+		role: "user",
+		content: typeof content === "string" ? [text(content)] : content
+	};
+}
+/** Create an {@link AssistantMessage}. Accepts a string or content array. */
+function assistant(content) {
+	return {
+		role: "assistant",
+		content: typeof content === "string" ? [text(content)] : content
+	};
+}
+/** Normalize a {@link Prompt} into a {@link Message} array. */
+function normalizePrompt(prompt) {
+	if (typeof prompt === "string") return [user(prompt)];
+	if (Array.isArray(prompt)) return prompt;
+	return [prompt];
+}
+//#endregion
+//#region src/schema.ts
+/**
+* Extract a JSON Schema object from a
+* [Standard Schema v1](https://github.com/standard-schema/standard-schema)
+* compatible validator.
+*
+* Throws if the schema does not expose `~standard.jsonSchema.input()`.
+*/
+function schemaToJsonSchema(schema) {
+	const ss = schema?.["~standard"];
+	if (ss?.jsonSchema?.input) return ss.jsonSchema.input();
+	throw new Error("Cannot convert schema to JSON Schema. Provide a Standard Schema v1-compatible validator.");
+}
+//#endregion
+//#region src/model.ts
+/** Create an empty {@link Usage}. */
+function emptyUsage() {
+	return {
+		inputTokens: 0,
+		outputTokens: 0,
+		totalTokens: 0
+	};
+}
+/** Add two {@link Usage} objects together. */
+function addUsage(a, b) {
+	return {
+		inputTokens: a.inputTokens + b.inputTokens,
+		outputTokens: a.outputTokens + b.outputTokens,
+		totalTokens: a.totalTokens + b.totalTokens,
+		cacheReadTokens: (a.cacheReadTokens ?? 0) + (b.cacheReadTokens ?? 0) || void 0,
+		cacheWriteTokens: (a.cacheWriteTokens ?? 0) + (b.cacheWriteTokens ?? 0) || void 0
+	};
+}
+//#endregion
+//#region src/tool.ts
+/** Create a type-safe {@link Tool}. Schema infers the argument type. */
+function defineTool(config) {
+	return config;
+}
+/** Normalize a {@link ToolReturn} into a {@link Content} array. */
+function normalizeToolReturn(value) {
+	if (typeof value === "string") return [text(value)];
+	if (Array.isArray(value)) return value;
+	return [json(value)];
+}
+//#endregion
+//#region src/policy.ts
+/** Create a {@link Policy}. */
+function definePolicy(config) {
+	return config;
+}
+//#endregion
+//#region src/observer.ts
+/** Create an {@link Observer}. */
+function defineObserver(config) {
+	return config;
+}
+//#endregion
+//#region src/channel.ts
+/** Create an {@link EventChannel}. */
+function createEventChannel() {
+	const buffer = [];
+	let closed = false;
+	let waiter = null;
+	let resolveResult;
+	let rejectResult;
+	const result = new Promise((resolve, reject) => {
+		resolveResult = resolve;
+		rejectResult = reject;
+	});
+	function releaseWaiter() {
+		if (waiter !== null) {
+			const resolve = waiter;
+			waiter = null;
+			resolve({
+				value: void 0,
+				done: true
+			});
+		}
+	}
+	function push(value) {
+		if (closed) return;
+		if (waiter !== null) {
+			const resolve = waiter;
+			waiter = null;
+			resolve({
+				value,
+				done: false
+			});
+		} else buffer.push(value);
+	}
+	function close(value) {
+		if (closed) return;
+		closed = true;
+		resolveResult(value);
+		releaseWaiter();
+	}
+	function fail(error) {
+		if (closed) return;
+		closed = true;
+		rejectResult(error);
+		releaseWaiter();
+	}
+	return {
+		push,
+		close,
+		fail,
+		stream: { [Symbol.asyncIterator]() {
+			return {
+				next() {
+					if (buffer.length > 0) return Promise.resolve({
+						value: buffer.shift(),
+						done: false
+					});
+					if (closed) return Promise.resolve({
+						value: void 0,
+						done: true
+					});
+					return new Promise((resolve) => {
+						waiter = resolve;
+					});
+				},
+				return() {
+					releaseWaiter();
+					return Promise.resolve({
+						value: void 0,
+						done: true
+					});
+				}
+			};
+		} },
+		result
+	};
+}
+//#endregion
+//#region src/emit.ts
+/**
+* Create an {@link EmitFn} that delivers events to observers and optionally
+* pushes them into an external consumer (e.g. an {@link EventChannel}).
+*
+* Observer handlers are invoked synchronously; async rejections are caught.
+* No observer can block or crash the agent loop.
+*/
+function createEmitFn(observers, push) {
+	return (event) => {
+		if (push !== void 0) push(event);
+		notifyObservers(observers, event, push);
+	};
+}
+/** Dispatch an event to all observers, reporting observer failures to the others. */
+function notifyObservers(observers, event, push) {
+	const isObserverError = event.type === "error" && event.source === "observer";
+	for (const observer of observers) invokeObserver(observer, event, (err) => {
+		if (isObserverError) return;
+		const errorEvent = {
+			type: "error",
+			runId: event.runId,
+			step: event.step,
+			agent: event.agent,
+			timestamp: Date.now(),
+			error: err instanceof Error ? err : new Error(String(err)),
+			source: "observer",
+			observer: observer.name
+		};
+		if (push !== void 0) push(errorEvent);
+		for (const other of observers) if (other !== observer) invokeObserver(other, errorEvent, () => {});
+	});
+}
+/** Call an observer's typed handler and catch-all handler, independently. */
+function invokeObserver(observer, event, onError) {
+	const typed = observer[`on${event.type.charAt(0).toUpperCase()}${event.type.slice(1)}`];
+	if (typeof typed === "function") try {
+		const result = typed.call(observer, event);
+		if (result != null) Promise.resolve(result).catch(onError);
+	} catch (err) {
+		onError(err);
+	}
+	if (observer.handler !== void 0) try {
+		const result = observer.handler(event);
+		if (result != null) Promise.resolve(result).catch(onError);
+	} catch (err) {
+		onError(err);
+	}
+}
+//#endregion
+//#region src/pipeline.ts
+/**
+* Evaluate policies in pipeline order.
+*
+* The first policy to return a non-void action wins and short-circuits the
+* remaining policies. If a policy throws, the error is caught and treated as
+* a `{ action: "stop" }` directive — the error is preserved on the result
+* so the caller can emit an appropriate {@link ErrorEvent}.
+*/
+async function runPolicies(policies, invoke) {
+	for (const policy of policies) try {
+		const result = await invoke(policy);
+		if (result != null) return {
+			action: result,
+			policy: policy.name
+		};
+	} catch (err) {
+		const error = err instanceof Error ? err : new Error(String(err));
+		return {
+			action: {
+				action: "stop",
+				reason: error.message
+			},
+			policy: policy.name,
+			error
+		};
+	}
+}
+//#endregion
+//#region src/execute.ts
+/**
+* Execute all tool calls from a model response in parallel.
+*
+* Returns assembled {@link ToolResultPart} entries (one per call, preserving
+* call order) and an optional `stopRun` policy name if any tool or policy
+* signaled a stop.
+*/
+async function executeToolCalls(calls, toolMap, policies, ctx, emit) {
+	const promises = calls.map((call) => {
+		const tool = toolMap.get(call.name);
+		if (tool === void 0) {
+			emit({
+				type: "error",
+				...base(ctx),
+				error: /* @__PURE__ */ new Error(`Tool "${call.name}" is not available`),
+				source: "tool",
+				toolCall: call
+			});
+			return Promise.resolve({
+				output: [text(`Tool "${call.name}" is not available. Available tools: ${[...toolMap.keys()].join(", ")}`)],
+				isError: true
+			});
+		}
+		return executeTool(call, tool, policies, ctx, emit);
+	});
+	const settled = await Promise.all(promises);
+	let stopRun;
+	const results = [];
+	for (let i = 0; i < calls.length; i++) {
+		const call = calls[i];
+		const exec = settled[i];
+		results.push({
+			type: "tool_result",
+			id: call.id,
+			name: call.name,
+			output: exec.output,
+			isError: exec.isError ? true : void 0
+		});
+		if (exec.stopRun !== void 0 && stopRun === void 0) stopRun = exec.stopRun;
+	}
+	return {
+		results,
+		stopRun
+	};
+}
+async function executeTool(call, tool, policies, ctx, emit) {
+	const callInfo = {
+		id: call.id,
+		name: call.name,
+		arguments: { ...call.arguments }
+	};
+	const beforePol = await runPolicies(policies, (p) => p.beforeToolRun?.(ctx, callInfo));
+	if (beforePol != null) {
+		if (beforePol.error) emitError(emit, ctx, beforePol.error, "policy", call, beforePol.policy);
+		emitSkip(emit, ctx, call, beforePol.action.action, "policy", beforePol.action.reason);
+		return {
+			output: beforePol.action.output ?? [],
+			isError: false,
+			stopRun: beforePol.action.action === "stop" ? beforePol.policy : void 0
+		};
+	}
+	const parsed = tool.schema.safeParse(callInfo.arguments);
+	if (!parsed.success) {
+		const msg = `Invalid arguments for tool "${tool.name}": ${String(parsed.error)}`;
+		emitError(emit, ctx, new Error(msg), "validation", call);
+		return {
+			output: [text(msg)],
+			isError: true
+		};
+	}
+	try {
+		const beforeAction = await tool.before?.(parsed.data, ctx);
+		if (beforeAction != null) {
+			emitSkip(emit, ctx, call, beforeAction.action, "tool", beforeAction.reason);
+			return {
+				output: beforeAction.output ?? [],
+				isError: false,
+				stopRun: beforeAction.action === "stop" ? tool.name : void 0
+			};
+		}
+	} catch (err) {
+		const error = err instanceof Error ? err : new Error(String(err));
+		emitError(emit, ctx, error, "tool", call);
+		return {
+			output: [text(`Error in "${tool.name}" before hook: ${error.message}`)],
+			isError: true
+		};
+	}
+	const execStart = Date.now();
+	emit({
+		type: "toolRunStart",
+		...base(ctx),
+		id: call.id,
+		name: call.name,
+		arguments: callInfo.arguments
+	});
+	let output = [];
+	let error;
+	let stopRun;
+	let currentArgs = parsed.data;
+	for (;;) {
+		const toolSignal = tool.timeout !== void 0 ? AbortSignal.any([ctx.signal, AbortSignal.timeout(tool.timeout)]) : ctx.signal;
+		const toolCtx = {
+			...ctx,
+			signal: toolSignal,
+			id: call.id,
+			update(data) {
+				emit({
+					type: "toolRunUpdate",
+					...base(ctx),
+					id: call.id,
+					name: call.name,
+					data
+				});
+			}
+		};
+		try {
+			output = normalizeToolReturn(await raceAbort((async () => tool.execute(currentArgs, toolCtx))(), toolSignal));
+			error = void 0;
+		} catch (err) {
+			error = err instanceof Error ? err : new Error(String(err));
+			output = [text(`Error in tool "${tool.name}": ${error.message}`)];
+			emitError(emit, ctx, error, "tool", call);
+		}
+		let shouldRetry = false;
+		if (tool.after !== void 0) try {
+			const action = await tool.after(currentArgs, output, ctx);
+			if (action != null) {
+				const r = applyAfterAction(action, tool, currentArgs);
+				if (r.output !== void 0) {
+					output = r.output;
+					error = void 0;
+				}
+				if (r.retry) {
+					currentArgs = r.nextArgs;
+					stopRun = void 0;
+					shouldRetry = true;
+				}
+				if (r.stop) stopRun = tool.name;
+				if (r.validationError) {
+					error = r.validationError;
+					output = [text(error.message)];
+					break;
+				}
+			}
+		} catch (err) {
+			emitError(emit, ctx, err instanceof Error ? err : new Error(String(err)), "tool", call);
+		}
+		if (shouldRetry) continue;
+		const resultInfo = {
+			id: call.id,
+			name: call.name,
+			arguments: callInfo.arguments,
+			output,
+			isError: error !== void 0
+		};
+		const afterPol = await runPolicies(policies, (p) => p.afterToolRun?.(ctx, resultInfo));
+		if (afterPol != null) {
+			if (afterPol.error) emitError(emit, ctx, afterPol.error, "policy", call, afterPol.policy);
+			const r = applyAfterAction(afterPol.action, tool, currentArgs);
+			if (r.output !== void 0) {
+				output = r.output;
+				error = void 0;
+			}
+			if (r.retry) {
+				currentArgs = r.nextArgs;
+				stopRun = void 0;
+				continue;
+			}
+			if (r.stop) stopRun = afterPol.policy;
+			if (r.validationError) {
+				error = r.validationError;
+				output = [text(error.message)];
+				break;
+			}
+		}
+		break;
+	}
+	emit({
+		type: "toolRunEnd",
+		...base(ctx),
+		id: call.id,
+		name: call.name,
+		output,
+		error,
+		duration: Date.now() - execStart
+	});
+	return {
+		output,
+		isError: error !== void 0,
+		stopRun
+	};
+}
+/**
+* Interpret an {@link AfterToolRunAction} from either `tool.after` or
+* `policy.afterToolRun`. Handles rewrite, retry (with optional re-validation),
+* and stop uniformly so the two call sites stay DRY.
+*/
+function applyAfterAction(action, tool, currentArgs) {
+	switch (action.action) {
+		case "rewrite": return {
+			output: action.output,
+			retry: false,
+			nextArgs: currentArgs,
+			stop: false
+		};
+		case "retry":
+			if (action.arguments !== void 0) {
+				const reparsed = tool.schema.safeParse(action.arguments);
+				if (!reparsed.success) return {
+					retry: false,
+					nextArgs: currentArgs,
+					stop: false,
+					validationError: /* @__PURE__ */ new Error(`Invalid retry arguments for "${tool.name}": ${String(reparsed.error)}`)
+				};
+				return {
+					retry: true,
+					nextArgs: reparsed.data,
+					stop: false
+				};
+			}
+			return {
+				retry: true,
+				nextArgs: currentArgs,
+				stop: false
+			};
+		case "stop": return {
+			retry: false,
+			nextArgs: currentArgs,
+			stop: true
+		};
+	}
+}
+/** Create the base fields shared by all observer events. */
+function base(ctx) {
+	return {
+		runId: ctx.runId,
+		step: ctx.step,
+		agent: ctx.agent,
+		timestamp: Date.now()
+	};
+}
+/** Emit an {@link ErrorEvent}. */
+function emitError(emit, ctx, error, source, toolCall, policy) {
+	emit({
+		type: "error",
+		...base(ctx),
+		error,
+		source,
+		toolCall,
+		policy
+	});
+}
+/** Emit a {@link ToolSkipEvent}. */
+function emitSkip(emit, ctx, call, action, source, reason) {
+	emit({
+		type: "toolSkip",
+		...base(ctx),
+		id: call.id,
+		name: call.name,
+		arguments: call.arguments,
+		action,
+		source,
+		reason
+	});
+}
+/**
+* Race a promise against an {@link AbortSignal}, with proper listener cleanup.
+*
+* If the signal is already aborted, rejects immediately. Otherwise, whichever
+* settles first wins, and the abort listener is removed to prevent leaks.
+*/
+function raceAbort(promise, signal) {
+	if (signal.aborted) return Promise.reject(signal.reason ?? /* @__PURE__ */ new Error("Aborted"));
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(signal.reason ?? /* @__PURE__ */ new Error("Aborted"));
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((v) => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(v);
+		}, (e) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(e);
+		});
+	});
+}
+//#endregion
+//#region src/loop.ts
+/** Create base observer event fields from current run state. */
+function baseFields(runId, step, agent) {
+	return {
+		runId,
+		step,
+		agent,
+		timestamp: Date.now()
+	};
+}
+/** Ensure system instructions appear as the first message in a plan's message list. */
+function prepareMessages(plan) {
+	const messages = plan.messages;
+	if (plan.instructions !== void 0) if (messages.length > 0 && messages[0].role === "system") messages[0] = system(plan.instructions);
+	else messages.unshift(system(plan.instructions));
+	return messages;
+}
+/** Extract {@link ToolDefinition} metadata from tools (strips execute/hooks). */
+function deriveToolDefs(tools) {
+	return tools.map((t) => ({
+		name: t.name,
+		description: t.description,
+		schema: t.schema,
+		...t.timeout !== void 0 && { timeout: t.timeout }
+	}));
+}
+/** Extract the {@link ModelConfig} subset from a {@link StepPlan}. */
+function extractModelConfig(plan) {
+	const config = {};
+	if (plan.maxTokens !== void 0) config.maxTokens = plan.maxTokens;
+	if (plan.temperature !== void 0) config.temperature = plan.temperature;
+	if (plan.topP !== void 0) config.topP = plan.topP;
+	if (plan.topK !== void 0) config.topK = plan.topK;
+	if (plan.stopSequences !== void 0) config.stopSequences = plan.stopSequences;
+	return config;
+}
+/** Extract all {@link ToolCallPart} entries from an assistant message. */
+function extractToolCalls(message) {
+	const calls = [];
+	for (const part of message.content) if (part.type === "tool_call") calls.push(part);
+	return calls;
+}
+/** Join all text content parts from an assistant message. */
+function extractText(message) {
+	let result = "";
+	for (const part of message.content) if (part.type === "text") {
+		if (result) result += "\n";
+		result += part.text;
+	}
+	return result;
+}
+/**
+* Parse structured output from the last text part of a response.
+*
+* Returns the validated object on success, `null` on failure. Emits an
+* {@link ErrorEvent} with `source: "validation"` on parse or validation failure.
+*/
+function parseStructuredOutput(message, schema, emit, base) {
+	let lastText;
+	for (const part of message.content) if (part.type === "text") lastText = part.text;
+	if (lastText === void 0) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(lastText);
+	} catch {
+		emit({
+			type: "error",
+			...base,
+			error: /* @__PURE__ */ new Error("Structured output is not valid JSON"),
+			source: "validation"
+		});
+		return null;
+	}
+	const result = schema.safeParse(parsed);
+	if (result.success) return result.data;
+	emit({
+		type: "error",
+		...base,
+		error: /* @__PURE__ */ new Error(`Structured output validation failed: ${String(result.error)}`),
+		source: "validation"
+	});
+	return null;
+}
+/**
+* Consume a model's {@link StreamPart} iterable, assembling the final
+* {@link AssistantMessage} while emitting observer events for each part.
+*
+* Single pass, single piece of state. Throws on stream errors — the caller
+* catches and converts to an error result.
+*/
+async function consumeStream(stream, emit, base) {
+	const content = [];
+	const toolCalls = /* @__PURE__ */ new Map();
+	let textBuffer = "";
+	let thinkingBuffer = "";
+	let thinkingSignature;
+	let thinkingRedacted = false;
+	let usage = emptyUsage();
+	let finishReason = "unknown";
+	function flushText() {
+		if (textBuffer) {
+			content.push({
+				type: "text",
+				text: textBuffer
+			});
+			textBuffer = "";
+		}
+	}
+	function flushThinking() {
+		if (thinkingBuffer || thinkingRedacted) {
+			content.push({
+				type: "thinking",
+				thinking: thinkingBuffer,
+				signature: thinkingSignature,
+				redacted: thinkingRedacted
+			});
+			thinkingBuffer = "";
+			thinkingSignature = void 0;
+			thinkingRedacted = false;
+		}
+	}
+	for await (const part of stream) switch (part.type) {
+		case "text_start":
+			flushText();
+			flushThinking();
+			textBuffer = "";
+			emit({
+				type: "textStart",
+				...base()
+			});
+			break;
+		case "text_delta":
+			textBuffer += part.text;
+			emit({
+				type: "textDelta",
+				...base(),
+				text: part.text
+			});
+			break;
+		case "text_end":
+			flushText();
+			emit({
+				type: "textStop",
+				...base()
+			});
+			break;
+		case "thinking_start":
+			flushText();
+			flushThinking();
+			thinkingBuffer = "";
+			thinkingSignature = void 0;
+			thinkingRedacted = part.redacted ?? false;
+			emit({
+				type: "thinkingStart",
+				...base(),
+				redacted: part.redacted
+			});
+			break;
+		case "thinking_delta":
+			thinkingBuffer += part.thinking;
+			emit({
+				type: "thinkingDelta",
+				...base(),
+				text: part.thinking
+			});
+			break;
+		case "thinking_end":
+			thinkingSignature = part.signature;
+			flushThinking();
+			emit({
+				type: "thinkingStop",
+				...base()
+			});
+			break;
+		case "tool_call_start":
+			flushText();
+			flushThinking();
+			toolCalls.set(part.id, {
+				id: part.id,
+				name: part.name,
+				args: "",
+				signature: part.signature
+			});
+			emit({
+				type: "toolCallStart",
+				...base(),
+				id: part.id,
+				name: part.name
+			});
+			break;
+		case "tool_call_delta": {
+			const tc = toolCalls.get(part.id);
+			if (tc !== void 0) {
+				tc.args += part.args;
+				emit({
+					type: "toolCallDelta",
+					...base(),
+					id: part.id,
+					name: tc.name,
+					partialArguments: tc.args
+				});
+			}
+			break;
+		}
+		case "tool_call_end": {
+			const tc = toolCalls.get(part.id);
+			if (tc !== void 0) {
+				let args;
+				try {
+					args = JSON.parse(tc.args || "{}");
+				} catch (e) {
+					throw new Error(`Invalid JSON in tool call arguments for ${tc.name} (${tc.id})`, { cause: e });
+				}
+				content.push({
+					type: "tool_call",
+					id: tc.id,
+					name: tc.name,
+					arguments: args,
+					...tc.signature !== void 0 && { signature: tc.signature }
+				});
+				toolCalls.delete(tc.id);
+				emit({
+					type: "toolCallStop",
+					...base(),
+					id: tc.id,
+					name: tc.name,
+					arguments: args
+				});
+			}
+			break;
+		}
+		case "finish":
+			usage = part.usage;
+			finishReason = part.finishReason;
+			break;
+		case "error": throw part.error;
+	}
+	flushThinking();
+	flushText();
+	return {
+		message: {
+			role: "assistant",
+			content
+		},
+		usage,
+		finishReason
+	};
+}
+/**
+* Execute an agent run to completion.
+*
+* This function never throws. All errors are caught and reflected in the
+* returned {@link AgentResult}. The caller provides an {@link EmitFn} that
+* receives every observer event as it occurs.
+*/
+async function executeRun(config, prompt, options, emit) {
+	const runStart = Date.now();
+	const runId = crypto.randomUUID();
+	const policies = [...config.policies ?? [], ...options.policies ?? []];
+	const tools = config.tools ?? [];
+	const transcript = [...options.transcript ?? [], ...prompt !== void 0 ? normalizePrompt(prompt) : []];
+	const modelConfig = {};
+	if (options.maxTokens !== void 0) modelConfig.maxTokens = options.maxTokens;
+	if (options.temperature !== void 0) modelConfig.temperature = options.temperature;
+	if (options.topP !== void 0) modelConfig.topP = options.topP;
+	if (options.topK !== void 0) modelConfig.topK = options.topK;
+	if (options.stopSequences !== void 0) modelConfig.stopSequences = options.stopSequences;
+	const signal = options.signal ?? new AbortController().signal;
+	const state = options.state ?? {};
+	let totalUsage = emptyUsage();
+	let step = 0;
+	let retries = 0;
+	let finishReason = "unknown";
+	let stoppedBy;
+	let runError;
+	let parsedObject;
+	let lastResponse = {
+		role: "assistant",
+		content: []
+	};
+	/** Snapshot the current {@link RunContext}. */
+	function ctx() {
+		return {
+			runId,
+			step,
+			agent: config.name,
+			state,
+			retries,
+			signal
+		};
+	}
+	/** Create {@link BaseFields} from current run state. */
+	function base() {
+		return baseFields(runId, step, config.name);
+	}
+	try {
+		emit({
+			type: "runStart",
+			...base(),
+			model: config.model.name,
+			instructions: config.instructions,
+			prompt: prompt ?? void 0,
+			tools: tools.map((t) => t.name)
+		});
+		for (;;) {
+			if (signal.aborted) {
+				finishReason = "cancelled";
+				emit({
+					type: "abort",
+					...base(),
+					reason: String(signal.reason ?? "Aborted")
+				});
+				break;
+			}
+			const plan = {
+				model: config.model,
+				instructions: config.instructions,
+				messages: [...transcript],
+				tools: [...tools],
+				...modelConfig
+			};
+			const beforeStep = await runPolicies(policies, (p) => p.beforeStep?.(ctx(), plan));
+			if (beforeStep != null) {
+				if (beforeStep.error) emit({
+					type: "error",
+					...base(),
+					error: beforeStep.error,
+					source: "policy",
+					policy: beforeStep.policy
+				});
+				finishReason = "stop";
+				stoppedBy = beforeStep.policy;
+				break;
+			}
+			const toolMap = new Map(plan.tools.map((t) => [t.name, t]));
+			const stepStart = Date.now();
+			emit({
+				type: "stepStart",
+				...base(),
+				model: plan.model.name
+			});
+			const callMessages = prepareMessages(plan);
+			const toolDefs = deriveToolDefs(plan.tools);
+			let message;
+			let stepUsage;
+			let stepFinishReason;
+			try {
+				const result = await consumeStream(plan.model.stream({
+					messages: callMessages,
+					tools: toolDefs.length > 0 ? toolDefs : void 0,
+					config: extractModelConfig(plan),
+					output: options.output,
+					signal
+				}), emit, base);
+				message = result.message;
+				stepUsage = result.usage;
+				stepFinishReason = result.finishReason;
+			} catch (err) {
+				const error = err instanceof Error ? err : new Error(String(err));
+				emit({
+					type: "error",
+					...base(),
+					error,
+					source: "provider"
+				});
+				message = {
+					role: "assistant",
+					content: []
+				};
+				stepUsage = emptyUsage();
+				stepFinishReason = "error";
+				runError = error;
+			}
+			const responseEnd = Date.now();
+			totalUsage = addUsage(totalUsage, stepUsage);
+			finishReason = stepFinishReason;
+			lastResponse = message;
+			parsedObject = options.output !== void 0 ? parseStructuredOutput(message, options.output, emit, base()) : void 0;
+			emit({
+				type: "responseFinish",
+				...base(),
+				message,
+				usage: stepUsage,
+				totalUsage,
+				finishReason: stepFinishReason,
+				error: runError,
+				duration: responseEnd - stepStart
+			});
+			if (runError !== void 0) break;
+			transcript.push(message);
+			const responseInfo = {
+				message,
+				messages: transcript,
+				usage: stepUsage,
+				totalUsage,
+				finishReason: stepFinishReason,
+				object: parsedObject
+			};
+			const afterResponse = await runPolicies(policies, (p) => p.afterResponse?.(ctx(), responseInfo));
+			if (afterResponse != null) {
+				if (afterResponse.error) emit({
+					type: "error",
+					...base(),
+					error: afterResponse.error,
+					source: "policy",
+					policy: afterResponse.policy
+				});
+				const a = afterResponse.action;
+				if (a.action === "stop") {
+					finishReason = "stop";
+					stoppedBy = afterResponse.policy;
+					break;
+				}
+				if (a.action === "replace") {
+					transcript[transcript.length - 1] = a.message;
+					lastResponse = a.message;
+					message = a.message;
+				}
+				if (a.action === "retry") {
+					transcript.pop();
+					if (a.messages) transcript.push(...a.messages);
+					retries++;
+					emit({
+						type: "stepRetry",
+						...base(),
+						reason: a.reason,
+						retries
+					});
+					continue;
+				}
+			}
+			const toolCalls = extractToolCalls(message);
+			if (toolCalls.length > 0) {
+				const { results, stopRun } = await executeToolCalls(toolCalls, toolMap, policies, ctx(), emit);
+				transcript.push({
+					role: "tool",
+					content: results
+				});
+				if (stopRun !== void 0) {
+					stoppedBy = stopRun;
+					finishReason = "stop";
+					break;
+				}
+			}
+			const stepMessages = [message];
+			if (toolCalls.length > 0) stepMessages.push(transcript[transcript.length - 1]);
+			const stepInfo = {
+				messages: stepMessages,
+				transcript,
+				usage: stepUsage,
+				totalUsage,
+				finishReason: stepFinishReason,
+				object: parsedObject
+			};
+			const afterStep = await runPolicies(policies, (p) => p.afterStep?.(ctx(), stepInfo));
+			let injected = false;
+			if (afterStep != null) {
+				if (afterStep.error) emit({
+					type: "error",
+					...base(),
+					error: afterStep.error,
+					source: "policy",
+					policy: afterStep.policy
+				});
+				const a = afterStep.action;
+				if (a.action === "stop") {
+					finishReason = "stop";
+					stoppedBy = afterStep.policy;
+					emit({
+						type: "stepFinish",
+						...base(),
+						messages: stepMessages,
+						object: parsedObject,
+						usage: stepUsage,
+						totalUsage,
+						finishReason,
+						duration: Date.now() - stepStart
+					});
+					break;
+				}
+				if (a.action === "retry") {
+					transcript.splice(transcript.length - stepMessages.length, stepMessages.length);
+					if (a.messages) transcript.push(...a.messages);
+					retries++;
+					emit({
+						type: "stepRetry",
+						...base(),
+						reason: a.reason,
+						retries
+					});
+					continue;
+				}
+				if (a.action === "inject") {
+					transcript.push(...a.messages);
+					injected = true;
+				}
+			}
+			emit({
+				type: "stepFinish",
+				...base(),
+				messages: stepMessages,
+				object: parsedObject,
+				usage: stepUsage,
+				totalUsage,
+				finishReason: stepFinishReason,
+				duration: Date.now() - stepStart
+			});
+			if (toolCalls.length === 0 && !injected) break;
+			step++;
+			retries = 0;
+		}
+	} catch (err) {
+		runError = err instanceof Error ? err : new Error(String(err));
+		finishReason = "error";
+		emit({
+			type: "error",
+			...base(),
+			error: runError,
+			source: "provider"
+		});
+	}
+	const result = {
+		text: extractText(lastResponse),
+		response: lastResponse,
+		transcript,
+		steps: step + 1,
+		usage: totalUsage,
+		finishReason,
+		stoppedBy,
+		error: runError,
+		duration: Date.now() - runStart,
+		object: parsedObject
+	};
+	emit({
+		type: "runFinish",
+		...base(),
+		text: result.text,
+		response: result.response,
+		transcript: result.transcript,
+		object: result.object,
+		steps: result.steps,
+		usage: result.usage,
+		finishReason: result.finishReason,
+		stoppedBy: result.stoppedBy,
+		error: result.error,
+		duration: result.duration
+	});
+	return result;
+}
+//#endregion
+//#region src/agent.ts
+/** Create an {@link Agent} from the given configuration. */
+function defineAgent(config) {
+	const agent = {
+		run(prompt, options) {
+			const opts = options ?? {};
+			return executeRun(config, prompt, opts, createEmitFn([...config.observers ?? [], ...opts.observers ?? []]));
+		},
+		stream(prompt, options) {
+			const opts = options ?? {};
+			const observers = [...config.observers ?? [], ...opts.observers ?? []];
+			const channel = createEventChannel();
+			executeRun(config, prompt, opts, createEmitFn(observers, channel.push)).then((result) => channel.close(result), (err) => channel.fail(err instanceof Error ? err : new Error(String(err))));
+			return {
+				result: channel.result,
+				[Symbol.asyncIterator]() {
+					return channel.stream[Symbol.asyncIterator]();
+				}
+			};
+		},
+		asTool(toolConfig) {
+			return {
+				name: toolConfig.name,
+				description: toolConfig.description,
+				schema: toolConfig.schema,
+				async execute(args, ctx) {
+					const result = await agent.run(toolConfig.prompt(args), { signal: ctx.signal });
+					if (toolConfig.output) return toolConfig.output(result);
+					return result.text;
+				}
+			};
+		}
+	};
+	return agent;
+}
+//#endregion
+export { addUsage, assistant, blob, defineAgent, defineObserver, definePolicy, defineTool, emptyUsage, json, normalizePrompt, normalizeToolReturn, schemaToJsonSchema, system, text, url, user };
+
+//# sourceMappingURL=index.mjs.map