agentfootprint 10.3.1 → 10.5.0

package/dist/types/ag-ui/adapter.d.ts

@@ -0,0 +1,119 @@
+/**
+ * adapter — AG-UI as a protocol adapter: what `streamHandler` takes to serve
+ * runs to any AG-UI frontend — or to a gateway that speaks AG-UI in its own
+ * request body and its own envelope.
+ *
+ * Three strategies, each replaceable on its own, around one CORE that is not:
+ *   - the READER — a request body → the turn it asks for (`reader`; default:
+ *     the body is a `RunAgentInput`). Mapping only;
+ *   - the TRANSLATION — one run's served events → AG-UI events (`translation`;
+ *     default `agUiSerializer`, tuned by `custom` and `reasoning`), one per
+ *     request;
+ *   - the FRAMING — AG-UI events → bytes (`framing`; default `agUiSse`,
+ *     `encoder` for bundles). The host numbers each stream's frames and hands
+ *     the number to the framing, so a gateway envelope's sequence is per run.
+ *   - the CORE (`request.ts`), whichever reader ran: the request's shape and
+ *     ids checked as plain JSON, a system/developer message refused, frontend
+ *     tools only by the app's allow-list, `state`/`context` only through the
+ *     app's validators (`accept`), an answer only for the pause the server
+ *     keeps. No strategy can reach past it.
+ *
+ * Holds no state between requests: its options are read once and frozen, and
+ * every request gets its own translation and its own frontend tools.
+ */
+import type { ProtocolAdapter, RunTranslation } from '../hosting/protocolAdapter.js';
+import type { SseFraming } from '../hosting/stream.js';
+import { type AgUiEncoderModule } from './framing.js';
+import { type AgUiFrontendTool } from './frontendTools.js';
+import { type AgUiRequestReader, type AgUiValidator } from './request.js';
+import { type AgUiSerializerOptions } from './serializer.js';
+import type { AgUiEvent, AgUiRunInput, AgUiSuspension } from './types.js';
+/** What a translation is opened with — one run's ids, and the pause it continues. */
+export interface AgUiTranslationRun {
+    /** The conversation the request named (already format-checked). */
+    readonly threadId: string;
+    /** The run id the request named (already format-checked). */
+    readonly runId: string;
+    /** The paused run this one continues — its translation's `suspension()`, as the server kept it. */
+    readonly resume?: AgUiSuspension;
+}
+/**
+ * The translation strategy: opens ONE run's translation — the run's served
+ * events → AG-UI events. Default: `agUiSerializer`. Called once per request;
+ * a translation it returns is fed only that request's run. One that pauses
+ * hands out an `AgUiSuspension` from `suspension()`, or the core cannot match
+ * the next request's answer to the pause and refuses it.
+ */
+export type AgUiTranslationStrategy = (run: AgUiTranslationRun) => RunTranslation<AgUiEvent>;
+/** Options for {@link agUi}. */
+export interface AgUiOptions {
+    /**
+     * The tools a page may run, allow-listed by NAME with the app's own contract
+     * (description, input schema) — never the page's. A request that declares a
+     * tool not listed here is refused by name; one listed here and declared by
+     * the page is handed to the agent factory (`StreamRunContext.tools`) for that
+     * request. Needs a host that keeps the paused run (`threads` + `sessions`).
+     */
+    readonly frontendTools?: Readonly<Record<string, AgUiFrontendTool>>;
+    /**
+     * The page's `state` and `context` reach the agent only through these: each
+     * gets the value and the bound thread, and returns what the agent is given
+     * (`StreamRunContext.accepted`) — or throws a `WireRequestRefusal`. Without
+     * one, a request carrying a non-empty value is refused by name.
+     */
+    readonly accept?: {
+        readonly state?: AgUiValidator;
+        readonly context?: AgUiValidator;
+    };
+    /**
+     * How a request body becomes the turn it asks for ({@link AgUiRequestReader}).
+     * Default: the body is an AG-UI `RunAgentInput`. A gateway that sends its own
+     * body passes a reader that maps it. The reader only MAPS: what it produces is
+     * checked by the same core as a `RunAgentInput` — shape and ids, no system or
+     * developer message, frontend tools by `frontendTools`, `state`/`context` by
+     * `accept`, an answer only for the pause the server keeps.
+     */
+    readonly reader?: AgUiRequestReader;
+    /**
+     * How one run's served events become AG-UI events ({@link AgUiTranslationStrategy}).
+     * Default: `agUiSerializer` with `custom` and `reasoning`. Refused together
+     * with either, which tune the default only.
+     */
+    readonly translation?: AgUiTranslationStrategy;
+    /** The CUSTOM allow-list — see {@link AgUiSerializerOptions.custom}. */
+    readonly custom?: AgUiSerializerOptions['custom'];
+    /** Write the model's reasoning — see {@link AgUiSerializerOptions.reasoning}. */
+    readonly reasoning?: boolean;
+    /**
+     * How each AG-UI event is written ({@link SseFraming}). Default: `agUiSse()`,
+     * the official `@ag-ui/encoder`'s frames. A gateway that expects its own
+     * envelope passes a framing that writes it; the frame's number in its stream
+     * arrives as `frame(event, { sequence })`, counted by the host per stream —
+     * keep no counter in the framing. Refused together with `encoder`, which
+     * feeds the default only.
+     */
+    readonly framing?: SseFraming<AgUiEvent>;
+    /** `@ag-ui/encoder`, imported by you — for a bundle this package cannot load it in. */
+    readonly encoder?: AgUiEncoderModule;
+}
+/**
+ * The AG-UI protocol adapter. Hand it to a host:
+ *
+ * @example
+ * ```ts
+ * import { memorySessions, streamHandler } from 'agentfootprint/hosting';
+ * import { agUi } from 'agentfootprint/ag-ui';
+ *
+ * export const POST = streamHandler({
+ *   agent: ({ tools }) => Agent.create({ provider, model }).tools([...mine, ...tools]).build(),
+ *   adapter: agUi(),
+ *   threads: { bind: ({ conversation, headers }) => bindToSignedInUser(conversation, headers) },
+ *   sessions: memorySessions(),
+ * });
+ * ```
+ *
+ * @throws TypeError at construction for a frontend tool whose name or contract
+ *   is not usable, and a validator that is not a function.
+ */
+export declare function agUi(options?: AgUiOptions): ProtocolAdapter<AgUiRunInput, AgUiEvent>;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/types/ag-ui/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/ag-ui/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACrF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAW,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAKL,KAAK,iBAAiB,EACtB,KAAK,aAAa,EACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAkB,KAAK,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAC7E,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE1E,qFAAqF;AACrF,MAAM,WAAW,kBAAkB;IACjC,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mGAAmG;IACnG,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;CAClC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,GAAG,EAAE,kBAAkB,KAAK,cAAc,CAAC,SAAS,CAAC,CAAC;AAE7F,gCAAgC;AAChC,MAAM,WAAW,WAAW;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;IACpE;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE;QAChB,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;QAC/B,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;KAClC,CAAC;IACF;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,iBAAiB,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,uBAAuB,CAAC;IAC/C,wEAAwE;IACxE,QAAQ,CAAC,MAAM,CAAC,EAAE,qBAAqB,CAAC,QAAQ,CAAC,CAAC;IAClD,iFAAiF;IACjF,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;IACzC,uFAAuF;IACvF,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,WAAgB,GAAG,eAAe,CAAC,YAAY,EAAE,SAAS,CAAC,CA2BxF"}

