@schlenkr/ragents 0.1.0

package/packages/ai/src/utils/validation.ts

@@ -0,0 +1,383 @@
+import { Compile } from "typebox/compile";
+import type { TLocalizedValidationError } from "typebox/error";
+import { Value } from "typebox/value";
+import type { Tool, ToolCall } from "../types.ts";
+
+const validatorCache = new WeakMap<object, ReturnType<typeof Compile>>();
+const rootTolerantSchemas = new WeakMap<object, Tool["parameters"]>();
+const TYPEBOX_KIND = Symbol.for("TypeBox.Kind");
+
+interface JsonSchemaObject {
+	type?: string | string[];
+	properties?: Record<string, JsonSchemaObject>;
+	items?: JsonSchemaObject | JsonSchemaObject[];
+	additionalProperties?: boolean | JsonSchemaObject;
+	allOf?: JsonSchemaObject[];
+	anyOf?: JsonSchemaObject[];
+	oneOf?: JsonSchemaObject[];
+}
+
+function getSchemaTypes(schema: JsonSchemaObject): string[] {
+	if (typeof schema.type === "string") {
+		return [schema.type];
+	}
+	if (Array.isArray(schema.type)) {
+		return schema.type.filter((type): type is string => typeof type === "string");
+	}
+	return [];
+}
+
+function matchesJsonType(value: unknown, type: string): boolean {
+	switch (type) {
+		case "number":
+			return typeof value === "number";
+		case "integer":
+			return typeof value === "number" && Number.isInteger(value);
+		case "boolean":
+			return typeof value === "boolean";
+		case "string":
+			return typeof value === "string";
+		case "null":
+			return value === null;
+		case "array":
+			return Array.isArray(value);
+		case "object":
+			return typeof value === "object" && value !== null && !Array.isArray(value);
+		default:
+			return false;
+	}
+}
+
+function getSubSchemaValidator(schema: JsonSchemaObject): ReturnType<typeof Compile> | undefined {
+	try {
+		return getValidator(schema as Tool["parameters"]);
+	} catch {
+		return undefined;
+	}
+}
+
+function coercePrimitiveByType(value: unknown, type: string): unknown {
+	switch (type) {
+		case "number": {
+			if (value === null) {
+				return 0;
+			}
+			if (typeof value === "string" && value.trim() !== "") {
+				const parsed = Number(value);
+				if (Number.isFinite(parsed)) {
+					return parsed;
+				}
+			}
+			if (typeof value === "boolean") {
+				return value ? 1 : 0;
+			}
+			return value;
+		}
+		case "integer": {
+			if (value === null) {
+				return 0;
+			}
+			if (typeof value === "string" && value.trim() !== "") {
+				const parsed = Number(value);
+				if (Number.isInteger(parsed)) {
+					return parsed;
+				}
+			}
+			if (typeof value === "boolean") {
+				return value ? 1 : 0;
+			}
+			return value;
+		}
+		case "boolean": {
+			if (value === null) {
+				return false;
+			}
+			if (typeof value === "string") {
+				if (value === "true") {
+					return true;
+				}
+				if (value === "false") {
+					return false;
+				}
+			}
+			if (typeof value === "number") {
+				if (value === 1) {
+					return true;
+				}
+				if (value === 0) {
+					return false;
+				}
+			}
+			return value;
+		}
+		case "string": {
+			if (value === null) {
+				return "";
+			}
+			if (typeof value === "number" || typeof value === "boolean") {
+				return String(value);
+			}
+			return value;
+		}
+		case "null": {
+			if (value === "" || value === 0 || value === false) {
+				return null;
+			}
+			return value;
+		}
+		default:
+			return value;
+	}
+}
+
+function applySchemaObjectCoercion(value: Record<string, unknown>, schema: JsonSchemaObject): void {
+	const properties = schema.properties;
+	const definedKeys = new Set<string>(properties ? Object.keys(properties) : []);
+
+	if (properties) {
+		for (const [key, propertySchema] of Object.entries(properties)) {
+			if (!(key in value)) {
+				continue;
+			}
+			value[key] = coerceWithJsonSchema(value[key], propertySchema);
+		}
+	}
+
+	if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+		for (const [key, propertyValue] of Object.entries(value)) {
+			if (definedKeys.has(key)) {
+				continue;
+			}
+			value[key] = coerceWithJsonSchema(propertyValue, schema.additionalProperties);
+		}
+	}
+}
+
+function applySchemaArrayCoercion(value: unknown[], schema: JsonSchemaObject): void {
+	if (Array.isArray(schema.items)) {
+		for (let index = 0; index < value.length; index++) {
+			const itemSchema = schema.items[index];
+			if (!itemSchema) {
+				continue;
+			}
+			value[index] = coerceWithJsonSchema(value[index], itemSchema);
+		}
+		return;
+	}
+
+	if (schema.items && typeof schema.items === "object") {
+		for (let index = 0; index < value.length; index++) {
+			value[index] = coerceWithJsonSchema(value[index], schema.items);
+		}
+	}
+}
+
+function coerceWithUnionSchema(value: unknown, schemas: JsonSchemaObject[]): unknown {
+	for (const schema of schemas) {
+		const candidate = structuredClone(value);
+		const coerced = coerceWithJsonSchema(candidate, schema);
+		const validator = getSubSchemaValidator(schema);
+		if (validator?.Check(coerced)) {
+			return coerced;
+		}
+	}
+	return value;
+}
+
+function coerceWithJsonSchema(value: unknown, schema: JsonSchemaObject): unknown {
+	if (getSubSchemaValidator(schema)?.Check(value)) {
+		return value;
+	}
+	let nextValue = value;
+
+	if (Array.isArray(schema.allOf)) {
+		for (const nested of schema.allOf) {
+			nextValue = coerceWithJsonSchema(nextValue, nested);
+		}
+	}
+
+	if (Array.isArray(schema.anyOf)) {
+		nextValue = coerceWithUnionSchema(nextValue, schema.anyOf);
+	}
+
+	if (Array.isArray(schema.oneOf)) {
+		nextValue = coerceWithUnionSchema(nextValue, schema.oneOf);
+	}
+
+	const schemaTypes = getSchemaTypes(schema);
+	const matchesUnionMember =
+		schemaTypes.length > 1 && schemaTypes.some((schemaType) => matchesJsonType(nextValue, schemaType));
+	if (schemaTypes.length > 0 && !matchesUnionMember) {
+		for (const schemaType of schemaTypes) {
+			const candidate = coercePrimitiveByType(nextValue, schemaType);
+			if (candidate !== nextValue) {
+				nextValue = candidate;
+				break;
+			}
+		}
+	}
+
+	if (
+		schemaTypes.includes("object") &&
+		typeof nextValue === "object" &&
+		nextValue !== null &&
+		!Array.isArray(nextValue)
+	) {
+		applySchemaObjectCoercion(nextValue as Record<string, unknown>, schema);
+	}
+
+	if (schemaTypes.includes("array") && Array.isArray(nextValue)) {
+		applySchemaArrayCoercion(nextValue, schema);
+	}
+
+	return nextValue;
+}
+
+/** Unknown root fields pass through; the engine strips and reports them (RAgents, 18.09.2026). */
+function rootTolerantSchema(schema: Tool["parameters"]): Tool["parameters"] {
+	if ((schema as JsonSchemaObject).additionalProperties !== false) {
+		return schema;
+	}
+	const cached = rootTolerantSchemas.get(schema);
+	if (cached) {
+		return cached;
+	}
+	const tolerant = { ...schema, additionalProperties: true } as Tool["parameters"];
+	rootTolerantSchemas.set(schema, tolerant);
+	return tolerant;
+}
+
+function getValidator(schema: Tool["parameters"]): ReturnType<typeof Compile> {
+	const key = schema as object;
+	const cached = validatorCache.get(key);
+	if (cached) {
+		return cached;
+	}
+	const validator = Compile(schema);
+	validatorCache.set(key, validator);
+	return validator;
+}
+
+function formatValidationPath(error: TLocalizedValidationError): string {
+	if (error.keyword === "required") {
+		const requiredProperties = (error.params as { requiredProperties?: string[] }).requiredProperties;
+		const requiredProperty = requiredProperties?.[0];
+		if (requiredProperty) {
+			const basePath = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+			return basePath ? `${basePath}.${requiredProperty}` : requiredProperty;
+		}
+	}
+	const path = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+	return path || "root";
+}
+
+function getAllowedValues(error: TLocalizedValidationError): string[] {
+	if (error.keyword === "const") {
+		return [String(error.params.allowedValue)];
+	}
+	if (error.keyword === "enum") {
+		return error.params.allowedValues.map((value) => String(value));
+	}
+	return [];
+}
+
+function getUnknownFields(error: TLocalizedValidationError): string[] {
+	return error.keyword === "additionalProperties" ? error.params.additionalProperties : [];
+}
+
+function getValueAtPointer(value: unknown, instancePath: string): unknown {
+	let current = value;
+	for (const part of instancePath.split("/").slice(1)) {
+		if (current === null || typeof current !== "object") {
+			return undefined;
+		}
+		current = (current as Record<string, unknown>)[part.replace(/~1/g, "/").replace(/~0/g, "~")];
+	}
+	return current;
+}
+
+function formatReceivedValue(value: unknown): string {
+	const text = JSON.stringify(value);
+	if (text === undefined) {
+		return "undefined";
+	}
+	return text.length > 120 ? `${text.slice(0, 120)}...` : text;
+}
+
+function formatValidationErrors(errors: TLocalizedValidationError[], args: unknown): string[] {
+	const byPath = new Map<string, TLocalizedValidationError[]>();
+
+	for (const error of errors) {
+		const path = formatValidationPath(error);
+		byPath.set(path, [...(byPath.get(path) ?? []), error]);
+	}
+
+	return [...byPath].map(([path, group]) => {
+		const allowed = [...new Set(group.flatMap(getAllowedValues))];
+		if (allowed.length > 0) {
+			const received = formatReceivedValue(getValueAtPointer(args, group[0].instancePath));
+			return `  - ${path}: got ${received}, allowed values: ${allowed.join(", ")}`;
+		}
+		const unknown = [...new Set(group.flatMap(getUnknownFields))];
+		if (unknown.length > 0) {
+			return `  - ${path}: unknown fields ${unknown.join(", ")}`;
+		}
+		const messages = [...new Set(group.map((error) => error.message))];
+		return `  - ${path}: ${messages.join("; ")}`;
+	});
+}
+
+/**
+ * Finds a tool by name and validates the tool call arguments against its TypeBox schema
+ * @param tools Array of tool definitions
+ * @param toolCall The tool call from the LLM
+ * @returns The validated arguments
+ * @throws Error if tool is not found or validation fails
+ */
+export function validateToolCall(tools: Tool[], toolCall: ToolCall): any {
+	const tool = tools.find((t) => t.name === toolCall.name);
+	if (!tool) {
+		throw new Error(`Tool "${toolCall.name}" not found`);
+	}
+	return validateToolArguments(tool, toolCall);
+}
+
+/**
+ * Validates tool call arguments against the tool's TypeBox schema
+ * @param tool The tool definition with TypeBox schema
+ * @param toolCall The tool call from the LLM
+ * @returns The validated (and potentially coerced) arguments
+ * @throws Error with formatted message if validation fails
+ */
+export function validateToolArguments(tool: Tool, toolCall: ToolCall): any {
+	const args = structuredClone(toolCall.arguments);
+	const validator = getValidator(rootTolerantSchema(tool.parameters));
+	if (validator.Check(args)) {
+		return args;
+	}
+	Value.Convert(tool.parameters, args);
+
+	if (!Object.getOwnPropertySymbols(tool.parameters).includes(TYPEBOX_KIND)) {
+		const coerced = coerceWithJsonSchema(args, tool.parameters as JsonSchemaObject);
+		if (coerced !== args) {
+			if (typeof args === "object" && args !== null && typeof coerced === "object" && coerced !== null) {
+				for (const key of Object.keys(args)) {
+					delete args[key];
+				}
+				Object.assign(args, coerced);
+			} else {
+				return validator.Check(coerced) ? coerced : args;
+			}
+		}
+	}
+
+	if (validator.Check(args)) {
+		return args;
+	}
+
+	const errors = formatValidationErrors([...getValidator(tool.parameters).Errors(args)], args).join("\n") || "Unknown validation error";
+
+	const errorMessage = `Validation failed for tool "${toolCall.name}":\n${errors}\nFix the named fields and call the tool again; do not repeat the other arguments differently.`;
+
+	throw new Error(errorMessage);
+}

