@nxgt/ai-alxia 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steve Tsala
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,87 @@
-# Temporary Holding Version
+# @nxgt/ai-alxia
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[alxia](https://www.npmjs.com/package/@alxia/core) glue for
+[`@nxgt/ai-core`](https://www.npmjs.com/package/@nxgt/ai-core). `aiRequest` is a middleware that gives a handler
+what `runAgent` needs from the request (an abort signal, the request language,
+the app's observers). `agentEvents` streams a run's events as Server-Sent
+Events, written by alxia's own SSE support. Peers: `@alxia/core`,
+`@nxgt/ai-core`, `zod`. The language comes from `@alxia/language` or
+`@alxia/i18n`, which you already use.
+
+```sh
+bun add @nxgt/ai-alxia @alxia/core @nxgt/ai-core zod
+```
+
+The example below uses `fakeModel` from `@nxgt/ai-testing`, a separate install
+(`bun add -d @nxgt/ai-testing`); in production give `runAgent` a real model.
+
+```ts
+import { alxia, responds } from '@alxia/core';
+import { language } from '@alxia/language';
+import { runAgent } from '@nxgt/ai-core';
+import { fakeModel } from '@nxgt/ai-testing';
+import { agentEvents, agentEventStream, aiRequest } from '@nxgt/ai-alxia';
+
+// A scripted model for the example; use @nxgt/ai-anthropic or @nxgt/ai-ollama in production.
+const model = fakeModel([{ text: 'Hello!' }]);
+
+const app = alxia()
+	.use(language({ supported: ['en', 'fr'] as const, fallback: 'en' }))
+	// observers: [aiTelemetry()] from @nxgt/ai-telemetry, for every run of the app
+	.use(aiRequest({ observers: [] }))
+	.post('/chat', responds({ 200: agentEventStream }), ({ ai, reply }) => {
+		const messages = [
+			{ role: 'user' as const, parts: [{ type: 'text' as const, text: 'Hi' }] },
+		];
+		// ai = { signal, language, observers }
+		const run = runAgent({
+			model,
+			system: `Answer in ${ai.language}.`,
+			messages,
+			...ai,
+		});
+		return reply(200, agentEvents(run, { ...ai, heartbeatMs: 15_000 }));
+	});
+
+app.listen(3000);
+```
+
+```sh
+curl -N -X POST 'localhost:3000/chat?lang=fr'
+# event: step-start
+# data: {"type":"step-start","step":1,"runId":"..."}
+#
+# event: text-delta
+# data: {"type":"text-delta","text":"Hello!"}
+# ...
+# event: done
+# data: {"type":"done","reason":"end","usage":{...}}
+```
+
+Imports carry no file extension, so consumers need `"moduleResolution": "bundler"`.
+
+## API
+
+| Export                                  | What it is                                                                                                  |
+| --------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
+| `aiRequest(options?)`                   | The middleware: puts `ctx.ai = { signal, language, observers }`; `options.observers` are given to every run |
+| `AiRequest`, `AiRequestOptions`         | The type of `ctx.ai` and of the options                                                                     |
+| `agentEvents(run, options?)`            | An async generator of SSE items for `reply(200, …)`; `options.signal` and `options.heartbeatMs`             |
+| `AgentEventsOptions`, `AgentStreamItem` | Its options and what it yields: a named event or a comment                                                  |
+| `agentEventStream`                      | The response schema (`eventStream`) of the route: one named event per `AgentEvent` type                     |
+| `toWireEvent(event)`, `WireEvent`       | The event as a client reads it: errors reduced to a code                                                    |
+| `userMessageSchema`, `UserMessage`      | The zod shape of a user message in a request body: `role: 'user'`, text parts only                          |
+| `INTERNAL_ERROR`                        | The code of a failure that is not an `AiError`                                                              |
+
+## Traps
+
+- **Never append parts from the client's request body.** A client could forge a `proposed-action` part, which the memory store records as an action anyone can confirm. Append only the user's text (parse the body with `userMessageSchema`, which accepts text parts only) plus `run.result.messages` ([example](docs/guide/request-and-sse.md#a-request-body-and-memory)).
+- `aiRequest` reads `language` from the context: put `@alxia/language` or `@alxia/i18n` before it, or alxia refuses the chain at compile time.
+- Always write the pair `agentEvents(runAgent({ ...ai, … }), ai)`: spread `ai` into `runAgent` **and** pass it (its `signal`) to `agentEvents`. A run waiting on the model is only stopped on a disconnect through the signal.
+- The wire has no error messages: an `error` event and every failed tool result (alone or inside a `message` event) carry `{ code }` only. `agentEventSchema` of `@nxgt/ai-core` does not parse the wire; validate with `wireEventSchema` (a [client example](docs/guide/request-and-sse.md#what-a-client-reads)).
+- `data:` is JSON on one line: a line break in text is escaped (`\n`), never a second `data:` line. alxia writes the frames, the `content-type`, `cache-control: no-cache` and `x-accel-buffering: no`.
+- alxia already writes `: keep-alive` every 8 s of silence. `heartbeatMs` adds a `: heartbeat` comment of your own period, for a proxy with a shorter timeout.
+- The stream ends after the `done` event, and after an `error` event the run did not follow with `done` (a failure of the stream itself).
+- Headers and status are gone after the first event: a failure after it is an `error` event, never a 500.
+
+More: [guide](docs/guide/request-and-sse.md), [troubleshooting](docs/troubleshooting.md), [roadmap](docs/roadmap.md).

package/dist/agent-events.d.ts

@@ -0,0 +1,32 @@
+import { type SseComment } from '@alxia/core';
+import type { AgentRun } from '@nxgt/ai-core';
+import type { agentEventStream } from './events.js';
+/** One value `agentEvents` yields: a named event, or a heartbeat comment. */
+export type AgentStreamItem = ReturnType<(typeof agentEventStream)['event']> | SseComment;
+export interface AgentEventsOptions {
+    /**
+     * Stops the stream and aborts the run when it aborts: pass `ctx.ai.signal`.
+     * Without it the run is stopped only when alxia closes the generator, which
+     * a generator waiting on the model does not see until it next yields.
+     */
+    signal?: AbortSignal;
+    /** Writes a `: heartbeat` comment after this many ms without an event. Default: none. */
+    heartbeatMs?: number;
+}
+/**
+ * Streams a run's events as Server-Sent Events: reply with it from a route
+ * whose response is `agentEventStream`. alxia writes the frames and the
+ * headers (`text/event-stream`, `no-cache`, `x-accel-buffering: no`).
+ *
+ * - The stream ends after the run's `done` event.
+ * - On a disconnect (`options.signal`) or when alxia closes the generator,
+ *   the run is aborted and the stream ends with no further event.
+ * - An `error` event holds a code only; a stream that fails ends with an
+ *   `error` event of code `INTERNAL_ERROR` (or the `AiError`'s code).
+ *
+ * ```ts
+ * ({ ai, reply }) => reply(200, agentEvents(runAgent({ model, messages, ...ai }), ai))
+ * ```
+ */
+export declare function agentEvents(run: AgentRun, options?: AgentEventsOptions): AsyncGenerator<AgentStreamItem, void, undefined>;
+//# sourceMappingURL=agent-events.d.ts.map

package/dist/agent-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-events.d.ts","sourceRoot":"","sources":["../src/agent-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAc,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAc,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAGjD,6EAA6E;AAC7E,MAAM,MAAM,eAAe,GACxB,UAAU,CAAC,CAAC,OAAO,gBAAgB,CAAC,CAAC,OAAO,CAAC,CAAC,GAC9C,UAAU,CAAC;AAEd,MAAM,WAAW,kBAAkB;IAClC;;;;OAIG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,yFAAyF;IACzF,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAeD;;;;;;;;;;;;;;GAcG;AACH,wBAAuB,WAAW,CACjC,GAAG,EAAE,QAAQ,EACb,OAAO,GAAE,kBAAuB,GAC9B,cAAc,CAAC,eAAe,EAAE,IAAI,EAAE,SAAS,CAAC,CAuClD"}

package/dist/ai-request.d.ts

@@ -0,0 +1,32 @@
+import type { AgentObserver } from '@nxgt/ai-core';
+/** What `aiRequest` puts on the request context as `ai`. */
+export interface AiRequest {
+    /** Aborts when the client disconnects or the request is aborted. */
+    readonly signal: AbortSignal;
+    /** The request's language, as the middleware before `aiRequest` read it. */
+    readonly language: string;
+    /** The observers given to `aiRequest`; one array shared by every request. */
+    readonly observers: readonly AgentObserver[];
+}
+export interface AiRequestOptions {
+    /** Observers every run of the app gets, such as `aiTelemetry()`. */
+    observers?: readonly AgentObserver[];
+}
+/**
+ * The alxia middleware that gives a handler what `runAgent` needs from the
+ * request: `ctx.ai` is `{ signal, language, observers }`, so a handler writes
+ * `runAgent({ model, messages, ...ai })`.
+ *
+ * It reads `language` from the context, so it comes after `@alxia/language`
+ * or `@alxia/i18n`.
+ *
+ * ```ts
+ * alxia().use(language({ supported: ['en', 'fr'], fallback: 'en' })).use(aiRequest());
+ * ```
+ */
+export declare function aiRequest(options?: AiRequestOptions): import("@alxia/core").Middleware<{
+    language: string;
+}, Promise<import("@alxia/core").Next<{
+    ai: AiRequest;
+}, import("@alxia/core").Empty>>>;
+//# sourceMappingURL=ai-request.d.ts.map

package/dist/ai-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-request.d.ts","sourceRoot":"","sources":["../src/ai-request.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,4DAA4D;AAC5D,MAAM,WAAW,SAAS;IACzB,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,EAAE,SAAS,aAAa,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,gBAAgB;IAChC,oEAAoE;IACpE,SAAS,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CACrC;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,OAAO,GAAE,gBAAqB;cAEnB,MAAM;;;kCAM1C"}

package/dist/events.d.ts

@@ -0,0 +1,134 @@
+/**
+ * The response schema of a route that replies with `agentEvents`: one named
+ * event per `AgentEvent` type, each with the exact wire shape of
+ * `wireEventSchema`. Errors are `{ code }` only.
+ *
+ * ```ts
+ * app.post('/chat', responds({ 200: agentEventStream }), handler);
+ * ```
+ */
+export declare const agentEventStream: import("@alxia/core").NamedEventStreamSchema<{
+    readonly 'step-start': import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"step-start">;
+        step: import("zod").ZodNumber;
+        runId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+    readonly 'text-delta': import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"text-delta">;
+        text: import("zod").ZodString;
+        start: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+    }, import("zod/v4/core").$strip>;
+    readonly 'thinking-delta': import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"thinking-delta">;
+        text: import("zod").ZodString;
+        start: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+        signature: import("zod").ZodOptional<import("zod").ZodString>;
+        redacted: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+    readonly 'tool-call': import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"tool-call">;
+        id: import("zod").ZodString;
+        name: import("zod").ZodString;
+        input: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strip>;
+    readonly 'tool-result': import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"tool-result">;
+        result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            isError: import("zod").ZodLiteral<false>;
+            output: import("zod").ZodUnknown;
+            type: import("zod").ZodLiteral<"tool-result">;
+            callId: import("zod").ZodString;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            isError: import("zod").ZodLiteral<true>;
+            error: import("zod").ZodObject<{
+                code: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+            type: import("zod").ZodLiteral<"tool-result">;
+            callId: import("zod").ZodString;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>], "isError">;
+    }, import("zod/v4/core").$strip>;
+    readonly 'proposed-action': import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"proposed-action">;
+        action: import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"proposed-action">;
+            id: import("zod").ZodString;
+            tool: import("zod").ZodString;
+            input: import("zod").ZodUnknown;
+            summary: import("zod").ZodOptional<import("zod").ZodString>;
+            expiresAt: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    readonly message: import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"message">;
+        message: import("zod").ZodObject<{
+            role: import("zod").ZodEnum<{
+                tool: "tool";
+                user: "user";
+                assistant: "assistant";
+            }>;
+            parts: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"thinking">;
+                text: import("zod").ZodString;
+                signature: import("zod").ZodOptional<import("zod").ZodString>;
+                redacted: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"tool-call">;
+                id: import("zod").ZodString;
+                name: import("zod").ZodString;
+                input: import("zod").ZodUnknown;
+            }, import("zod/v4/core").$strip>, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                isError: import("zod").ZodLiteral<false>;
+                output: import("zod").ZodUnknown;
+                type: import("zod").ZodLiteral<"tool-result">;
+                callId: import("zod").ZodString;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                isError: import("zod").ZodLiteral<true>;
+                error: import("zod").ZodObject<{
+                    code: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                type: import("zod").ZodLiteral<"tool-result">;
+                callId: import("zod").ZodString;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>], "isError">, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"proposed-action">;
+                id: import("zod").ZodString;
+                tool: import("zod").ZodString;
+                input: import("zod").ZodUnknown;
+                summary: import("zod").ZodOptional<import("zod").ZodString>;
+                expiresAt: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    readonly usage: import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"usage">;
+        usage: import("zod").ZodObject<{
+            inputTokens: import("zod").ZodNumber;
+            outputTokens: import("zod").ZodNumber;
+            cacheReadTokens: import("zod").ZodNumber;
+            cacheWriteTokens: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    readonly error: import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"error">;
+        error: import("zod").ZodObject<{
+            code: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    readonly done: import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"done">;
+        reason: import("zod").ZodString;
+        usage: import("zod").ZodObject<{
+            inputTokens: import("zod").ZodNumber;
+            outputTokens: import("zod").ZodNumber;
+            cacheReadTokens: import("zod").ZodNumber;
+            cacheWriteTokens: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+}>;
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAgC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { type AgentEventsOptions, type AgentStreamItem, agentEvents, } from './agent-events.js';
+export { type AiRequest, type AiRequestOptions, aiRequest } from './ai-request.js';
+export { agentEventStream } from './events.js';
+export { type UserMessage, userMessageSchema } from './user-message.js';
+export { INTERNAL_ERROR, toWireEvent, type WireEvent, type WireToolResult, wireEventSchema, wireToolResultSchema, } from './wire.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,WAAW,GACX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,KAAK,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EACN,cAAc,EACd,WAAW,EACX,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,eAAe,EACf,oBAAoB,GACpB,MAAM,QAAQ,CAAC"}

package/dist/index.js

@@ -0,0 +1,230 @@
+// src/agent-events.ts
+import { sseComment } from "@alxia/core";
+
+// src/wire.ts
+import {
+  AiError
+} from "@nxgt/ai-core";
+import { z } from "zod";
+var INTERNAL_ERROR = "INTERNAL_ERROR";
+function codeOf(error) {
+  return error instanceof AiError ? error.code : INTERNAL_ERROR;
+}
+var code = z.string();
+var usageSchema = z.object({
+  inputTokens: z.number(),
+  outputTokens: z.number(),
+  cacheReadTokens: z.number(),
+  cacheWriteTokens: z.number()
+});
+var toolResultBase = {
+  type: z.literal("tool-result"),
+  callId: z.string(),
+  name: z.string()
+};
+var wireToolResultSchema = z.discriminatedUnion("isError", [
+  z.object({
+    ...toolResultBase,
+    isError: z.literal(false),
+    output: z.unknown()
+  }),
+  z.object({
+    ...toolResultBase,
+    isError: z.literal(true),
+    error: z.object({ code })
+  })
+]);
+var proposedActionSchema = z.object({
+  type: z.literal("proposed-action"),
+  id: z.string(),
+  tool: z.string(),
+  input: z.unknown(),
+  summary: z.string().optional(),
+  expiresAt: z.number()
+});
+var partSchema = z.union([
+  z.object({ type: z.literal("text"), text: z.string() }),
+  z.object({
+    type: z.literal("thinking"),
+    text: z.string(),
+    signature: z.string().optional(),
+    redacted: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("tool-call"),
+    id: z.string(),
+    name: z.string(),
+    input: z.unknown()
+  }),
+  wireToolResultSchema,
+  proposedActionSchema
+]);
+var messageSchema = z.object({
+  role: z.enum(["user", "assistant", "tool"]),
+  parts: z.array(partSchema)
+});
+var wireEventSchemas = {
+  "step-start": z.object({
+    type: z.literal("step-start"),
+    step: z.number().int(),
+    runId: z.string()
+  }),
+  "text-delta": z.object({
+    type: z.literal("text-delta"),
+    text: z.string(),
+    start: z.literal(true).optional()
+  }),
+  "thinking-delta": z.object({
+    type: z.literal("thinking-delta"),
+    text: z.string(),
+    start: z.literal(true).optional(),
+    signature: z.string().optional(),
+    redacted: z.string().optional()
+  }),
+  "tool-call": z.object({
+    type: z.literal("tool-call"),
+    id: z.string(),
+    name: z.string(),
+    input: z.unknown()
+  }),
+  "tool-result": z.object({
+    type: z.literal("tool-result"),
+    result: wireToolResultSchema
+  }),
+  "proposed-action": z.object({
+    type: z.literal("proposed-action"),
+    action: proposedActionSchema
+  }),
+  message: z.object({ type: z.literal("message"), message: messageSchema }),
+  usage: z.object({ type: z.literal("usage"), usage: usageSchema }),
+  error: z.object({ type: z.literal("error"), error: z.object({ code }) }),
+  done: z.object({
+    type: z.literal("done"),
+    reason: z.string(),
+    usage: usageSchema
+  })
+};
+var wireEventSchema = z.discriminatedUnion("type", [
+  wireEventSchemas["step-start"],
+  wireEventSchemas["text-delta"],
+  wireEventSchemas["thinking-delta"],
+  wireEventSchemas["tool-call"],
+  wireEventSchemas["tool-result"],
+  wireEventSchemas["proposed-action"],
+  wireEventSchemas.message,
+  wireEventSchemas.usage,
+  wireEventSchemas.error,
+  wireEventSchemas.done
+]);
+function wireResult(result) {
+  if (!result.isError)
+    return result;
+  const { type, callId, name, error } = result;
+  return { type, callId, name, isError: true, error: { code: error.code } };
+}
+function wirePart(part) {
+  return part.type === "tool-result" ? wireResult(part) : part;
+}
+function wireMessage(message) {
+  return { role: message.role, parts: message.parts.map(wirePart) };
+}
+function toWireEvent(event) {
+  switch (event.type) {
+    case "error":
+      return { type: "error", error: { code: event.error.code } };
+    case "tool-result":
+      return { type: "tool-result", result: wireResult(event.result) };
+    case "message":
+      return { type: "message", message: wireMessage(event.message) };
+    default:
+      return event;
+  }
+}
+
+// src/agent-events.ts
+var ABORTED = Symbol("aborted");
+var BEAT = Symbol("beat");
+function aborted(signal) {
+  let onAbort = () => {};
+  const promise = new Promise((resolve) => {
+    onAbort = () => resolve(ABORTED);
+    if (signal?.aborted)
+      onAbort();
+    else
+      signal?.addEventListener("abort", onAbort, { once: true });
+  });
+  return { promise, stop: () => signal?.removeEventListener("abort", onAbort) };
+}
+async function* agentEvents(run, options = {}) {
+  const { signal, heartbeatMs } = options;
+  const iterator = run[Symbol.asyncIterator]();
+  const stop = aborted(signal);
+  try {
+    let pending = iterator.next();
+    while (true) {
+      let beat;
+      const racers = [pending, stop.promise];
+      if (heartbeatMs !== undefined && heartbeatMs > 0) {
+        racers.push(new Promise((resolve) => {
+          beat = setTimeout(() => resolve(BEAT), heartbeatMs);
+        }));
+      }
+      const won = await Promise.race(racers).finally(() => clearTimeout(beat));
+      if (won === ABORTED)
+        return;
+      if (won === BEAT) {
+        yield sseComment("heartbeat");
+        continue;
+      }
+      const step = won;
+      if (step.done)
+        return;
+      const wire = toWireEvent(step.value);
+      yield { event: wire.type, data: wire };
+      if (step.value.type === "done")
+        return;
+      pending = iterator.next();
+    }
+  } catch (error) {
+    if (!signal?.aborted) {
+      const data = { type: "error", error: { code: codeOf(error) } };
+      yield { event: "error", data };
+    }
+  } finally {
+    stop.stop();
+    run.abort();
+    run.result.catch(() => {});
+  }
+}
+// src/ai-request.ts
+import { defineMiddleware } from "@alxia/core";
+var NO_OBSERVERS = [];
+function aiRequest(options = {}) {
+  const observers = options.observers ?? NO_OBSERVERS;
+  return defineMiddleware()(({ request, language }, next) => {
+    const ai = { signal: request.signal, language, observers };
+    return next({ ai });
+  });
+}
+// src/events.ts
+import { eventStream } from "@alxia/core";
+var agentEventStream = eventStream(wireEventSchemas);
+// src/user-message.ts
+import { z as z2 } from "zod";
+var userMessageSchema = z2.object({
+  role: z2.literal("user"),
+  parts: z2.array(z2.object({ type: z2.literal("text"), text: z2.string() })).min(1)
+});
+export {
+  INTERNAL_ERROR,
+  agentEventStream,
+  agentEvents,
+  aiRequest,
+  toWireEvent,
+  userMessageSchema,
+  wireEventSchema,
+  wireToolResultSchema
+};
+
+//# debugId=9611CD0C4527036B64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,14 @@
+{
+  "version": 3,
+  "sources": ["../src/agent-events.ts", "../src/wire.ts", "../src/ai-request.ts", "../src/events.ts", "../src/user-message.ts"],
+  "sourcesContent": [
+    "import { type SseComment, sseComment } from '@alxia/core';\nimport type { AgentEvent, AgentRun } from '@nxgt/ai-core';\nimport type { agentEventStream } from './events';\nimport { codeOf, toWireEvent } from './wire';\n\n/** One value `agentEvents` yields: a named event, or a heartbeat comment. */\nexport type AgentStreamItem =\n\t| ReturnType<(typeof agentEventStream)['event']>\n\t| SseComment;\n\nexport interface AgentEventsOptions {\n\t/**\n\t * Stops the stream and aborts the run when it aborts: pass `ctx.ai.signal`.\n\t * Without it the run is stopped only when alxia closes the generator, which\n\t * a generator waiting on the model does not see until it next yields.\n\t */\n\tsignal?: AbortSignal;\n\t/** Writes a `: heartbeat` comment after this many ms without an event. Default: none. */\n\theartbeatMs?: number;\n}\n\nconst ABORTED = Symbol('aborted');\nconst BEAT = Symbol('beat');\n\nfunction aborted(signal: AbortSignal | undefined) {\n\tlet onAbort = () => {};\n\tconst promise = new Promise<typeof ABORTED>((resolve) => {\n\t\tonAbort = () => resolve(ABORTED);\n\t\tif (signal?.aborted) onAbort();\n\t\telse signal?.addEventListener('abort', onAbort, { once: true });\n\t});\n\treturn { promise, stop: () => signal?.removeEventListener('abort', onAbort) };\n}\n\n/**\n * Streams a run's events as Server-Sent Events: reply with it from a route\n * whose response is `agentEventStream`. alxia writes the frames and the\n * headers (`text/event-stream`, `no-cache`, `x-accel-buffering: no`).\n *\n * - The stream ends after the run's `done` event.\n * - On a disconnect (`options.signal`) or when alxia closes the generator,\n *   the run is aborted and the stream ends with no further event.\n * - An `error` event holds a code only; a stream that fails ends with an\n *   `error` event of code `INTERNAL_ERROR` (or the `AiError`'s code).\n *\n * ```ts\n * ({ ai, reply }) => reply(200, agentEvents(runAgent({ model, messages, ...ai }), ai))\n * ```\n */\nexport async function* agentEvents(\n\trun: AgentRun,\n\toptions: AgentEventsOptions = {},\n): AsyncGenerator<AgentStreamItem, void, undefined> {\n\tconst { signal, heartbeatMs } = options;\n\tconst iterator = run[Symbol.asyncIterator]();\n\tconst stop = aborted(signal);\n\ttry {\n\t\tlet pending = iterator.next();\n\t\twhile (true) {\n\t\t\tlet beat: Timer | undefined;\n\t\t\tconst racers: Promise<unknown>[] = [pending, stop.promise];\n\t\t\tif (heartbeatMs !== undefined && heartbeatMs > 0) {\n\t\t\t\tracers.push(\n\t\t\t\t\tnew Promise((resolve) => {\n\t\t\t\t\t\tbeat = setTimeout(() => resolve(BEAT), heartbeatMs);\n\t\t\t\t\t}),\n\t\t\t\t);\n\t\t\t}\n\t\t\tconst won = await Promise.race(racers).finally(() => clearTimeout(beat));\n\t\t\tif (won === ABORTED) return;\n\t\t\tif (won === BEAT) {\n\t\t\t\tyield sseComment('heartbeat');\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst step = won as IteratorResult<AgentEvent>;\n\t\t\tif (step.done) return;\n\t\t\tconst wire = toWireEvent(step.value);\n\t\t\tyield { event: wire.type, data: wire } as AgentStreamItem;\n\t\t\tif (step.value.type === 'done') return;\n\t\t\tpending = iterator.next();\n\t\t}\n\t} catch (error) {\n\t\tif (!signal?.aborted) {\n\t\t\tconst data = { type: 'error' as const, error: { code: codeOf(error) } };\n\t\t\tyield { event: 'error' as const, data };\n\t\t}\n\t} finally {\n\t\tstop.stop();\n\t\trun.abort();\n\t\tvoid run.result.catch(() => {});\n\t}\n}\n",
+    "import {\n\ttype AgentEvent,\n\tAiError,\n\ttype Message,\n\ttype Part,\n\ttype ToolResultPart,\n} from '@nxgt/ai-core';\nimport { z } from 'zod';\n\n/** The code a client sees for a failure that has none of its own. */\nexport const INTERNAL_ERROR = 'INTERNAL_ERROR';\n\n/** The code of a thrown value: an `AiError`'s, else `INTERNAL_ERROR`. */\nexport function codeOf(error: unknown): string {\n\treturn error instanceof AiError ? error.code : INTERNAL_ERROR;\n}\n\nconst code = z.string();\n\nconst usageSchema = z.object({\n\tinputTokens: z.number(),\n\toutputTokens: z.number(),\n\tcacheReadTokens: z.number(),\n\tcacheWriteTokens: z.number(),\n});\n\nconst toolResultBase = {\n\ttype: z.literal('tool-result'),\n\tcallId: z.string(),\n\tname: z.string(),\n};\n\n/** A tool result as sent: a failure is its code, with no message and no issues. */\nexport const wireToolResultSchema = z.discriminatedUnion('isError', [\n\tz.object({\n\t\t...toolResultBase,\n\t\tisError: z.literal(false),\n\t\toutput: z.unknown(),\n\t}),\n\tz.object({\n\t\t...toolResultBase,\n\t\tisError: z.literal(true),\n\t\terror: z.object({ code }),\n\t}),\n]);\n\nconst proposedActionSchema = z.object({\n\ttype: z.literal('proposed-action'),\n\tid: z.string(),\n\ttool: z.string(),\n\tinput: z.unknown(),\n\tsummary: z.string().optional(),\n\texpiresAt: z.number(),\n});\n\nconst partSchema = z.union([\n\tz.object({ type: z.literal('text'), text: z.string() }),\n\tz.object({\n\t\ttype: z.literal('thinking'),\n\t\ttext: z.string(),\n\t\tsignature: z.string().optional(),\n\t\tredacted: z.string().optional(),\n\t}),\n\tz.object({\n\t\ttype: z.literal('tool-call'),\n\t\tid: z.string(),\n\t\tname: z.string(),\n\t\tinput: z.unknown(),\n\t}),\n\twireToolResultSchema,\n\tproposedActionSchema,\n]);\n\nconst messageSchema = z.object({\n\trole: z.enum(['user', 'assistant', 'tool']),\n\tparts: z.array(partSchema),\n});\n\n/** Each wire event by its `type`, which is also its SSE `event:` name. */\nexport const wireEventSchemas = {\n\t'step-start': z.object({\n\t\ttype: z.literal('step-start'),\n\t\tstep: z.number().int(),\n\t\trunId: z.string(),\n\t}),\n\t'text-delta': z.object({\n\t\ttype: z.literal('text-delta'),\n\t\ttext: z.string(),\n\t\tstart: z.literal(true).optional(),\n\t}),\n\t'thinking-delta': z.object({\n\t\ttype: z.literal('thinking-delta'),\n\t\ttext: z.string(),\n\t\tstart: z.literal(true).optional(),\n\t\tsignature: z.string().optional(),\n\t\tredacted: z.string().optional(),\n\t}),\n\t'tool-call': z.object({\n\t\ttype: z.literal('tool-call'),\n\t\tid: z.string(),\n\t\tname: z.string(),\n\t\tinput: z.unknown(),\n\t}),\n\t'tool-result': z.object({\n\t\ttype: z.literal('tool-result'),\n\t\tresult: wireToolResultSchema,\n\t}),\n\t'proposed-action': z.object({\n\t\ttype: z.literal('proposed-action'),\n\t\taction: proposedActionSchema,\n\t}),\n\tmessage: z.object({ type: z.literal('message'), message: messageSchema }),\n\tusage: z.object({ type: z.literal('usage'), usage: usageSchema }),\n\terror: z.object({ type: z.literal('error'), error: z.object({ code }) }),\n\tdone: z.object({\n\t\ttype: z.literal('done'),\n\t\treason: z.string(),\n\t\tusage: usageSchema,\n\t}),\n} as const;\n\n/**\n * Validates an event as read from the stream (unlike `agentEventSchema` of\n * `@nxgt/ai-core`, which wants the `message` the wire leaves out).\n */\nexport const wireEventSchema = z.discriminatedUnion('type', [\n\twireEventSchemas['step-start'],\n\twireEventSchemas['text-delta'],\n\twireEventSchemas['thinking-delta'],\n\twireEventSchemas['tool-call'],\n\twireEventSchemas['tool-result'],\n\twireEventSchemas['proposed-action'],\n\twireEventSchemas.message,\n\twireEventSchemas.usage,\n\twireEventSchemas.error,\n\twireEventSchemas.done,\n]);\n\n/** An event as the client reads it: errors are codes, never messages. */\nexport type WireEvent = z.infer<typeof wireEventSchema>;\nexport type WireToolResult = z.infer<typeof wireToolResultSchema>;\n\nfunction wireResult(result: ToolResultPart): WireToolResult {\n\tif (!result.isError) return result;\n\tconst { type, callId, name, error } = result;\n\treturn { type, callId, name, isError: true, error: { code: error.code } };\n}\n\nfunction wirePart(part: Part): z.infer<typeof partSchema> {\n\treturn part.type === 'tool-result' ? wireResult(part) : part;\n}\n\nfunction wireMessage(message: Message): z.infer<typeof messageSchema> {\n\treturn { role: message.role, parts: message.parts.map(wirePart) };\n}\n\n/**\n * The event a client may read. Everywhere an event holds an error (an\n * `error` event, a failed `tool-result`, a failed result inside a `message`)\n * only its `code` is kept: messages and issues can hold what a provider, a\n * tool or an exception said, so they stay on the server.\n */\nexport function toWireEvent(event: AgentEvent): WireEvent {\n\tswitch (event.type) {\n\t\tcase 'error':\n\t\t\treturn { type: 'error', error: { code: event.error.code } };\n\t\tcase 'tool-result':\n\t\t\treturn { type: 'tool-result', result: wireResult(event.result) };\n\t\tcase 'message':\n\t\t\treturn { type: 'message', message: wireMessage(event.message) };\n\t\tdefault:\n\t\t\treturn event;\n\t}\n}\n",
+    "import { defineMiddleware } from '@alxia/core';\nimport type { AgentObserver } from '@nxgt/ai-core';\n\n/** What `aiRequest` puts on the request context as `ai`. */\nexport interface AiRequest {\n\t/** Aborts when the client disconnects or the request is aborted. */\n\treadonly signal: AbortSignal;\n\t/** The request's language, as the middleware before `aiRequest` read it. */\n\treadonly language: string;\n\t/** The observers given to `aiRequest`; one array shared by every request. */\n\treadonly observers: readonly AgentObserver[];\n}\n\nexport interface AiRequestOptions {\n\t/** Observers every run of the app gets, such as `aiTelemetry()`. */\n\tobservers?: readonly AgentObserver[];\n}\n\nconst NO_OBSERVERS: readonly AgentObserver[] = [];\n\n/**\n * The alxia middleware that gives a handler what `runAgent` needs from the\n * request: `ctx.ai` is `{ signal, language, observers }`, so a handler writes\n * `runAgent({ model, messages, ...ai })`.\n *\n * It reads `language` from the context, so it comes after `@alxia/language`\n * or `@alxia/i18n`.\n *\n * ```ts\n * alxia().use(language({ supported: ['en', 'fr'], fallback: 'en' })).use(aiRequest());\n * ```\n */\nexport function aiRequest(options: AiRequestOptions = {}) {\n\tconst observers = options.observers ?? NO_OBSERVERS;\n\treturn defineMiddleware<{ language: string }>()(\n\t\t({ request, language }, next) => {\n\t\t\tconst ai: AiRequest = { signal: request.signal, language, observers };\n\t\t\treturn next({ ai });\n\t\t},\n\t);\n}\n",
+    "import { eventStream } from '@alxia/core';\nimport { wireEventSchemas } from './wire';\n\n/**\n * The response schema of a route that replies with `agentEvents`: one named\n * event per `AgentEvent` type, each with the exact wire shape of\n * `wireEventSchema`. Errors are `{ code }` only.\n *\n * ```ts\n * app.post('/chat', responds({ 200: agentEventStream }), handler);\n * ```\n */\nexport const agentEventStream = eventStream(wireEventSchemas);\n",
+    "import { z } from 'zod';\n\n/**\n * A user message as a request body may carry it: the `user` role and text\n * parts only. Any other part (a forged `proposed-action`, a `tool-result`)\n * fails the parse, so nothing but the user's text reaches the memory store.\n */\nexport const userMessageSchema = z.object({\n\trole: z.literal('user'),\n\tparts: z\n\t\t.array(z.object({ type: z.literal('text'), text: z.string() }))\n\t\t.min(1),\n});\n\n/** A user message of a request body, text parts only. */\nexport type UserMessage = z.infer<typeof userMessageSchema>;\n"
+  ],
+  "mappings": ";AAAA;;;ACAA;AAAA;AAAA;AAOA;AAGO,IAAM,iBAAiB;AAGvB,SAAS,MAAM,CAAC,OAAwB;AAAA,EAC9C,OAAO,iBAAiB,UAAU,MAAM,OAAO;AAAA;AAGhD,IAAM,OAAO,EAAE,OAAO;AAEtB,IAAM,cAAc,EAAE,OAAO;AAAA,EAC5B,aAAa,EAAE,OAAO;AAAA,EACtB,cAAc,EAAE,OAAO;AAAA,EACvB,iBAAiB,EAAE,OAAO;AAAA,EAC1B,kBAAkB,EAAE,OAAO;AAC5B,CAAC;AAED,IAAM,iBAAiB;AAAA,EACtB,MAAM,EAAE,QAAQ,aAAa;AAAA,EAC7B,QAAQ,EAAE,OAAO;AAAA,EACjB,MAAM,EAAE,OAAO;AAChB;AAGO,IAAM,uBAAuB,EAAE,mBAAmB,WAAW;AAAA,EACnE,EAAE,OAAO;AAAA,OACL;AAAA,IACH,SAAS,EAAE,QAAQ,KAAK;AAAA,IACxB,QAAQ,EAAE,QAAQ;AAAA,EACnB,CAAC;AAAA,EACD,EAAE,OAAO;AAAA,OACL;AAAA,IACH,SAAS,EAAE,QAAQ,IAAI;AAAA,IACvB,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC;AAAA,EACzB,CAAC;AACF,CAAC;AAED,IAAM,uBAAuB,EAAE,OAAO;AAAA,EACrC,MAAM,EAAE,QAAQ,iBAAiB;AAAA,EACjC,IAAI,EAAE,OAAO;AAAA,EACb,MAAM,EAAE,OAAO;AAAA,EACf,OAAO,EAAE,QAAQ;AAAA,EACjB,SAAS,EAAE,OAAO,EAAE,SAAS;AAAA,EAC7B,WAAW,EAAE,OAAO;AACrB,CAAC;AAED,IAAM,aAAa,EAAE,MAAM;AAAA,EAC1B,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,CAAC;AAAA,EACtD,EAAE,OAAO;AAAA,IACR,MAAM,EAAE,QAAQ,UAAU;AAAA,IAC1B,MAAM,EAAE,OAAO;AAAA,IACf,WAAW,EAAE,OAAO,EAAE,SAAS;AAAA,IAC/B,UAAU,EAAE,OAAO,EAAE,SAAS;AAAA,EAC/B,CAAC;AAAA,EACD,EAAE,OAAO;AAAA,IACR,MAAM,EAAE,QAAQ,WAAW;AAAA,IAC3B,IAAI,EAAE,OAAO;AAAA,IACb,MAAM,EAAE,OAAO;AAAA,IACf,OAAO,EAAE,QAAQ;AAAA,EAClB,CAAC;AAAA,EACD;AAAA,EACA;AACD,CAAC;AAED,IAAM,gBAAgB,EAAE,OAAO;AAAA,EAC9B,MAAM,EAAE,KAAK,CAAC,QAAQ,aAAa,MAAM,CAAC;AAAA,EAC1C,OAAO,EAAE,MAAM,UAAU;AAC1B,CAAC;AAGM,IAAM,mBAAmB;AAAA,EAC/B,cAAc,EAAE,OAAO;AAAA,IACtB,MAAM,EAAE,QAAQ,YAAY;AAAA,IAC5B,MAAM,EAAE,OAAO,EAAE,IAAI;AAAA,IACrB,OAAO,EAAE,OAAO;AAAA,EACjB,CAAC;AAAA,EACD,cAAc,EAAE,OAAO;AAAA,IACtB,MAAM,EAAE,QAAQ,YAAY;AAAA,IAC5B,MAAM,EAAE,OAAO;AAAA,IACf,OAAO,EAAE,QAAQ,IAAI,EAAE,SAAS;AAAA,EACjC,CAAC;AAAA,EACD,kBAAkB,EAAE,OAAO;AAAA,IAC1B,MAAM,EAAE,QAAQ,gBAAgB;AAAA,IAChC,MAAM,EAAE,OAAO;AAAA,IACf,OAAO,EAAE,QAAQ,IAAI,EAAE,SAAS;AAAA,IAChC,WAAW,EAAE,OAAO,EAAE,SAAS;AAAA,IAC/B,UAAU,EAAE,OAAO,EAAE,SAAS;AAAA,EAC/B,CAAC;AAAA,EACD,aAAa,EAAE,OAAO;AAAA,IACrB,MAAM,EAAE,QAAQ,WAAW;AAAA,IAC3B,IAAI,EAAE,OAAO;AAAA,IACb,MAAM,EAAE,OAAO;AAAA,IACf,OAAO,EAAE,QAAQ;AAAA,EAClB,CAAC;AAAA,EACD,eAAe,EAAE,OAAO;AAAA,IACvB,MAAM,EAAE,QAAQ,aAAa;AAAA,IAC7B,QAAQ;AAAA,EACT,CAAC;AAAA,EACD,mBAAmB,EAAE,OAAO;AAAA,IAC3B,MAAM,EAAE,QAAQ,iBAAiB;AAAA,IACjC,QAAQ;AAAA,EACT,CAAC;AAAA,EACD,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAS,GAAG,SAAS,cAAc,CAAC;AAAA,EACxE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,OAAO,GAAG,OAAO,YAAY,CAAC;AAAA,EAChE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,OAAO,GAAG,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,CAAC;AAAA,EACvE,MAAM,EAAE,OAAO;AAAA,IACd,MAAM,EAAE,QAAQ,MAAM;AAAA,IACtB,QAAQ,EAAE,OAAO;AAAA,IACjB,OAAO;AAAA,EACR,CAAC;AACF;AAMO,IAAM,kBAAkB,EAAE,mBAAmB,QAAQ;AAAA,EAC3D,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,iBAAiB;AAClB,CAAC;AAMD,SAAS,UAAU,CAAC,QAAwC;AAAA,EAC3D,IAAI,CAAC,OAAO;AAAA,IAAS,OAAO;AAAA,EAC5B,QAAQ,MAAM,QAAQ,MAAM,UAAU;AAAA,EACtC,OAAO,EAAE,MAAM,QAAQ,MAAM,SAAS,MAAM,OAAO,EAAE,MAAM,MAAM,KAAK,EAAE;AAAA;AAGzE,SAAS,QAAQ,CAAC,MAAwC;AAAA,EACzD,OAAO,KAAK,SAAS,gBAAgB,WAAW,IAAI,IAAI;AAAA;AAGzD,SAAS,WAAW,CAAC,SAAiD;AAAA,EACrE,OAAO,EAAE,MAAM,QAAQ,MAAM,OAAO,QAAQ,MAAM,IAAI,QAAQ,EAAE;AAAA;AAS1D,SAAS,WAAW,CAAC,OAA8B;AAAA,EACzD,QAAQ,MAAM;AAAA,IACb,KAAK;AAAA,MACJ,OAAO,EAAE,MAAM,SAAS,OAAO,EAAE,MAAM,MAAM,MAAM,KAAK,EAAE;AAAA,IAC3D,KAAK;AAAA,MACJ,OAAO,EAAE,MAAM,eAAe,QAAQ,WAAW,MAAM,MAAM,EAAE;AAAA,IAChE,KAAK;AAAA,MACJ,OAAO,EAAE,MAAM,WAAW,SAAS,YAAY,MAAM,OAAO,EAAE;AAAA,IAC/D;AAAA,MACC,OAAO;AAAA;AAAA;;;ADtJV,IAAM,UAAU,OAAO,SAAS;AAChC,IAAM,OAAO,OAAO,MAAM;AAE1B,SAAS,OAAO,CAAC,QAAiC;AAAA,EACjD,IAAI,UAAU,MAAM;AAAA,EACpB,MAAM,UAAU,IAAI,QAAwB,CAAC,YAAY;AAAA,IACxD,UAAU,MAAM,QAAQ,OAAO;AAAA,IAC/B,IAAI,QAAQ;AAAA,MAAS,QAAQ;AAAA,IAC7B;AAAA,MAAK,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AAAA,GAC9D;AAAA,EACD,OAAO,EAAE,SAAS,MAAM,MAAM,QAAQ,oBAAoB,SAAS,OAAO,EAAE;AAAA;AAkBtE,gBAAgB,WAAW,CACjC,KACA,UAA8B,CAAC,GACoB;AAAA,EACnD,QAAQ,QAAQ,gBAAgB;AAAA,EAChC,MAAM,WAAW,IAAI,OAAO,eAAe;AAAA,EAC3C,MAAM,OAAO,QAAQ,MAAM;AAAA,EAC3B,IAAI;AAAA,IACH,IAAI,UAAU,SAAS,KAAK;AAAA,IAC5B,OAAO,MAAM;AAAA,MACZ,IAAI;AAAA,MACJ,MAAM,SAA6B,CAAC,SAAS,KAAK,OAAO;AAAA,MACzD,IAAI,gBAAgB,aAAa,cAAc,GAAG;AAAA,QACjD,OAAO,KACN,IAAI,QAAQ,CAAC,YAAY;AAAA,UACxB,OAAO,WAAW,MAAM,QAAQ,IAAI,GAAG,WAAW;AAAA,SAClD,CACF;AAAA,MACD;AAAA,MACA,MAAM,MAAM,MAAM,QAAQ,KAAK,MAAM,EAAE,QAAQ,MAAM,aAAa,IAAI,CAAC;AAAA,MACvE,IAAI,QAAQ;AAAA,QAAS;AAAA,MACrB,IAAI,QAAQ,MAAM;AAAA,QACjB,MAAM,WAAW,WAAW;AAAA,QAC5B;AAAA,MACD;AAAA,MACA,MAAM,OAAO;AAAA,MACb,IAAI,KAAK;AAAA,QAAM;AAAA,MACf,MAAM,OAAO,YAAY,KAAK,KAAK;AAAA,MACnC,MAAM,EAAE,OAAO,KAAK,MAAM,MAAM,KAAK;AAAA,MACrC,IAAI,KAAK,MAAM,SAAS;AAAA,QAAQ;AAAA,MAChC,UAAU,SAAS,KAAK;AAAA,IACzB;AAAA,IACC,OAAO,OAAO;AAAA,IACf,IAAI,CAAC,QAAQ,SAAS;AAAA,MACrB,MAAM,OAAO,EAAE,MAAM,SAAkB,OAAO,EAAE,MAAM,OAAO,KAAK,EAAE,EAAE;AAAA,MACtE,MAAM,EAAE,OAAO,SAAkB,KAAK;AAAA,IACvC;AAAA,IACC,QAAQ;AAAA,IACT,KAAK,KAAK;AAAA,IACV,IAAI,MAAM;AAAA,IACL,IAAI,OAAO,MAAM,MAAM,EAAE;AAAA;AAAA;;AEzFhC;AAkBA,IAAM,eAAyC,CAAC;AAczC,SAAS,SAAS,CAAC,UAA4B,CAAC,GAAG;AAAA,EACzD,MAAM,YAAY,QAAQ,aAAa;AAAA,EACvC,OAAO,iBAAuC,EAC7C,GAAG,SAAS,YAAY,SAAS;AAAA,IAChC,MAAM,KAAgB,EAAE,QAAQ,QAAQ,QAAQ,UAAU,UAAU;AAAA,IACpE,OAAO,KAAK,EAAE,GAAG,CAAC;AAAA,GAEpB;AAAA;;ACvCD;AAYO,IAAM,mBAAmB,YAAY,gBAAgB;;ACZ5D,cAAS;AAOF,IAAM,oBAAoB,GAAE,OAAO;AAAA,EACzC,MAAM,GAAE,QAAQ,MAAM;AAAA,EACtB,OAAO,GACL,MAAM,GAAE,OAAO,EAAE,MAAM,GAAE,QAAQ,MAAM,GAAG,MAAM,GAAE,OAAO,EAAE,CAAC,CAAC,EAC7D,IAAI,CAAC;AACR,CAAC;",
+  "debugId": "9611CD0C4527036B64756E2164756E21",
+  "names": []
+}

package/dist/user-message.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+/**
+ * A user message as a request body may carry it: the `user` role and text
+ * parts only. Any other part (a forged `proposed-action`, a `tool-result`)
+ * fails the parse, so nothing but the user's text reaches the memory store.
+ */
+export declare const userMessageSchema: z.ZodObject<{
+    role: z.ZodLiteral<"user">;
+    parts: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** A user message of a request body, text parts only. */
+export type UserMessage = z.infer<typeof userMessageSchema>;
+//# sourceMappingURL=user-message.d.ts.map

package/dist/user-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-message.d.ts","sourceRoot":"","sources":["../src/user-message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;iBAK5B,CAAC;AAEH,yDAAyD;AACzD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}