package/dist/types/ag-ui/framing.d.ts

@@ -0,0 +1,53 @@
+/**
+ * framing — AG-UI events → Server-Sent Events frames: the second framing
+ * strategy beside `toSSE`'s own (`hosting/stream.ts` · `agentfootprintSse`).
+ *
+ * The frames are written by the official encoder, `@ag-ui/encoder`'s
+ * `EventEncoder.encodeSSE` — a `data:` line holding the event's JSON, nothing
+ * else — so a frame here is byte for byte what an AG-UI SDK writes and an AG-UI
+ * client reads. The encoder is an OPTIONAL peer: it loads when a framing is
+ * built (never when this module is imported), and a missing package is refused
+ * at that moment by name, with the install line. A runtime whose loader cannot
+ * reach it (a browser or edge bundle) passes the module it imported instead.
+ *
+ * Every value inside an event already passed the wire rule
+ * (`lib/wireJson.ts`): the serializer renders an `Error` as its name, message
+ * and code before an event is built, so the encoder's own `JSON.stringify`
+ * never meets one.
+ */
+import type { SseFraming } from '../hosting/stream.js';
+import type { AgUiEvent } from './types.js';
+/** What this framing needs from `@ag-ui/encoder` — its `EventEncoder`, structurally. */
+export interface AgUiEncoderModule {
+    readonly EventEncoder: new () => {
+        encodeSSE(event: never): string;
+    };
+}
+/** Options for {@link agUiSse}. */
+export interface AgUiSseOptions {
+    /**
+     * `@ag-ui/encoder`, imported by you — for a runtime where this package cannot
+     * load it with its Node loader (a browser or edge bundle):
+     * `import * as encoder from '@ag-ui/encoder'; agUiSse({ encoder })`.
+     * Absent, the package is loaded here, once per framing.
+     */
+    readonly encoder?: AgUiEncoderModule;
+}
+/** The refusal for a missing `@ag-ui/encoder` — stated once, so every site says the same. */
+export declare const AG_UI_ENCODER_MISSING: string;
+/**
+ * The AG-UI framing strategy: each AG-UI event → one `data: <json>` frame, as
+ * `@ag-ui/encoder` writes it, under `text/event-stream`.
+ *
+ * @throws Error when `@ag-ui/encoder` is not installed (or cannot be loaded
+ *   here) and no `encoder` was passed — the message names the install line.
+ *
+ * @example
+ * ```ts
+ * const framing = agUiSse();
+ * let sequence = 0; // this stream's own count
+ * for (const event of serializer.event(e)) res.write(framing.frame(event, { sequence: ++sequence }));
+ * ```
+ */
+export declare function agUiSse(options?: AgUiSseOptions): SseFraming<AgUiEvent>;
+//# sourceMappingURL=framing.d.ts.map