package/packages/ragents/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@aicontainer/ragents",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./src/*.ts": "./src/*.ts",
+    "./src/*": "./src/*.ts",
+    "./tests/*": "./tests/*"
+  },
+  "engines": {
+    "node": ">=22.23.0"
+  },
+  "scripts": {
+    "test": "node --test tests/*.test.ts",
+    "typecheck": "tsc --noEmit",
+    "check": "pnpm run typecheck && pnpm test"
+  },
+  "devDependencies": {
+    "@aicontainer/agent-core": "workspace:*",
+    "@aicontainer/ai": "workspace:*"
+  },
+  "dependencies": {
+    "@aicontainer/agent": "workspace:*",
+    "@types/node": "^24.10.0",
+    "typebox": "1.1.38",
+    "typescript": "^5.9.0",
+    "yaml": "^2.9.0"
+  }
+}

package/packages/ragents/src/access.ts

@@ -0,0 +1,54 @@
+export interface AccessUser {
+  readonly id: string;
+  readonly label: string;
+  readonly rights: readonly string[];
+  readonly startEntries?: readonly string[];
+}
+
+/** Abfrageparameter, unter dem GET-Abrufe ohne Header (Ereignisstrom, iframes) einen Zugangstoken mitgeben. */
+export const ACCESS_TOKEN_QUERY = "access";
+
+export const isAccessRight = (value: unknown): value is string =>
+  typeof value === "string" && (value === "*" || /^[a-z][a-z0-9._:-]*$/.test(value));
+
+export interface AccessSnapshot {
+  readonly enabled: boolean;
+  readonly user: AccessUser | null;
+}
+
+export interface AccessContext extends AccessSnapshot {
+  can(right: string): boolean;
+}
+
+export const builtinPermissions = [
+  { id: "runs.read", description: "Runs, Chats, Journale und Arbeitsbereiche ansehen." },
+  { id: "runs.write", description: "Vorhandene Runs steuern, Nachrichten senden, freigegebene Setups starten und App-Aktionen ausführen." },
+  { id: "runs.create", description: "Freie Runs erstellen, Startoptionen wählen und Aufträge vorbereiten." },
+  { id: "runs.inspect", description: "Modelle, technische Laufdetails, Journale und Programmquellen ansehen." },
+  { id: "runs.trace", description: "Denk- und Werkzeugschritte im Chat mit Inhalt sehen und ihren Detailgrad wählen." },
+  { id: "runs.delete", description: "Runs und ihre gespeicherten Daten löschen." },
+  { id: "settings.read", description: "Profil, Konfiguration und Erweiterungen ansehen." },
+  { id: "settings.write", description: "Einstellungen und externen Zugang ändern." },
+  { id: "models.use", description: "Modelle über das Modell-Relay dieses Servers aufrufen." },
+  { id: "profile.fetch", description: "Das Client-Profil dieses Servers beschreiben und herunterladen." },
+] as const;
+
+export const hasRight = (access: AccessSnapshot, right: string): boolean =>
+  (!access.enabled && !access.user) || Boolean(access.user?.rights.some((entry) => entry === "*" || entry === right));
+
+export const canStartEntry = (access: AccessSnapshot, entryId: string): boolean =>
+  hasRight(access, "runs.write") && (hasRight(access, "runs.create") || Boolean(access.user?.startEntries?.includes(entryId)));
+
+export const createAccessContext = (snapshot: AccessSnapshot): AccessContext => ({
+  ...snapshot,
+  can: (right) => hasRight(snapshot, right),
+});
+
+export const unrestrictedAccess = createAccessContext({ enabled: false, user: null });
+
+export const accessMode = (access: AccessSnapshot, read: string, write: string): "hidden" | "readonly" | "write" =>
+  !hasRight(access, read) ? "hidden" : hasRight(access, write) ? "write" : "readonly";
+
+export const defaultHttpRights = (method: string | undefined): readonly string[] =>
+  method === "GET" || method === "HEAD" || method === "OPTIONS"
+    ? ["runs.read"] : ["runs.read", "runs.write"];

