@infinityi/engine-lib 1.0.0

package/dist/events/telemetry.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The `forge/telemetry` bridge for agent runs.
+ *
+ * Wraps the run loop in spans and metrics expressed entirely in terms of
+ * forge's `Telemetry` handle — engine-lib never invents its own observability
+ * surface. The stable application path is passing `telemetry` to `runAgent`.
+ * `createRunTelemetry`, span constants, and telemetry handle types are exported
+ * from `@infinityi/engine-lib/events` for advanced integrations and tests. Everything here
+ * is a no-op when no telemetry handle (or no tracer/meter) is supplied, so the
+ * library stays usable with zero wiring.
+ *
+ * Spans:
+ * - {@link SPAN_RUN} `agent.run` — one per {@link runAgent} call.
+ * - {@link SPAN_PROVIDER} `agent.provider.call` — one per provider turn.
+ * - {@link SPAN_TOOL} `agent.tool.execute` — one per tool execution.
+ *
+ * In buffered mode the run span is opened with `tracer.withSpan`, so it is the
+ * active context for the whole loop and the provider/tool spans (and the
+ * provider's own `tracedFetch` HTTP span) nest underneath it. In streaming mode
+ * the run span is opened with `tracer.startSpan` and ended on completion;
+ * child spans are still emitted but not nested under it.
+ *
+ * Metric names emitted by this bridge: `agent.run.duration` /
+ * `agent.tool.duration` (histograms, ms), `agent.tokens` (counter, tagged
+ * `token.type`), and `agent.runs` (counter, tagged outcome).
+ *
+ * @module
+ */
+import type { Usage } from "../providers/types";
+import type { TelemetryHandle } from "../runtime/types";
+/** Span name for the whole run. */
+export declare const SPAN_RUN = "agent.run";
+/** Span name for a single provider turn. */
+export declare const SPAN_PROVIDER = "agent.provider.call";
+/** Span name for a single tool execution. */
+export declare const SPAN_TOOL = "agent.tool.execute";
+/** Attribute bag accepted by spans and metrics (forge's common subset). */
+export type Attrs = Record<string, string | number | boolean>;
+/** A started span the loop ends manually; a no-op when telemetry is absent. */
+export interface SpanHandle {
+    setAttributes(attrs: Attrs): void;
+    ok(): void;
+    fail(message: string): void;
+    end(): void;
+}
+/** The telemetry surface the run loop drives. All methods are no-op safe. */
+export interface RunTelemetry {
+    /** Run `fn` inside `name` as the active context (nests children). */
+    withSpan<T>(name: string, attrs: Attrs, fn: (span: SpanHandle) => Promise<T>): Promise<T>;
+    /** Start `name`, parented to the current active span; caller ends it. */
+    startSpan(name: string, attrs: Attrs): SpanHandle;
+    /** Record run-level duration, outcome, and token usage. */
+    recordRun(attrs: Attrs, durationMs: number, usage: Usage): void;
+    /** Record one tool execution's duration. */
+    recordTool(attrs: Attrs, durationMs: number): void;
+}
+/**
+ * Build the {@link RunTelemetry} bridge from a forge telemetry handle.
+ * Returns a fully no-op implementation when no tracer/meter is available.
+ */
+export declare function createRunTelemetry(telemetry?: TelemetryHandle): RunTelemetry;

package/dist/events/types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Event-system contracts (Phase 6).
+ *
+ * A run already emits a {@link RunEvent} stream (Phase 4). Phase 6 adds the
+ * ability to attach **multiple independent subscribers** — UI streaming, an
+ * audit log, a metrics sink, a `forge/messaging` bridge — to a single run
+ * without coupling them to the runtime internals or to each other.
+ *
+ * A {@link RunSubscriber} is just a function of a {@link RunEvent}. Subscribers
+ * are dispatched by an {@link EventHub} (see {@link createEventHub}) in
+ * declaration order, awaited, and isolated: a subscriber that throws or rejects
+ * is reported but never aborts the run nor starves the other subscribers.
+ * `runAgent` registers `onEvent` first, then entries from `subscribers`.
+ *
+ * @module
+ */
+import type { RunEvent } from "../execution/types";
+/**
+ * An external observer of a run. May be sync or async; the hub awaits it so a
+ * slow subscriber applies back-pressure to the run (offload heavy work yourself
+ * if you don't want that).
+ */
+export type RunSubscriber = (event: RunEvent) => void | Promise<void>;
+/** Fans one {@link RunEvent} out to every registered {@link RunSubscriber}. */
+export interface EventHub {
+    /** Deliver `event` to all subscribers, in order, awaiting each. */
+    emit(event: RunEvent): Promise<void>;
+}
+/** Options for {@link createEventHub}. */
+export interface EventHubOptions {
+    /** Subscribers, dispatched in array order. `undefined` entries are ignored. */
+    readonly subscribers?: ReadonlyArray<RunSubscriber | undefined>;
+    /**
+     * Invoked when a subscriber throws/rejects (the run continues regardless).
+     * If this callback throws, that failure is swallowed so isolation is
+     * preserved.
+     */
+    readonly onSubscriberError?: (error: unknown, event: RunEvent, index: number) => void;
+}

package/dist/execution/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `@infinityi/engine-lib/execution` — the agent run loop.
+ *
+ * {@link runAgent} executes an {@link AgentDefinition} against its provider
+ * using provider-native tool calling, in buffered or streaming mode.
+ *
+ * @module
+ */
+export { DEFAULT_MAX_HANDOFFS, DEFAULT_MAX_STEPS, runAgent } from "./run";
+export { addUsage, emptyUsage } from "./usage";
+export type { AnyRunOptions, BufferedRunOptions, RunBridge, RunEvent, RunHandle, RunInput, RunOptions, RunResult, StreamingRunOptions, } from "./types";

package/dist/execution/index.js

@@ -0,0 +1,22 @@
+import"../index-kte2h4k2.js";
+import {
+  DEFAULT_MAX_HANDOFFS,
+  DEFAULT_MAX_STEPS,
+  addUsage,
+  emptyUsage,
+  runAgent
+} from "../index-pwr8179t.js";
+import"../index-yrqrxwjt.js";
+import"../index-fkr3rcq9.js";
+import"../index-02s1fjxr.js";
+import"../index-zfgr4xx3.js";
+import"../index-7690reng.js";
+import"../index-rentvdpp.js";
+import"../index-1p6mb2vz.js";
+export {
+  runAgent,
+  emptyUsage,
+  addUsage,
+  DEFAULT_MAX_STEPS,
+  DEFAULT_MAX_HANDOFFS
+};

package/dist/execution/run.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `runAgent` — the provider-native agent execution loop.
+ *
+ * Each step sends the conversation + the agent's tool schemas to the provider,
+ * appends the assistant turn, and — if the model requested tools — validates
+ * each call's arguments against its Phase-1 schema, dispatches the tools **in
+ * parallel** with per-call error isolation, appends the results, and loops.
+ * The loop ends when the model answers without tool calls, the step budget is
+ * exhausted (`MaxStepsExceededError`), or the run is cancelled
+ * (`CancelledError`).
+ *
+ * Buffered and streaming modes share one core async generator
+ * ({@link executeAgent}); the buffered path drives it to completion, the
+ * streaming path exposes it as a {@link RunHandle}.
+ *
+ * @module
+ */
+import type { AgentDefinition } from "../agent/types";
+import type { AnyRunOptions, BufferedRunOptions, RunHandle, RunResult, StreamingRunOptions } from "./types";
+/** Default cap on provider turns when {@link RunOptions.maxSteps} is omitted. */
+export declare const DEFAULT_MAX_STEPS = 16;
+/** Default cap on agent handoffs when {@link RunOptions.maxHandoffs} is omitted. */
+export declare const DEFAULT_MAX_HANDOFFS = 8;
+/**
+ * Run an agent to completion using the provider-native tool-calling loop.
+ *
+ * Buffered mode (default, or `stream: false`) resolves with a {@link RunResult}.
+ * Streaming mode (`stream: true`) returns a {@link RunHandle} you can
+ * `for await` over for {@link RunEvent}s, with `handle.completed` resolving to
+ * the final result. When `stream` is a non-literal boolean, the return type is
+ * `Promise<RunResult> | RunHandle`.
+ */
+export declare function runAgent(agent: AgentDefinition, opts?: BufferedRunOptions): Promise<RunResult>;
+export declare function runAgent(agent: AgentDefinition, opts: StreamingRunOptions): RunHandle;
+export declare function runAgent(agent: AgentDefinition, opts: AnyRunOptions): Promise<RunResult> | RunHandle;

package/dist/execution/types.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Types for the agent execution flow.
+ *
+ * {@link runAgent} drives the provider-native tool-calling loop. It runs in two
+ * shapes that share one core: *buffered* (returns a {@link RunResult}) and
+ * *streaming* (returns a {@link RunHandle} — an async-iterable of
+ * {@link RunEvent}s plus a `completed` promise). Both modes also feed
+ * {@link RunOptions.onEvent} and {@link RunOptions.subscribers}.
+ *
+ * `RunEvent["type"]` values are part of the public contract. Consumers should
+ * handle unknown future variants defensively if they want minor-version
+ * compatibility with newly added events.
+ *
+ * @module
+ */
+import type { AgentError } from "../errors";
+import type { Message } from "../messages/types";
+import type { FinishReason, Usage } from "../providers/types";
+import type { Logger, TelemetryHandle } from "../runtime/types";
+import type { GenerationSettings } from "../agent/types";
+import type { AgentRegistry } from "../agent/agent-registry";
+import type { ContextProvider, ContextWindowOptions } from "../context/types";
+import type { Session } from "../session/types";
+import type { ToolResult } from "../tools/types";
+import type { RunSubscriber } from "../events/types";
+/** New input for a run: raw text (→ a user message), a single message, or several. */
+export type RunInput = string | Message | Message[];
+/**
+ * A single event emitted over the course of a run.
+ *
+ * Ordering guarantees:
+ *
+ * - Every run starts with `run.start`.
+ * - Provider assistant turns are emitted as `message` events.
+ * - Streaming text is emitted as `token` before the assistant `message` that
+ *   contains the accumulated text.
+ * - Tool calls emit `tool.call`, then `tool.result`, then the corresponding
+ *   tool-result `message`.
+ * - Successful runs end with `run.finish`; failed runs emit `error` and then
+ *   reject/throw the same `AgentError`.
+ * - `agent.child` wraps events forwarded from sub-agent tools, and
+ *   `agent.handoff` marks a control transfer between agents.
+ */
+export type RunEvent = {
+    readonly type: "run.start";
+    readonly agent: string;
+} | {
+    readonly type: "message";
+    readonly message: Message;
+} | {
+    readonly type: "token";
+    readonly delta: string;
+} | {
+    readonly type: "tool.call";
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: unknown;
+} | {
+    readonly type: "tool.result";
+    readonly id: string;
+    readonly name: string;
+    readonly result: ToolResult;
+} | {
+    readonly type: "run.finish";
+    readonly result: RunResult;
+} | {
+    readonly type: "error";
+    readonly error: AgentError;
+}
+/**
+ * An event from a nested child run (e.g. a sub-agent invoked through
+ * {@link RunBridge}). `agent` is the child's name and `depth` is its nesting
+ * level relative to this run (1 for a direct child). Parent subscribers that
+ * don't care about nesting can ignore this variant; those that do can recurse
+ * into `event`.
+ */
+ | {
+    readonly type: "agent.child";
+    readonly agent: string;
+    readonly depth: number;
+    readonly event: RunEvent;
+}
+/**
+ * The active agent handed the run off to another agent (Phase 7). `from` and
+ * `to` are agent names. Emitted at the switch point; the message history is
+ * preserved across the handoff.
+ */
+ | {
+    readonly type: "agent.handoff";
+    readonly from: string;
+    readonly to: string;
+};
+/**
+ * A handle the run loop hands to a tool so it can participate in its parent run:
+ * forward nested {@link RunEvent}s onto the parent's event stream and fold
+ * nested token {@link Usage} into the parent run's aggregate. Used by
+ * sub-agent-as-tool (`asTool`) to propagate a child run's events and usage
+ * upward. Tools that ignore it behave exactly as before.
+ */
+export interface RunBridge {
+    /** Forward a nested event onto the parent run's event stream. */
+    emit(event: RunEvent): void;
+    /** Add token usage from nested work into the parent run's running total. */
+    reportUsage(usage: Usage): void;
+}
+/** Options for a single {@link runAgent} call. */
+export interface RunOptions {
+    /** New input for this run. */
+    readonly input?: RunInput;
+    /** Prior conversation prepended before `input`. Ignored when `session` is set (history comes from the session). */
+    readonly messages?: Message[];
+    /** Durable conversation: history is read before the run and new messages appended after it. */
+    readonly session?: Session;
+    /** Context providers injected into the system layer at run time (after instructions, before history). */
+    readonly context?: readonly ContextProvider[];
+    /** Token budgeting for the messages sent to the provider (does not affect persisted/returned history). */
+    readonly contextWindow?: ContextWindowOptions;
+    /** Per-run generation overrides, merged over the agent's `generation` defaults. */
+    readonly generation?: GenerationSettings;
+    /** Cap on provider turns (model→tools→model cycles). Defaults to {@link DEFAULT_MAX_STEPS}. */
+    readonly maxSteps?: number;
+    /** Stream tokens + tool lifecycle. Omitted/`false` → buffered `Promise<RunResult>`. */
+    readonly stream?: boolean;
+    /** Event sink invoked for every {@link RunEvent}, in both buffered and streaming modes. */
+    readonly onEvent?: (event: RunEvent) => void;
+    /**
+     * Additional independent event subscribers (UI streaming, audit log, metrics,
+     * a `forge/messaging` bridge). Dispatched after {@link RunOptions.onEvent}, in
+     * order, awaited per event. A subscriber that throws/rejects is isolated — it
+     * neither aborts the run nor starves the others.
+     */
+    readonly subscribers?: readonly RunSubscriber[];
+    /** Forge telemetry handle, threaded to provider calls / tools / hooks. */
+    readonly telemetry?: TelemetryHandle;
+    /** Structured logger (defaults to `telemetry.log`). */
+    readonly logger?: Logger;
+    /** Cancellation signal; halts the loop and in-flight provider/tool calls. */
+    readonly signal?: AbortSignal;
+    /**
+     * Cap on agent handoffs in a single run, to bound triage↔specialist
+     * ping-pong (Phase 7). Defaults to {@link DEFAULT_MAX_HANDOFFS}. Exceeding it
+     * throws {@link MaxHandoffsExceededError}.
+     */
+    readonly maxHandoffs?: number;
+    /**
+     * Registry used to resolve string-named {@link AgentDefinition.handoffs}
+     * targets (Phase 7). Not needed when every handoff target is given directly
+     * as an {@link AgentDefinition}.
+     */
+    readonly registry?: AgentRegistry;
+}
+/** Options for buffered mode. This is the default when `stream` is omitted. */
+export type BufferedRunOptions = Omit<RunOptions, "stream"> & {
+    readonly stream?: false | undefined;
+};
+/** Options for streaming mode. */
+export type StreamingRunOptions = Omit<RunOptions, "stream"> & {
+    readonly stream: true;
+};
+/**
+ * Options for callers that decide streaming dynamically. Passing this shape to
+ * `runAgent` returns `Promise<RunResult> | RunHandle`.
+ */
+export type AnyRunOptions = Omit<RunOptions, "stream"> & {
+    readonly stream?: boolean;
+};
+/** The buffered result of a completed run. */
+export interface RunResult {
+    /** Concatenated text of the final assistant message. */
+    readonly output: string;
+    /** The final assistant message. */
+    readonly finalMessage: Message;
+    /** Full history: prior messages + input + every assistant turn + tool results. */
+    readonly messages: Message[];
+    /** Why the loop ended. */
+    readonly finishReason: FinishReason;
+    /** Number of provider turns taken. */
+    readonly steps: number;
+    /** Token usage aggregated across all turns (zeros when unreported). */
+    readonly usage: Usage;
+    /**
+     * Name of the agent that produced the final answer (Phase 7). Equals the
+     * agent passed to {@link runAgent} unless the run handed off to another.
+     */
+    readonly agent: string;
+    /**
+     * Ordered trail of agent names the run handed off to (Phase 7). Empty when no
+     * handoff occurred; the final entry equals {@link RunResult.agent}.
+     */
+    readonly handoffs: readonly string[];
+}
+/**
+ * A streaming run: an async-iterable of {@link RunEvent}s, plus `completed`
+ * which resolves with the final {@link RunResult} once the stream is fully
+ * consumed (the same result is also delivered as the `run.finish` event).
+ *
+ * If iteration throws, `completed` rejects with the same error. If the consumer
+ * abandons iteration before a terminal event, `completed` rejects with
+ * `CancelledError`.
+ */
+export type RunHandle = AsyncIterable<RunEvent> & {
+    readonly completed: Promise<RunResult>;
+};

package/dist/execution/usage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Usage aggregation across the turns of a run.
+ *
+ * Provider {@link Usage} is reported per turn (and may be absent); the run loop
+ * folds each turn's usage into a running total so {@link RunResult.usage}
+ * reflects the whole run.
+ *
+ * @module
+ */
+import type { Usage } from "../providers/types";
+/** A zeroed {@link Usage} accumulator. */
+export declare function emptyUsage(): Usage;
+/** Field-wise sum of two {@link Usage} values; optional fields appear only when present. */
+export declare function addUsage(a: Usage, b?: Usage): Usage;

package/dist/index-02s1fjxr.js

@@ -0,0 +1,226 @@
+import {
+  SchemaValidationError
+} from "./index-7690reng.js";
+
+// src/schema/validate.ts
+function issue(path, message) {
+  return { path: [...path], message };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateJsonSchema(node, input, path = []) {
+  const issues = [];
+  if (node.enum !== undefined) {
+    if (!node.enum.includes(input)) {
+      issues.push(issue(path, `expected one of ${JSON.stringify(node.enum)}`));
+    }
+    return issues;
+  }
+  switch (node.type) {
+    case "string":
+      if (typeof input !== "string")
+        issues.push(issue(path, "expected string"));
+      break;
+    case "boolean":
+      if (typeof input !== "boolean")
+        issues.push(issue(path, "expected boolean"));
+      break;
+    case "null":
+      if (input !== null)
+        issues.push(issue(path, "expected null"));
+      break;
+    case "number":
+      if (typeof input !== "number" || Number.isNaN(input)) {
+        issues.push(issue(path, "expected number"));
+      }
+      break;
+    case "integer":
+      if (typeof input !== "number" || !Number.isInteger(input)) {
+        issues.push(issue(path, "expected integer"));
+      }
+      break;
+    case "array": {
+      if (!Array.isArray(input)) {
+        issues.push(issue(path, "expected array"));
+        break;
+      }
+      if (node.items !== undefined) {
+        input.forEach((element, index) => {
+          issues.push(...validateJsonSchema(node.items, element, [...path, index]));
+        });
+      }
+      break;
+    }
+    case "object": {
+      if (!isPlainObject(input)) {
+        issues.push(issue(path, "expected object"));
+        break;
+      }
+      const properties = node.properties ?? {};
+      const required = node.required ?? [];
+      for (const key of required) {
+        if (input[key] === undefined) {
+          issues.push(issue([...path, key], "required"));
+        }
+      }
+      for (const [key, propSchema] of Object.entries(properties)) {
+        const value = input[key];
+        if (value === undefined)
+          continue;
+        issues.push(...validateJsonSchema(propSchema, value, [...path, key]));
+      }
+      if (node.additionalProperties === false) {
+        for (const key of Object.keys(input)) {
+          if (!(key in properties)) {
+            issues.push(issue([...path, key], "unexpected property"));
+          }
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return issues;
+}
+
+// src/schema/builder.ts
+var optionalSchemas = new WeakSet;
+function makeSchema(jsonSchema) {
+  return {
+    jsonSchema,
+    safeParse(input) {
+      const issues = validateJsonSchema(jsonSchema, input);
+      if (issues.length === 0)
+        return { success: true, data: input };
+      return {
+        success: false,
+        error: new SchemaValidationError("schema validation failed", { issues })
+      };
+    },
+    parse(input) {
+      const result = this.safeParse(input);
+      if (!result.success)
+        throw result.error;
+      return result.data;
+    }
+  };
+}
+var s = {
+  string(opts) {
+    const node = { type: "string" };
+    if (opts?.description !== undefined)
+      node.description = opts.description;
+    if (opts?.enum !== undefined)
+      node.enum = opts.enum;
+    return makeSchema(node);
+  },
+  number(opts) {
+    const node = { type: opts?.int ? "integer" : "number" };
+    if (opts?.description !== undefined)
+      node.description = opts.description;
+    return makeSchema(node);
+  },
+  boolean(opts) {
+    const node = { type: "boolean" };
+    if (opts?.description !== undefined)
+      node.description = opts.description;
+    return makeSchema(node);
+  },
+  enum(values, opts) {
+    const node = { type: "string", enum: values };
+    if (opts?.description !== undefined)
+      node.description = opts.description;
+    return makeSchema(node);
+  },
+  array(item, opts) {
+    const node = { type: "array", items: item.jsonSchema };
+    if (opts?.description !== undefined)
+      node.description = opts.description;
+    return makeSchema(node);
+  },
+  object(props, opts) {
+    const properties = {};
+    const required = [];
+    for (const [key, prop] of Object.entries(props)) {
+      properties[key] = prop.jsonSchema;
+      if (!optionalSchemas.has(prop))
+        required.push(key);
+    }
+    const node = {
+      type: "object",
+      properties,
+      additionalProperties: false
+    };
+    if (required.length > 0)
+      node.required = required;
+    if (opts?.description !== undefined)
+      node.description = opts.description;
+    return makeSchema(node);
+  },
+  optional(inner) {
+    const schema = {
+      jsonSchema: inner.jsonSchema,
+      safeParse(input) {
+        if (input === undefined)
+          return { success: true, data: undefined };
+        return inner.safeParse(input);
+      },
+      parse(input) {
+        const result = this.safeParse(input);
+        if (!result.success)
+          throw result.error;
+        return result.data;
+      }
+    };
+    optionalSchemas.add(schema);
+    return schema;
+  }
+};
+// src/schema/json-schema.ts
+function toJsonSchema(schema) {
+  return schema.jsonSchema;
+}
+function asSchema(impl) {
+  return {
+    jsonSchema: impl.jsonSchema,
+    parse: impl.parse.bind(impl),
+    safeParse: impl.safeParse?.bind(impl) ?? ((input) => {
+      try {
+        return { success: true, data: impl.parse(input) };
+      } catch (error) {
+        if (error instanceof SchemaValidationError)
+          return { success: false, error };
+        return {
+          success: false,
+          error: new SchemaValidationError("schema validation failed", {
+            cause: error,
+            issues: [{ path: [], message: String(error) }]
+          })
+        };
+      }
+    })
+  };
+}
+function fromJsonSchema(jsonSchema) {
+  return {
+    jsonSchema,
+    safeParse(input) {
+      const issues = validateJsonSchema(jsonSchema, input);
+      if (issues.length === 0)
+        return { success: true, data: input };
+      return {
+        success: false,
+        error: new SchemaValidationError("schema validation failed", { issues })
+      };
+    },
+    parse(input) {
+      const result = this.safeParse(input);
+      if (!result.success)
+        throw result.error;
+      return result.data;
+    }
+  };
+}
+export { validateJsonSchema, s, toJsonSchema, asSchema, fromJsonSchema };

package/dist/index-1p6mb2vz.js

@@ -0,0 +1,32 @@
+// src/messages/factory.ts
+function text(value) {
+  return { type: "text", text: value };
+}
+function normalizeContent(content) {
+  return typeof content === "string" ? [text(content)] : content;
+}
+function system(content) {
+  return { role: "system", content: normalizeContent(content) };
+}
+function user(content) {
+  return { role: "user", content: normalizeContent(content) };
+}
+function assistant(content) {
+  return { role: "assistant", content: normalizeContent(content) };
+}
+function toolResult(toolCallId, output, opts) {
+  const content = typeof output === "string" ? [text(output)] : output;
+  return {
+    role: "tool",
+    content: [
+      {
+        type: "tool_result",
+        toolCallId,
+        content,
+        ...opts?.isError !== undefined ? { isError: opts.isError } : {}
+      }
+    ]
+  };
+}
+
+export { text, normalizeContent, system, user, assistant, toolResult };