package/dist/types/ag-ui/framing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framing.d.ts","sourceRoot":"","sources":["../../../src/ag-ui/framing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,wFAAwF;AACxF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,YAAY,EAAE,UAAU;QAAE,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAA;KAAE,CAAC;CACtE;AAED,mCAAmC;AACnC,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;CACtC;AAED,6FAA6F;AAC7F,eAAO,MAAM,qBAAqB,QAG0B,CAAC;AAE7D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,OAAO,GAAE,cAAmB,GAAG,UAAU,CAAC,SAAS,CAAC,CAc3E"}

package/dist/types/ag-ui/frontendTools.d.ts

@@ -0,0 +1,38 @@
+/**
+ * frontendTools — tools the PAGE runs (AG-UI "frontend tools"), as tools an
+ * agent can be given.
+ *
+ * A frontend tool does its work in the browser: a date picker, a confirmation
+ * dialog, a chart the person adjusts. The server never runs it. Its tool here
+ * has no body: a call PAUSES the run, the page receives the call
+ * (`RUN_FINISHED { outcome: success, pendingToolCallIds }`), runs it, and sends
+ * the result as a `tool` message in its next request, which continues the
+ * paused run with that result as the call's answer.
+ *
+ * WHAT IT CAN NEVER DO. The tool runs nothing on the server, so it holds no
+ * server privilege: no credential (`needs`), no artifact (`wants`), no
+ * capability. Its NAME and its contract (description, input schema) are the
+ * APP's — `agUi({ frontendTools })` allow-lists it — never the page's: a
+ * description the model reads is an instruction, and a page does not get to
+ * write the agent's instructions. A page that declares a tool the app did not
+ * list is refused by name. Its result is the page's word, read by the model
+ * like any tool result.
+ */
+import { type Tool } from '../tools/tools.js';
+/** A frontend tool's contract, as the APP declares it. */
+export interface AgUiFrontendTool {
+    /** What the tool does, in the words the model reads. */
+    readonly description: string;
+    /** The JSON Schema of its arguments. */
+    readonly inputSchema: Readonly<Record<string, unknown>>;
+}
+/**
+ * Check the app's frontend tools at construction and return, per name, how to
+ * build the tool an agent is given — fresh for every request.
+ *
+ * @throws TypeError naming the tool when its name or contract is not usable.
+ */
+export declare function frontendToolBuilders(declared: Readonly<Record<string, AgUiFrontendTool>> | undefined): ReadonlyMap<string, () => Tool>;
+/** Does this pause wait on the page — a frontend tool's call? Read from the pause's own data. */
+export declare function isFrontendToolPause(pauseData: unknown): boolean;
+//# sourceMappingURL=frontendTools.d.ts.map

package/dist/types/ag-ui/frontendTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontendTools.d.ts","sourceRoot":"","sources":["../../../src/ag-ui/frontendTools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAc,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAG1D,0DAA0D;AAC1D,MAAM,WAAW,gBAAgB;IAC/B,wDAAwD;IACxD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wCAAwC;IACxC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACzD;AAQD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,GAAG,SAAS,GAC/D,WAAW,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,CAgCjC;AAED,iGAAiG;AACjG,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,OAAO,GAAG,OAAO,CAM/D"}

package/dist/types/ag-ui/ids.d.ts

@@ -0,0 +1,44 @@
+/**
+ * ids — every id the AG-UI adapter mints, from ONE grammar.
+ *
+ *   <run>/<kind>/<n>/<address>
+ *
+ *   run      the AG-UI `runId`, through `encodeIdentityField` — `%` and `/`
+ *            escaped, so it holds no `/`;
+ *   kind     one of {@link AgUiIdKind} — no `/`;
+ *   n        a decimal ordinal — no `/`;
+ *   address  the agentfootprint `runtimeStageId` of the event that opened the
+ *            entity (`call-llm#18`, `step-p/x/tool-calls#97`) — any string.
+ *
+ * INJECTIVE by construction: the first three `/` end the three segments that
+ * cannot hold one, so two different (run, kind, n, address) tuples never spell
+ * the same id. `test/ag-ui/ids.test.ts` pins it with a property test.
+ *
+ * WHY THE ADDRESS, NOT THE PROVIDER'S ID. A model's tool-call id is not unique
+ * in a run: a provider may reuse it across iterations, and two parallel branches
+ * routinely mint the same one (`call_1`, `c1`). An AG-UI client finds a tool
+ * call by its id across the WHOLE conversation, so a reused id would land a new
+ * call's arguments on an old message. And under a redaction policy the record
+ * serves every id as the placeholder. The address — the stage execution that
+ * produced the entity, unique within a run — is unique, survives redaction (it
+ * is the record's own key, never a value a policy selects) and lines up with the
+ * recording; the run segment makes it unique across the thread. The provider's
+ * id, as the record serves it, rides `metadata.agentfootprint.toolCallId`.
+ */
+/** The kinds of entity the adapter mints ids for. */
+export type AgUiIdKind = 'text' | 'reasoning' | 'tool' | 'result' | 'agent' | 'interrupt';
+/** One run's minter: ordinals counted per (kind, address), ids spelled by {@link agUiId}. */
+export interface AgUiIdMinter {
+    /** The next id of `kind` at `address` — `n` counts up from 0 per (kind, address). */
+    next(kind: AgUiIdKind, address: string): {
+        readonly id: string;
+        readonly n: number;
+    };
+    /** The id of `kind` at `address` with a KNOWN ordinal — a tool result reuses its call's. */
+    at(kind: AgUiIdKind, n: number, address: string): string;
+}
+/** Spell one id. Exported for the property test; the minter is the only caller. */
+export declare function agUiId(runId: string, kind: AgUiIdKind, n: number, address: string): string;
+/** A minter for the AG-UI run `runId`. Refuses an empty run id: it would mint `_` ids. */
+export declare function agUiIdMinter(runId: string): AgUiIdMinter;
+//# sourceMappingURL=ids.d.ts.map