package/packages/ragents/src/agents/actor-input.ts

@@ -0,0 +1,191 @@
+import { Type, type Static, type TSchema } from "typebox";
+
+import type { EventPayloads, EventType } from "../domain/events.ts";
+import { assertJsonValue, type JsonValue } from "../domain/json.ts";
+import type { CommandContext } from "../runtime/command.ts";
+import type { Orchestration } from "../runtime/orchestration.ts";
+
+export const actorInputSchema = Type.Object({
+    actor: Type.String({ minLength: 1, description: "Actor ID oder Handle" }),
+    content: Type.String({ minLength: 1 }),
+    artifactIds: Type.Optional(Type.Array(Type.String({ minLength: 1 }), { uniqueItems: true })),
+}, { additionalProperties: false });
+
+type KeysOf<Value> = Value extends unknown ? keyof Value : never;
+
+const payloadOf = <Name extends EventType>(
+    fields: { [Key in KeysOf<EventPayloads[Name]>]?: TSchema },
+): TSchema => Type.Object(fields as Record<string, TSchema>, { additionalProperties: false });
+
+const eventPayloads = {
+    "run.created": payloadOf<"run.created">({
+        title: Type.String(),
+    }),
+    "run.forked": payloadOf<"run.forked">({
+        sourceRunId: Type.String({ description: "ID des Quell-Runs" }),
+        sourceSequence: Type.Integer(),
+    }),
+    "run.primary-actor-selected": payloadOf<"run.primary-actor-selected">({
+        actorId: Type.String({ description: "ID des primären Actors" }),
+    }),
+    "run.title-changed": payloadOf<"run.title-changed">({
+        title: Type.String({ description: "Neuer Titel des Runs" }),
+    }),
+    "agent.spawned": payloadOf<"agent.spawned">({
+        agentId: Type.String({ description: "ID des neuen Agenten; actor_input und actor_stop nehmen sie oder @handle" }),
+        handle: Type.String(),
+        displayName: Type.String(),
+    }),
+    "script.created": payloadOf<"script.created">({
+        scriptId: Type.String({ description: "ID des neuen TypeScript-Actors" }),
+        handle: Type.String(),
+        displayName: Type.String(),
+    }),
+    "actor.input.enqueued": payloadOf<"actor.input.enqueued">({
+        inputId: Type.String({ description: "ID des eingereihten Inputs" }),
+        actorId: Type.String({ description: "ID des empfangenden Actors" }),
+    }),
+    "turn.started": payloadOf<"turn.started">({
+        turnId: Type.String({ description: "ID des gestarteten Turns" }),
+        inputId: Type.String(),
+    }),
+    "turn.finished": payloadOf<"turn.finished">({
+        turnId: Type.String({ description: "ID des beendeten Turns" }),
+        outcome: Type.String(),
+        reason: Type.Optional(Type.String()),
+    }),
+    "turn.interrupted": payloadOf<"turn.interrupted">({
+        turnId: Type.String({ description: "ID des unterbrochenen Turns" }),
+        reason: Type.String(),
+    }),
+    "model.output.completed": payloadOf<"model.output.completed">({
+        turnId: Type.String({ description: "Turn, zu dem die Ausgabe gehört" }),
+    }),
+    "model.reasoning.completed": payloadOf<"model.reasoning.completed">({
+        turnId: Type.String({ description: "Turn, zu dem die Ausgabe gehört" }),
+    }),
+    "runtime.output.recorded": payloadOf<"runtime.output.recorded">({
+        turnId: Type.String({ description: "Turn, zu dem die Ausgabe gehört" }),
+    }),
+    "tool.call.started": payloadOf<"tool.call.started">({
+        turnId: Type.String(),
+        toolCallId: Type.String({ description: "ID des Werkzeugaufrufs" }),
+        name: Type.String(),
+    }),
+    "tool.call.source": payloadOf<"tool.call.source">({
+        turnId: Type.String(),
+        toolCallId: Type.String({ description: "ID des Werkzeugaufrufs" }),
+        path: Type.Union([Type.String(), Type.Null()]),
+    }),
+    "tool.call.completed": payloadOf<"tool.call.completed">({
+        turnId: Type.String(),
+        toolCallId: Type.String({ description: "ID des Werkzeugaufrufs" }),
+        name: Type.String(),
+    }),
+    "tool.call.failed": payloadOf<"tool.call.failed">({
+        turnId: Type.String(),
+        toolCallId: Type.String({ description: "ID des Werkzeugaufrufs" }),
+        name: Type.String(),
+        error: Type.String(),
+    }),
+    "actor.tools.opened": payloadOf<"actor.tools.opened">({
+        actorId: Type.String({ description: "Actor, dessen Werkzeuge geöffnet wurden" }),
+        toolNames: Type.Array(Type.String()),
+    }),
+    "actor.stopped": payloadOf<"actor.stopped">({
+        actorId: Type.String({ description: "ID des gestoppten Actors" }),
+        reason: Type.String(),
+    }),
+    "actor.restarted": payloadOf<"actor.restarted">({
+        actorId: Type.String({ description: "ID des neu gestarteten Actors" }),
+        reason: Type.String(),
+    }),
+    "subscription.created": payloadOf<"subscription.created">({
+        subscriptionId: Type.String({ description: "ID der neuen Subscription" }),
+        subscriberId: Type.String(),
+    }),
+    "subscription.removed": payloadOf<"subscription.removed">({
+        subscriptionId: Type.String({ description: "ID der entfernten Subscription" }),
+        reason: Type.String(),
+    }),
+    "subscription.failed": payloadOf<"subscription.failed">({
+        subscriptionId: Type.String({ description: "ID der gescheiterten Subscription" }),
+        sourceEventId: Type.String(),
+        reason: Type.String(),
+    }),
+    "action.proposed": payloadOf<"action.proposed">({
+        actionId: Type.String({ description: "ID der vorgeschlagenen Aktion" }),
+        title: Type.String(),
+    }),
+    "action.resolved": payloadOf<"action.resolved">({
+        actionId: Type.String({ description: "ID der aufgelösten Aktion" }),
+        decision: Type.String(),
+    }),
+    "artifact.published": payloadOf<"artifact.published">({
+        artifact: Type.Object({
+            id: Type.String({ description: "ID des Artefakts; artifact_read liest es damit" }),
+            title: Type.String(),
+            mediaType: Type.String(),
+        }, { additionalProperties: false }),
+    }),
+    "plugin.state-replaced": payloadOf<"plugin.state-replaced">({
+        pluginId: Type.String({ description: "Plugin, dessen Zustand ersetzt wurde" }),
+    }),
+    "plugin.state-patched": payloadOf<"plugin.state-patched">({
+        pluginId: Type.String({ description: "Plugin, dessen Zustand geändert wurde" }),
+    }),
+} satisfies Record<EventType, TSchema>;
+
+export const eventResultSchema: TSchema = Type.Array(
+    Type.Union(Object.entries(eventPayloads).map(([type, payload]) => Type.Object({
+        type: Type.Literal(type),
+        payload,
+    }, { additionalProperties: false }))),
+    {
+        description:
+            "Die Journal-Events dieses Aufrufs. Die payload nennt die Kennungen des Ergebnisses; "
+            + "Eingaben und Hashes wiederholt sie nicht.",
+    },
+);
+
+const pickedBySchema = (schema: TSchema, value: JsonValue): JsonValue => {
+    const properties = (schema as { properties?: Record<string, TSchema> }).properties;
+
+    if (!properties || typeof value !== "object" || value === null || Array.isArray(value))
+        return value;
+
+    return Object.fromEntries(Object.entries(properties)
+        .filter(([key]) => (value as Record<string, unknown>)[key] !== undefined)
+        .map(([key, property]) => [key, pickedBySchema(property, (value as Record<string, JsonValue>)[key]!)]));
+};
+
+export const toolResultEventOf = (
+    event: { readonly type: EventType; readonly payload: JsonValue },
+): { type: EventType; payload: JsonValue } => ({
+    type: event.type,
+    payload: pickedBySchema(eventPayloads[event.type], event.payload),
+});
+
+export type ActorInputRequest = Static<typeof actorInputSchema>;
+
+export const enqueueActorInput = (
+    runtime: Orchestration,
+    context: CommandContext,
+    runId: string,
+    input: ActorInputRequest,
+): Array<{ type: string; payload: JsonValue }> => {
+    runtime.enqueueInput(context, runId, {
+        actorId: input.actor,
+        content: input.content,
+        artifactIds: input.artifactIds ?? [],
+        sourceEventIds: [],
+        subscriptionId: null,
+    });
+
+    return runtime.events(runId)
+        .filter((event) => event.commandId === context.commandId)
+        .map((event) => {
+            assertJsonValue(event.payload, `Event ${event.eventId} payload`);
+            return toolResultEventOf(event);
+        });
+};