package/dist/types/ag-ui/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../../src/ag-ui/ids.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,qDAAqD;AACrD,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,WAAW,CAAC;AAE1F,6FAA6F;AAC7F,MAAM,WAAW,YAAY;IAC3B,qFAAqF;IACrF,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACrF,4FAA4F;IAC5F,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1D;AAED,mFAAmF;AACnF,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1F;AAED,0FAA0F;AAC1F,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAgBxD"}

package/dist/types/ag-ui/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ag-ui — the AG-UI protocol adapter over agentfootprint's event stream.
+ *
+ * `agUi()` is the adapter a host takes (`streamHandler` on
+ * `agentfootprint/hosting`): it reads an untrusted request (a `RunAgentInput`,
+ * or a gateway's own body through a `reader`), plans the turn against what the
+ * server holds, translates the run and frames it (`agUiSse`, or a gateway's
+ * own envelope through `framing`).
+ * `agUiSerializer` turns one run's served events into AG-UI events; `agUiSse`
+ * frames them for the wire with the official `@ag-ui/encoder`. Published
+ * through the `agentfootprint/ag-ui` door. The fixed sentences and the id
+ * grammar stay internal — tests import them by module path.
+ */
+export { agUiSerializer, AG_UI_CUSTOM_EVENTS, type AgUiCustomContext, type AgUiCustomProjection, type AgUiSerializerOptions, type AgUiTranslation, } from './serializer.js';
+export { agUiSse, type AgUiEncoderModule, type AgUiSseOptions } from './framing.js';
+export { agUi, type AgUiOptions, type AgUiTranslationRun, type AgUiTranslationStrategy, } from './adapter.js';
+export type { AgUiFrontendTool } from './frontendTools.js';
+export { AG_UI_MAX_ID_LENGTH, readAgUiRunInput, type AgUiRequestFacts, type AgUiRequestReader, type AgUiTurnRequest, type AgUiValidator, } from './request.js';
+export { AG_UI_PROTOCOL_VERSION, type AgUiAddress, type AgUiEvent, type AgUiEventType, type AgUiInterrupt, type AgUiMessage, type AgUiMetadata, type AgUiResumeEntry, type AgUiRunInput, type AgUiRunOutcome, type AgUiSuspendedCall, type AgUiSuspendedScope, type AgUiSuspension, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ag-ui/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ag-ui/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,GACrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,OAAO,EAAE,KAAK,iBAAiB,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AACpF,OAAO,EACL,IAAI,EACJ,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,GAC7B,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,aAAa,GACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,sBAAsB,EACtB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,cAAc,GACpB,MAAM,YAAY,CAAC"}

package/dist/types/ag-ui/request.d.ts

@@ -0,0 +1,152 @@
+/**
+ * request — an AG-UI request (`RunAgentInput`) read as UNTRUSTED browser input,
+ * and the one turn it may ask for.
+ *
+ * Three steps. The first is the app's to replace; the other two are the CORE,
+ * and run whichever reader produced the request — so a reader can map another
+ * body onto a turn, and never weaken a rule:
+ *
+ *   the READER         a body → an {@link AgUiTurnRequest}. The default takes
+ *                      the body as an AG-UI `RunAgentInput`; a gateway that
+ *                      sends its own body shape passes its own
+ *                      ({@link AgUiRequestReader}). Mapping only — it decides
+ *                      nothing below;
+ *   readAgUiRequest    what a custom reader produced, copied as plain JSON (so
+ *                      a getter or a proxy cannot answer the check one way and
+ *                      the plan another; the default reader's body is parsed
+ *                      JSON already and is read as it is), then
+ *   readAgUiRunInput   its SHAPE, field by field, and
+ *                      the ids' FORMAT and length — nothing here is trusted,
+ *                      nothing the server holds is read;
+ *   planAgUiTurn       the turn, from the request AND what the server holds
+ *                      for the bound conversation.
+ *
+ * The core's steps refuse by NAME (a `WireRequestRefusal`: its own status and
+ * code; the field named, the value never quoted back).
+ *
+ * WHAT A REQUEST MAY DECIDE, and what it may not:
+ *   - the newest USER message is the run's message. Nothing else the browser
+ *     sends is ever conversation: its assistant and tool messages are its own
+ *     copy of what the server said, and the server's copy is the one kept
+ *     (`sessions`, or the agent's memory under the bound session). A system or
+ *     developer message is refused — the agent's instructions are its own;
+ *   - an ANSWER is taken only for the pause the server is keeping, matched to
+ *     the ids that pause handed out (`AgUiSuspension`): a resume entry naming
+ *     its interrupt, or the tool message answering the frontend tool call it is
+ *     waiting on. Any other tool result is refused — never folded in;
+ *   - a frontend tool runs only when the app allow-listed its NAME — with the
+ *     app's own description and schema, never the page's (a description the
+ *     model reads is an instruction) — and only on a host that keeps the paused
+ *     run until the page answers;
+ *   - `state` and `context` reach the agent only through the app's validators;
+ *     without one, a request carrying either is refused;
+ *   - identity, credentials and redaction never come from a request: the host
+ *     binds the thread to the caller the app authenticates (`ThreadBinder`).
+ * `forwardedProps` is never read.
+ */
+import type { HeldConversation, PlanFacts, ProtocolPlan, ProtocolRequestFacts, ThreadBinding } from '../hosting/protocolAdapter.js';
+import type { Tool } from '../tools/tools.js';
+import type { AgUiMessage, AgUiResumeEntry, AgUiRunInput, AgUiSuspension } from './types.js';
+/** The longest thread or run id read — longer is refused, never truncated. */
+export declare const AG_UI_MAX_ID_LENGTH = 128;
+/**
+ * Read one AG-UI request body — its shape and its ids — refusing what the
+ * protocol does not allow by the field's NAME, never by its value.
+ *
+ * @throws WireRequestRefusal (400, `ERR_INVALID_RUN_INPUT`)
+ */
+export declare function readAgUiRunInput(body: unknown): AgUiRunInput;
+/**
+ * What a request reader hands the core: the one turn a request asks for, in
+ * AG-UI's terms. `AgUiRunInput` is one (a `RunAgentInput` as sent); a reader
+ * for another body builds one from it — `tools` and `context` may be left out.
+ *
+ * It carries no identity, credential or redaction setting, and the core reads
+ * nothing else a reader adds: the caller is bound by the host's `ThreadBinder`,
+ * a credential reaches a run only through the host's `sealRequest`.
+ */
+export interface AgUiTurnRequest {
+    /** The conversation the request NAMES — format-checked, never a key. */
+    readonly threadId: string;
+    /** The run id the stream names this run by — format-checked. */
+    readonly runId: string;
+    readonly parentRunId?: string;
+    /**
+     * The messages, newest last. Only the newest is read — a user message (the
+     * run's message), or the `tool` message answering the frontend tool call a
+     * paused run waits on. A system or developer message anywhere is refused.
+     */
+    readonly messages: readonly AgUiMessage[];
+    /** The frontend tools the caller offers — run only when the app allow-listed the name. */
+    readonly tools?: AgUiRunInput['tools'];
+    /** Reaches the agent only through the app's `accept.context` validator. */
+    readonly context?: AgUiRunInput['context'];
+    /** Reaches the agent only through the app's `accept.state` validator. */
+    readonly state?: unknown;
+    /** Answers to the interrupt a paused run waits on — matched to the server's own record. */
+    readonly resume?: readonly AgUiResumeEntry[];
+}
+/**
+ * What a request reader is given: the request as the host read it — UNTRUSTED.
+ * The host port's own `ProtocolRequestFacts` (the parsed body, the headers).
+ */
+export type AgUiRequestFacts = ProtocolRequestFacts;
+/**
+ * The request-reading strategy: a body → the turn it asks for. Mapping only;
+ * every rule runs after it, in the core. Refuse a body it cannot read by
+ * throwing a `WireRequestRefusal` (its status and code reach the caller);
+ * anything else it throws is refused as a malformed request, in fixed words.
+ *
+ * @example A gateway that sends `{ conversationId, requestId, text }`
+ * ```ts
+ * const reader: AgUiRequestReader = ({ body }) => {
+ *   const b = body as { conversationId?: unknown; requestId?: unknown; text?: unknown };
+ *   return {
+ *     threadId: String(b.conversationId),
+ *     runId: String(b.requestId),
+ *     messages: [{ id: 'gateway-turn', role: 'user', content: String(b.text) }],
+ *   };
+ * };
+ * ```
+ */
+export type AgUiRequestReader = (request: AgUiRequestFacts) => AgUiTurnRequest;
+/** The default reader: the body IS an AG-UI `RunAgentInput`. */
+export declare const runAgentInputReader: AgUiRequestReader;
+/**
+ * The core's read of one request: `reader` maps the body, and what it produced
+ * is checked by {@link readAgUiRunInput} — whichever reader it was. A custom
+ * reader's answer is copied as plain JSON first; the default reader's is the
+ * parsed body itself, read exactly as before readers were replaceable.
+ *
+ * @throws WireRequestRefusal — the reader's own refusal, or the core's by name
+ *   (400, `ERR_INVALID_RUN_INPUT`).
+ */
+export declare function readAgUiRequest(reader: AgUiRequestReader, request: AgUiRequestFacts): AgUiRunInput;
+/** What a page's `state` or `context` is checked by before the agent may see it. */
+export type AgUiValidator = (value: unknown, at: {
+    /** The conversation the request was bound to — whose state this claims to be. */
+    readonly thread?: ThreadBinding;
+    readonly headers: Readonly<Record<string, string>>;
+}) => unknown;
+/** The rules one adapter plans by — built from `agUi()`'s options. */
+export interface AgUiTurnRules {
+    /** The frontend tools the app allow-listed, by name: each builds the tool the agent is given. */
+    readonly frontendTools: ReadonlyMap<string, () => Tool>;
+    readonly accept: {
+        readonly state?: AgUiValidator;
+        readonly context?: AgUiValidator;
+    };
+}
+/**
+ * Plan one turn: the request (read by {@link readAgUiRunInput}) against what
+ * the server holds for its bound conversation.
+ *
+ * @throws WireRequestRefusal — by name, for everything a page may not decide.
+ */
+export declare function planAgUiTurn(input: AgUiRunInput, held: HeldConversation, facts: PlanFacts, rules: AgUiTurnRules): ProtocolPlan;
+/**
+ * A stored suspension record, checked — the store holds bytes; a record that
+ * is not one this adapter wrote is `undefined`, and nothing is matched to it.
+ */
+export declare function readAgUiSuspension(value: unknown): AgUiSuspension | undefined;
+//# sourceMappingURL=request.d.ts.map

package/dist/types/ag-ui/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../../src/ag-ui/request.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAGH,OAAO,KAAK,EACV,gBAAgB,EAChB,SAAS,EACT,YAAY,EACZ,oBAAoB,EAEpB,aAAa,EACd,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAEV,WAAW,EACX,eAAe,EACf,YAAY,EAEZ,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,8EAA8E;AAC9E,eAAO,MAAM,mBAAmB,MAAM,CAAC;AA0GvC;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,CAuC5D;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IAC1C,0FAA0F;IAC1F,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IACvC,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;IAC3C,yEAAyE;IACzE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,2FAA2F;IAC3F,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;CAC9C;AAED;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,CAAC;AAEpD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,EAAE,gBAAgB,KAAK,eAAe,CAAC;AAE/E,gEAAgE;AAChE,eAAO,MAAM,mBAAmB,EAAE,iBAAyD,CAAC;AAE5F;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,gBAAgB,GACxB,YAAY,CAiBd;AAiBD,oFAAoF;AACpF,MAAM,MAAM,aAAa,GAAG,CAC1B,KAAK,EAAE,OAAO,EACd,EAAE,EAAE;IACF,iFAAiF;IACjF,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACpD,KACE,OAAO,CAAC;AAEb,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B,iGAAiG;IACjG,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC;IACxD,QAAQ,CAAC,MAAM,EAAE;QACf,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;QAC/B,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;KAClC,CAAC;CACH;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,gBAAgB,EACtB,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,aAAa,GACnB,YAAY,CAyBd;AAyKD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAuB7E"}

package/dist/types/ag-ui/serializer.d.ts

@@ -0,0 +1,174 @@
+/**
+ * serializer — one run's served agentfootprint events → AG-UI events.
+ *
+ * Pattern: a per-run state machine (`RunTranslation`), pure — no I/O, no clock,
+ *          no import of `@ag-ui/*`. Frames are the framing strategy's job
+ *          (`framing.ts`); reading a request is the adapter's (`adapter.ts`).
+ * Role:    the Lens over a run for an AG-UI reader. It composes what that reader
+ *          is served, from the RECORD only: every value it writes comes from a
+ *          served event (the placeholder wherever a redaction policy selected a
+ *          value), from the record's address (`meta.runtimeStageId`,
+ *          `meta.subflowPath` — never selected by a policy), or from the
+ *          AG-UI request's own ids. It never reads the run's live values, so
+ *          nothing a policy hides can reach an AG-UI event. The record's own
+ *          run id is never written: it counts every run the process made.
+ *
+ * THE MAPPING
+ *   agent.turn_start (nested)          → SUBAGENT_STARTED      (a sub-agent's turn)
+ *   agent.turn_end                     → SUBAGENT_FINISHED / the root answer
+ *   agent.iteration_start/_end         → STEP_STARTED/_FINISHED  `iteration <n>`
+ *   composition.enter/exit             → STEP_STARTED/_FINISHED  `<Kind>[:<mount>]`
+ *   stream.token                       → TEXT_MESSAGE_START/CONTENT/END
+ *   stream.llm_end (no agent around)   → one whole TEXT message (an LLM call that streams nothing)
+ *   stream.thinking_delta/_end         → REASONING_START … REASONING_END   (only with `reasoning: true`)
+ *   stream.tool_start                  → TOOL_CALL_START + TOOL_CALL_ARGS + TOOL_CALL_END
+ *   stream.tool_end                    → TOOL_CALL_RESULT
+ *   pause.request + settle('paused')   → RUN_FINISHED { outcome: interrupt }
+ *   settle('paused', awaiting caller)  → RUN_FINISHED { outcome: success, pendingToolCallIds }
+ *                                        (a tool the client runs: its call is left to answer)
+ *   error.fatal + settle('failed')     → RUN_ERROR — the served error.fatal's words when they
+ *                                        are a fixed sentence, else "The run failed."
+ *   an allow-listed event              → CUSTOM { name: <event type>, value: <its listed fields> }
+ *   anything else                      → nothing
+ *
+ * WHAT LEAVES THE PROCESS. An AG-UI stream goes to a browser, so nothing goes
+ * out by default that a person is not meant to read. Every value comes from a
+ * served payload; `CUSTOM` carries only the event types on an allow-list, each
+ * with the fields its projection picks ({@link AG_UI_CUSTOM_EVENTS} — the whole
+ * record, such as `context.injected`'s assembled prompt or `error.retried`'s
+ * raw error, stays off the wire unless the app lists it); the model's
+ * reasoning goes out only when the app says so; and a failure is described by
+ * the record, never by the thrown value. Identity on the meta (`principal`,
+ * `tenant`, `sessionId`) is never written.
+ *
+ * WHO OWNS AN EVENT. Each agent's turn opens a SCOPE at its mount — the
+ * subflow path its `turn_start` fired at (`[]` for the root agent, `step-p/x`
+ * for an agent in a parallel branch). An event belongs to the deepest open scope
+ * whose mount prefixes its own subflow path, segment by segment, and carries
+ * that scope's `subagentRunId`. Parallel branches have different mounts, so
+ * their interleaved events can never be attributed to each other.
+ *
+ * A RUN THAT CONTINUES A PAUSE. A paused run hands back `suspension()` — the
+ * ids it gave the client (the interrupt, the open call) and every scope and
+ * step open at the pause. The run that continues it passes that as `resume`:
+ * the same sub-agents re-open (AG-UI: "a later run may continue the same
+ * invocation"), their steps re-open, and the first result in the paused call's
+ * scope answers that call under its own id — or, for a tool the client ran, is
+ * not written at all, because the client holds the result it sent.
+ *
+ * TEXT. The reply is what the record streamed (`stream.token`) — the channel
+ * `toSSE({ format: 'text' })` and a hosted reply read. An agent turn whose
+ * answer streamed no token (a provider without `stream()`) is written whole
+ * from `turn_end.finalContent`, unless the record marks it refused. An
+ * agent's `llm_end.content` is a DRAFT the library may be holding back
+ * (answer validation, an output policy) and is never written.
+ */
+import type { AgentfootprintEvent } from '../events/registry.js';
+import type { RunTranslation } from '../hosting/protocolAdapter.js';
+import { type AgUiEvent, type AgUiSuspension } from './types.js';
+/** What a CUSTOM projection is told beside the payload: where the event landed. */
+export interface AgUiCustomContext {
+    /** The AG-UI id of the tool call open where the event happened, when one is. */
+    readonly toolCallId?: string;
+}
+/**
+ * One allow-listed event's `CUSTOM` value: the fields of its SERVED payload
+ * that go out (the payload is the one every listener receives — the
+ * placeholder wherever a redaction policy selected a value). Return only what
+ * a person using the frontend is meant to read.
+ */
+export type AgUiCustomProjection = (payload: Readonly<Record<string, unknown>>, at: AgUiCustomContext) => unknown;
+/**
+ * The agentfootprint events that go out as AG-UI `CUSTOM` by default, each with
+ * the fields it carries: progress (which call, which iteration), spend, the
+ * loop's route, the answer's standing and a provider's retries — counts and the
+ * library's own words. Content (a tool's own progress `payload`,
+ * `context.injected`'s assembled prompt, `error.retried`'s raw error, memory,
+ * permission and credential facts) stays off the wire unless an app lists it:
+ * `agUiSerializer({ ..., custom: { ...AG_UI_CUSTOM_EVENTS, [type]: projection } })`.
+ */
+export declare const AG_UI_CUSTOM_EVENTS: Readonly<Record<string, AgUiCustomProjection>>;
+/** Options for {@link agUiSerializer}. */
+export interface AgUiSerializerOptions {
+    /** The conversation this run belongs to — `RunAgentInput.threadId`. */
+    readonly threadId: string;
+    /** This run's AG-UI id — `RunAgentInput.runId`. Every id the run mints is under it. */
+    readonly runId: string;
+    /**
+     * The events with no AG-UI equivalent that go out as `CUSTOM`, keyed by event
+     * type, each with the projection that picks its fields. Default
+     * {@link AG_UI_CUSTOM_EVENTS}; `{}` sends none. An event not listed sends
+     * nothing. Events the mapping consumes (tokens, tool calls, turns,
+     * iterations, compositions, the pause and the fatal error) are never CUSTOM.
+     */
+    readonly custom?: Readonly<Record<string, AgUiCustomProjection>>;
+    /**
+     * Write the model's reasoning — `REASONING_*` events from the served
+     * `stream.thinking_*` events. Default `false`: a model's chain of thought is
+     * shown to a person only when the app decides it is.
+     */
+    readonly reasoning?: boolean;
+    /**
+     * What a FAILED tool call's result says. Default `'withheld'`: the fixed words
+     * "The tool failed." — the record's result for a failed call is the thrown
+     * text, which may hold a connection string, a path or a provider's response.
+     * `'served'` sends the record's own result (still the served value: the
+     * placeholder wherever a redaction policy selected one).
+     */
+    readonly toolErrors?: 'withheld' | 'served';
+    /**
+     * Which served events are this run's. Default: the events of the first run
+     * an event names (plus events that name no run). Pass it when the listener
+     * can hear more than one run — an instance several callers share — so the
+     * translation never binds to whichever run spoke first.
+     */
+    readonly owns?: (event: AgentfootprintEvent) => boolean;
+    /**
+     * The paused run this one continues — what that run's translation returned
+     * from `suspension()` after it settled `'paused'`. Its suspended sub-agents
+     * and open steps re-open under the same ids, and the call it stopped in is
+     * answered under its own id (or, for a frontend tool, not at all: the client
+     * already holds the result it sent).
+     */
+    readonly resume?: AgUiSuspension;
+}
+/** One run's AG-UI translation — and, once it pauses, what its continuation needs. */
+export interface AgUiTranslation extends RunTranslation<AgUiEvent> {
+    /**
+     * The record to `resume` from. Before settling, what a `'paused'` settlement
+     * with the same `awaiting` will hand out (keep it first, then settle); after
+     * `settle({ kind: 'paused' })`, what it handed out; after any other ending,
+     * `undefined`.
+     */
+    suspension(awaiting?: 'person' | 'caller'): AgUiSuspension | undefined;
+}
+/** Said by `TOOL_CALL_RESULT` for a failed call, unless `toolErrors: 'served'`. */
+export declare const AG_UI_TOOL_FAILED = "The tool failed.";
+/** Said by `RUN_ERROR` when the run's `error.fatal` is not one of the record's fixed sentences. */
+export declare const AG_UI_RUN_FAILED = "The run failed.";
+/** Said by `SUBAGENT_ERROR` for a sub-agent whose turn ended without an answer. */
+export declare const AG_UI_SUBAGENT_UNFINISHED = "The sub-agent's turn ended without an answer.";
+/** Said by `SUBAGENT_ERROR` for a sub-agent still running when its run was cancelled. */
+export declare const AG_UI_SUBAGENT_CANCELLED = "The run was cancelled before this sub-agent finished.";
+/**
+ * The AG-UI serializer for ONE run: feed it every served agentfootprint event
+ * of the run, in order, then settle it once. `RUN_STARTED` comes before the
+ * first event it returns; `RUN_FINISHED` or `RUN_ERROR` is the last thing
+ * `settle` returns, with everything still open closed before it.
+ *
+ * @example
+ * ```ts
+ * const ag = agUiSerializer({ threadId, runId });
+ * const off = agent.on('*', (event) => send(ag.event(event)));
+ * try {
+ *   const out = await agent.run({ message });
+ *   send(ag.settle({ kind: isPaused(out) ? 'paused' : 'finished' }));
+ * } catch {
+ *   send(ag.settle({ kind: 'failed' })); // described by the record, never by the thrown value
+ * } finally {
+ *   off();
+ * }
+ * ```
+ */
+export declare function agUiSerializer(options: AgUiSerializerOptions): AgUiTranslation;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/types/ag-ui/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../../src/ag-ui/serializer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAIpE,OAAO,EAGL,KAAK,SAAS,EAId,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAEpB,mFAAmF;AACnF,MAAM,WAAW,iBAAiB;IAChC,gFAAgF;IAChF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,CACjC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC1C,EAAE,EAAE,iBAAiB,KAClB,OAAO,CAAC;AAYb;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAuB7E,CAAC;AAEH,0CAA0C;AAC1C,MAAM,WAAW,qBAAqB;IACpC,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,uFAAuF;IACvF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC;IACjE;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC5C;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO,CAAC;IACxD;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;CAClC;AAED,sFAAsF;AACtF,MAAM,WAAW,eAAgB,SAAQ,cAAc,CAAC,SAAS,CAAC;IAChE;;;;;OAKG;IACH,UAAU,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,cAAc,GAAG,SAAS,CAAC;CACxE;AAED,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,qBAAqB,CAAC;AAEpD,mGAAmG;AACnG,eAAO,MAAM,gBAAgB,oBAAoB,CAAC;AAMlD,mFAAmF;AACnF,eAAO,MAAM,yBAAyB,kDAAkD,CAAC;AAEzF,yFAAyF;AACzF,eAAO,MAAM,wBAAwB,0DAA0D,CAAC;AAyFhG;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,eAAe,CAgvB9E"}