@jini-ai/http-kit 0.3.2 → 0.3.3

package/dist/fastify/request.js

@@ -1,25 +0,0 @@
-import { createApiError } from '@jini/protocol';
-/**
- * Extracts `body`/`query`/`params` from a Fastify `FastifyRequest` into a `RouteInputContext`, so
- * a route's `parse` function can be unit-tested without constructing a real `FastifyRequest`.
- */
-export function rawInput(request) {
-    return {
-        body: request.body,
-        query: (request.query ?? {}),
-        params: (request.params ?? {}),
-    };
-}
-/**
- * Builds a `BAD_REQUEST` `ApiError` for a failed parse. When `issues` is non-empty, attaches
- * them as structured validation details so clients can render per-field errors.
- */
-export function validationError(message, issues = []) {
-    if (issues.length === 0) {
-        return createApiError('BAD_REQUEST', message);
-    }
-    return createApiError('BAD_REQUEST', message, {
-        details: { kind: 'validation', issues },
-    });
-}
-//# sourceMappingURL=request.js.map

package/dist/fastify/request.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"request.js","sourceRoot":"","sources":["../../src/fastify/request.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,cAAc,EAA0C,MAAM,gBAAgB,CAAC;AAGxF;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAuB;IAC9C,OAAO;QACL,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,KAAK,EAAE,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,CAA4B;QACvD,MAAM,EAAE,CAAC,OAAO,CAAC,MAAM,IAAI,EAAE,CAA2B;KACzD,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAC7B,OAAe,EACf,SAAyD,EAAE;IAE3D,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO,cAAc,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;IACD,OAAO,cAAc,CAAC,aAAa,EAAE,OAAO,EAAE;QAC5C,OAAO,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAiD;KACvF,CAAC,CAAC;AACL,CAAC"}

package/dist/fastify/response.d.ts

@@ -1,20 +0,0 @@
-/**
- * Response-side serialization: writes a plain JSON body or a standard `ApiError` envelope onto a
- * Fastify `FastifyReply`, and maps an `ApiErrorCode` to its default HTTP status. No internal
- * dependencies — this is the terminal step of the Fastify Adapter's error-handling pipeline.
- *
- * Deliberately duplicated from `../express/response.ts` rather than shared: both files implement
- * the identical `ApiErrorCode` -> HTTP status mapping and error-envelope shape, but this
- * subtree's whole point is to stay independent of `express/` (see `../../source-map.md`'s
- * Fastify-transport section) — a Fastify-only consumer must be able to import this module without
- * ever pulling in anything that even *type*-references the `express` package.
- */
-import type { FastifyReply } from 'fastify';
-import { type ApiError } from '@jini/protocol';
-/** Writes `body` as JSON with the given status code. */
-export declare function sendJson(reply: FastifyReply, status: number, body: unknown): void;
-/** Writes an `ApiError`, wrapped in the standard `{ error }` envelope, with the given status code. */
-export declare function sendApiError(reply: FastifyReply, status: number, error: ApiError): void;
-/** Resolves the HTTP status to send for an `ApiError`, defaulting to 500 for unmapped codes. */
-export declare function statusForError(error: ApiError): number;
-//# sourceMappingURL=response.d.ts.map

package/dist/fastify/response.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/fastify/response.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAA0B,KAAK,QAAQ,EAAqB,MAAM,gBAAgB,CAAC;AAE1F,wDAAwD;AACxD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAEjF;AAED,sGAAsG;AACtG,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,CAEvF;AA8BD,gGAAgG;AAChG,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAEtD"}

package/dist/fastify/response.js

@@ -1,41 +0,0 @@
-import { createApiErrorResponse } from '@jini/protocol';
-/** Writes `body` as JSON with the given status code. */
-export function sendJson(reply, status, body) {
-    reply.code(status).send(body);
-}
-/** Writes an `ApiError`, wrapped in the standard `{ error }` envelope, with the given status code. */
-export function sendApiError(reply, status, error) {
-    reply.code(status).send(createApiErrorResponse(error));
-}
-/**
- * @internal
- * Default HTTP status per generic `ApiErrorCode`. Codes not listed here fall back to 500 in
- * `statusForError` — deliberately conservative, since an unmapped code (including any
- * product-specific code a consuming pack defines) is more likely a new server-side failure mode
- * than a client error. Kept identical to `../express/response.ts`'s copy — see this file's
- * top-of-module doc for why it is duplicated rather than imported.
- */
-const ERROR_STATUS_BY_CODE = {
-    BAD_REQUEST: 400,
-    UNAUTHORIZED: 401,
-    FORBIDDEN: 403,
-    NOT_FOUND: 404,
-    CONFLICT: 409,
-    PAYLOAD_TOO_LARGE: 413,
-    UNSUPPORTED_MEDIA_TYPE: 415,
-    VALIDATION_FAILED: 422,
-    RATE_LIMITED: 429,
-    INTERNAL_ERROR: 500,
-    UPSTREAM_UNAVAILABLE: 502,
-    TOOL_TOKEN_MISSING: 401,
-    TOOL_TOKEN_INVALID: 401,
-    TOOL_TOKEN_EXPIRED: 401,
-    TOOL_ENDPOINT_DENIED: 403,
-    TOOL_OPERATION_DENIED: 403,
-    TOOL_NOT_AVAILABLE: 503,
-};
-/** Resolves the HTTP status to send for an `ApiError`, defaulting to 500 for unmapped codes. */
-export function statusForError(error) {
-    return ERROR_STATUS_BY_CODE[error.code] ?? 500;
-}
-//# sourceMappingURL=response.js.map

package/dist/fastify/response.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"response.js","sourceRoot":"","sources":["../../src/fastify/response.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,sBAAsB,EAAoC,MAAM,gBAAgB,CAAC;AAE1F,wDAAwD;AACxD,MAAM,UAAU,QAAQ,CAAC,KAAmB,EAAE,MAAc,EAAE,IAAa;IACzE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC;AAED,sGAAsG;AACtG,MAAM,UAAU,YAAY,CAAC,KAAmB,EAAE,MAAc,EAAE,KAAe;IAC/E,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,oBAAoB,GAA0C;IAClE,WAAW,EAAE,GAAG;IAChB,YAAY,EAAE,GAAG;IACjB,SAAS,EAAE,GAAG;IACd,SAAS,EAAE,GAAG;IACd,QAAQ,EAAE,GAAG;IACb,iBAAiB,EAAE,GAAG;IACtB,sBAAsB,EAAE,GAAG;IAC3B,iBAAiB,EAAE,GAAG;IACtB,YAAY,EAAE,GAAG;IACjB,cAAc,EAAE,GAAG;IACnB,oBAAoB,EAAE,GAAG;IACzB,kBAAkB,EAAE,GAAG;IACvB,kBAAkB,EAAE,GAAG;IACvB,kBAAkB,EAAE,GAAG;IACvB,oBAAoB,EAAE,GAAG;IACzB,qBAAqB,EAAE,GAAG;IAC1B,kBAAkB,EAAE,GAAG;CACxB,CAAC;AAEF,gGAAgG;AAChG,MAAM,UAAU,cAAc,CAAC,KAAe;IAC5C,OAAO,oBAAoB,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC;AACjD,CAAC"}

package/dist/fastify/route-registration-guard.d.ts

@@ -1,70 +0,0 @@
-/**
- * @module fastify/route-registration-guard
- *
- * Builds a queryable inventory of every route registered on a Fastify instance, and guards a
- * caller-supplied set of "must register at most once" route keys against accidental duplicate
- * registration — e.g. two packs each mounting `POST /api/runs` would otherwise silently shadow
- * one another instead of failing loudly at composition time.
- *
- * Unlike the Express version (`../express/route-registration-guard.ts`, which monkey-patches
- * `get`/`post`/etc. because Express has no first-class "a route was just registered" signal),
- * Fastify exposes a built-in `onRoute` application hook that fires exactly once per registered
- * route with the fully resolved `{ method, url }` — no monkey-patching needed. `guardedRouteKey`
- * is deliberately duplicated (not imported) from the Express version; see
- * `./response.ts`'s top-of-module doc for why this subtree does not import from `express/`.
- */
-import type { FastifyInstance } from 'fastify';
-/** One recorded route registration: the HTTP verb and the literal string path it was mounted on. */
-export interface RouteRegistration {
-    method: string;
-    path: string;
-}
-/**
- * Builds the `METHOD PATH` key used to check `guardedRouteKeys` membership.
- *
- * @param method - The HTTP method name (any case; normalized to upper-case in the key).
- * @param path - The route's registered URL. Fastify's `onRoute` hook always supplies a string
- * `url`, so (unlike the Express version) there is no non-string-path branch to guard against here.
- * @param guardedRouteKeys - The set of `METHOD PATH` keys this call installed a duplicate-registration
- * guard for.
- * @returns The matching key if it is in `guardedRouteKeys`, otherwise `null`.
- * @complexity O(1) — a single `Set` lookup.
- * @overallScore 100/100
- */
-export declare function guardedRouteKey(method: string, path: string, guardedRouteKeys: ReadonlySet<string>): string | null;
-export interface InstallRouteRegistrationGuardOptions {
-    /** `METHOD PATH` keys (e.g. `'POST /api/runs'`) that must be registered at most once on `app`. Defaults to none — installing the guard with no options only builds the inventory, it enforces nothing. */
-    guardedRouteKeys?: ReadonlySet<string>;
-}
-/**
- * Registers a Fastify `onRoute` application hook that records every route registration into a
- * per-app inventory (retrievable via {@link getRouteRegistrationInventory}) and throws if any
- * `options.guardedRouteKeys` entry is registered a second time.
- *
- * A route registered for multiple HTTP methods at once (`method: ['GET', 'POST']`, or Fastify's
- * own automatic `HEAD` sibling for a `GET` route when `exposeHeadRoute` is left at its default)
- * produces one inventory entry and one guard check per method — mirroring how the Express version
- * records one entry per distinct `app.get(...)`/`app.post(...)` call.
- *
- * @param app - The Fastify instance to instrument. Must not already have this guard installed
- * (installing twice would double-register the `onRoute` hook and double-count the inventory — not
- * guarded against here since every caller in this codebase calls this exactly once per app at
- * composition time).
- * @param options.guardedRouteKeys - See {@link InstallRouteRegistrationGuardOptions}.
- * @returns Nothing — registers a hook on `app` and stashes its inventory under a well-known `Symbol.for` key.
- * @throws If a `guardedRouteKeys` entry is registered more than once, at the moment of the second registration.
- * @complexity O(1) setup; each `onRoute` firing is O(m) in the number of methods the route was registered for (typically 1).
- * @overallScore 100/100
- */
-export declare function installRouteRegistrationGuard(app: FastifyInstance, options?: InstallRouteRegistrationGuardOptions): void;
-/**
- * Reads back every route {@link installRouteRegistrationGuard} recorded for `app`.
- *
- * @param app - An app the guard was installed on. Safe to call on an app with no guard installed
- * (returns an empty array rather than throwing).
- * @returns A fresh array copy each call — the caller can never mutate the guard's own internal inventory through the returned reference.
- * @complexity O(n) in the number of routes registered so far.
- * @overallScore 100/100
- */
-export declare function getRouteRegistrationInventory(app: FastifyInstance): RouteRegistration[];
-//# sourceMappingURL=route-registration-guard.d.ts.map

package/dist/fastify/route-registration-guard.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"route-registration-guard.d.ts","sourceRoot":"","sources":["../../src/fastify/route-registration-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,oGAAoG;AACpG,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI,CAGlH;AAED,MAAM,WAAW,oCAAoC;IACnD,0MAA0M;IAC1M,gBAAgB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,eAAe,EACpB,OAAO,GAAE,oCAAyC,GACjD,IAAI,CAmBN;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,eAAe,GAAG,iBAAiB,EAAE,CAEvF"}

package/dist/fastify/route-registration-guard.js

@@ -1,69 +0,0 @@
-const routeInventorySymbol = Symbol.for('jini.routeRegistrationGuard.inventory');
-/**
- * Builds the `METHOD PATH` key used to check `guardedRouteKeys` membership.
- *
- * @param method - The HTTP method name (any case; normalized to upper-case in the key).
- * @param path - The route's registered URL. Fastify's `onRoute` hook always supplies a string
- * `url`, so (unlike the Express version) there is no non-string-path branch to guard against here.
- * @param guardedRouteKeys - The set of `METHOD PATH` keys this call installed a duplicate-registration
- * guard for.
- * @returns The matching key if it is in `guardedRouteKeys`, otherwise `null`.
- * @complexity O(1) — a single `Set` lookup.
- * @overallScore 100/100
- */
-export function guardedRouteKey(method, path, guardedRouteKeys) {
-    const key = `${method.toUpperCase()} ${path}`;
-    return guardedRouteKeys.has(key) ? key : null;
-}
-/**
- * Registers a Fastify `onRoute` application hook that records every route registration into a
- * per-app inventory (retrievable via {@link getRouteRegistrationInventory}) and throws if any
- * `options.guardedRouteKeys` entry is registered a second time.
- *
- * A route registered for multiple HTTP methods at once (`method: ['GET', 'POST']`, or Fastify's
- * own automatic `HEAD` sibling for a `GET` route when `exposeHeadRoute` is left at its default)
- * produces one inventory entry and one guard check per method — mirroring how the Express version
- * records one entry per distinct `app.get(...)`/`app.post(...)` call.
- *
- * @param app - The Fastify instance to instrument. Must not already have this guard installed
- * (installing twice would double-register the `onRoute` hook and double-count the inventory — not
- * guarded against here since every caller in this codebase calls this exactly once per app at
- * composition time).
- * @param options.guardedRouteKeys - See {@link InstallRouteRegistrationGuardOptions}.
- * @returns Nothing — registers a hook on `app` and stashes its inventory under a well-known `Symbol.for` key.
- * @throws If a `guardedRouteKeys` entry is registered more than once, at the moment of the second registration.
- * @complexity O(1) setup; each `onRoute` firing is O(m) in the number of methods the route was registered for (typically 1).
- * @overallScore 100/100
- */
-export function installRouteRegistrationGuard(app, options = {}) {
-    const guardedRouteKeys = options.guardedRouteKeys ?? new Set();
-    const seen = new Set();
-    const inventory = [];
-    app[routeInventorySymbol] = inventory;
-    app.addHook('onRoute', (routeOptions) => {
-        const methods = Array.isArray(routeOptions.method) ? routeOptions.method : [routeOptions.method];
-        for (const method of methods) {
-            inventory.push({ method: method.toUpperCase(), path: routeOptions.url });
-            const key = guardedRouteKey(method, routeOptions.url, guardedRouteKeys);
-            if (key) {
-                if (seen.has(key)) {
-                    throw new Error(`duplicate guarded route registration: ${key}`);
-                }
-                seen.add(key);
-            }
-        }
-    });
-}
-/**
- * Reads back every route {@link installRouteRegistrationGuard} recorded for `app`.
- *
- * @param app - An app the guard was installed on. Safe to call on an app with no guard installed
- * (returns an empty array rather than throwing).
- * @returns A fresh array copy each call — the caller can never mutate the guard's own internal inventory through the returned reference.
- * @complexity O(n) in the number of routes registered so far.
- * @overallScore 100/100
- */
-export function getRouteRegistrationInventory(app) {
-    return [...(app[routeInventorySymbol] ?? [])];
-}
-//# sourceMappingURL=route-registration-guard.js.map

package/dist/fastify/route-registration-guard.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"route-registration-guard.js","sourceRoot":"","sources":["../../src/fastify/route-registration-guard.ts"],"names":[],"mappings":"AAuBA,MAAM,oBAAoB,GAAG,MAAM,CAAC,GAAG,CAAC,uCAAuC,CAAC,CAAC;AAEjF;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAAC,MAAc,EAAE,IAAY,EAAE,gBAAqC;IACjG,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,WAAW,EAAE,IAAI,IAAI,EAAE,CAAC;IAC9C,OAAO,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;AAChD,CAAC;AAOD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,6BAA6B,CAC3C,GAAoB,EACpB,UAAgD,EAAE;IAElD,MAAM,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,IAAI,IAAI,GAAG,EAAU,CAAC;IACvE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,SAAS,GAAwB,EAAE,CAAC;IACzC,GAAsD,CAAC,oBAAoB,CAAC,GAAG,SAAS,CAAC;IAE1F,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,YAAY,EAAE,EAAE;QACtC,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QACjG,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,SAAS,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,EAAE,IAAI,EAAE,YAAY,CAAC,GAAG,EAAE,CAAC,CAAC;YACzE,MAAM,GAAG,GAAG,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;YACxE,IAAI,GAAG,EAAE,CAAC;gBACR,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;oBAClB,MAAM,IAAI,KAAK,CAAC,yCAAyC,GAAG,EAAE,CAAC,CAAC;gBAClE,CAAC;gBACD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAChB,CAAC;QACH,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,6BAA6B,CAAC,GAAoB;IAChE,OAAO,CAAC,GAAG,CAAE,GAAkE,CAAC,oBAAoB,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAChH,CAAC"}

package/dist/fastify/run-stream.d.ts

@@ -1,18 +0,0 @@
-/**
- * @module fastify/run-stream
- *
- * Fastify-specific mounting glue for the shared AG-UI SSE run-stream handler
- * (`../run-stream.js`). `reply.raw`/`request.raw` give the exact underlying `http.ServerResponse`/
- * `http.IncomingMessage` pair directly, so this file's only job is resolving the `runId` route
- * param and handing those raw objects straight through — a few lines, not a reimplementation, per
- * the design decision that motivated building the SSE primitive once instead of duplicating it
- * per transport. `reply.hijack()` tells Fastify this handler is taking over the raw response
- * itself, so Fastify's own reply lifecycle (which otherwise expects the handler to return a value
- * for it to serialize, or call `reply.send(...)`) does not try to act on a response this handler
- * already wrote to and ended directly.
- */
-import type { FastifyInstance } from 'fastify';
-import { type RunStreamDeps } from '../run-stream.js';
-/** Mounts the AG-UI SSE run-stream route on `app`. A pack's `http(app, services)` calls this directly. */
-export declare function registerRunStreamRoute(app: FastifyInstance, deps: RunStreamDeps): void;
-//# sourceMappingURL=run-stream.d.ts.map

package/dist/fastify/run-stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-stream.d.ts","sourceRoot":"","sources":["../../src/fastify/run-stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,eAAe,EAAgC,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAiD,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAErG,0GAA0G;AAC1G,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAMtF"}

package/dist/fastify/run-stream.js

@@ -1,10 +0,0 @@
-import { handleRunStreamRequest, RUN_STREAM_ROUTE_PATH } from '../run-stream.js';
-/** Mounts the AG-UI SSE run-stream route on `app`. A pack's `http(app, services)` calls this directly. */
-export function registerRunStreamRoute(app, deps) {
-    app.get(RUN_STREAM_ROUTE_PATH, async (request, reply) => {
-        reply.hijack();
-        const runId = request.params.runId;
-        await handleRunStreamRequest(request.raw, reply.raw, runId, deps);
-    });
-}
-//# sourceMappingURL=run-stream.js.map

package/dist/fastify/run-stream.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-stream.js","sourceRoot":"","sources":["../../src/fastify/run-stream.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAsB,MAAM,kBAAkB,CAAC;AAErG,0GAA0G;AAC1G,MAAM,UAAU,sBAAsB,CAAC,GAAoB,EAAE,IAAmB;IAC9E,GAAG,CAAC,GAAG,CAAC,qBAAqB,EAAE,KAAK,EAAE,OAAuB,EAAE,KAAmB,EAAE,EAAE;QACpF,KAAK,CAAC,MAAM,EAAE,CAAC;QACf,MAAM,KAAK,GAAI,OAAO,CAAC,MAA4B,CAAC,KAAK,CAAC;QAC1D,MAAM,sBAAsB,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IACpE,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/fastify/runs.d.ts

@@ -1,17 +0,0 @@
-/**
- * @module fastify/runs
- *
- * Fastify-mounting glue for `../runs.js`'s route logic — every `JsonRouteSpec` (`runStartRoute`,
- * `runListRoute`, `runStatusRoute`, `runCancelRoute`) and the SSE event-stream core
- * (`handleRunEventStreamRequest`) are the exact same functions the Express mounting in `../runs.js`
- * uses; nothing here re-implements route logic, only how a request reaches it and a response
- * leaves it, mirroring the rest of this `fastify/` subtree.
- */
-import type { FastifyInstance } from 'fastify';
-import type { RunHttpDeps } from '../runs.js';
-import { type AdapterContext } from './adapter.js';
-/** Mounts `GET /api/runs/:runId/events` on `app` via Fastify's native `route()` (matching `mountJsonRoute`'s own registration mechanism, unlike `fastify/run-stream.ts`'s `.get()` shorthand — kept consistent within this file since `registerRunRoutes` below mounts both through the same `app`), hijacking the reply so `handleRunEventStreamRequest` can write the raw SSE stream directly. */
-export declare function registerRunEventStream(app: FastifyInstance, deps: RunHttpDeps): void;
-/** Mounts create/status/cancel JSON endpoints and the SSE event stream as one run transport — the Fastify-native equivalent of `../runs.js`'s `registerRunRoutes`, mounting the identical `JsonRouteSpec` objects. */
-export declare function registerRunRoutes(app: FastifyInstance, deps: RunHttpDeps, adapter: AdapterContext): void;
-//# sourceMappingURL=runs.d.ts.map

package/dist/fastify/runs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runs.d.ts","sourceRoot":"","sources":["../../src/fastify/runs.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,eAAe,EAAgC,MAAM,SAAS,CAAC;AAC7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAWnE,oYAAoY;AACpY,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAWpF;AAED,sNAAsN;AACtN,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,GAAG,IAAI,CAMxG"}

package/dist/fastify/runs.js

@@ -1,33 +0,0 @@
-import { handleRunEventStreamRequest, runCancelRoute, runListRoute, runStartRoute, runStatusRoute } from '../runs.js';
-import { mountJsonRoute } from './adapter.js';
-/** Reads a reconnect cursor from the `Last-Event-ID` header, falling back to an `afterCursor` query parameter — the Fastify-request-shaped equivalent of `../sse.js`'s `requestedAfterCursor` (Fastify already parses both `.headers` and `.query` for us, so no Express-`Request`-shaped adapter object is needed here). */
-function requestedAfterCursorFastify(request) {
-    const header = request.headers['last-event-id'];
-    const headerValue = Array.isArray(header) ? header[0] : header;
-    if (headerValue !== undefined && headerValue.length > 0)
-        return headerValue;
-    const query = request.query?.afterCursor;
-    return typeof query === 'string' && query.length > 0 ? query : null;
-}
-/** Mounts `GET /api/runs/:runId/events` on `app` via Fastify's native `route()` (matching `mountJsonRoute`'s own registration mechanism, unlike `fastify/run-stream.ts`'s `.get()` shorthand — kept consistent within this file since `registerRunRoutes` below mounts both through the same `app`), hijacking the reply so `handleRunEventStreamRequest` can write the raw SSE stream directly. */
-export function registerRunEventStream(app, deps) {
-    app.route({
-        method: 'GET',
-        url: '/api/runs/:runId/events',
-        exposeHeadRoute: false,
-        handler: async (request, reply) => {
-            reply.hijack();
-            const runId = request.params.runId ?? '';
-            await handleRunEventStreamRequest(reply.raw, runId, requestedAfterCursorFastify(request), deps);
-        },
-    });
-}
-/** Mounts create/status/cancel JSON endpoints and the SSE event stream as one run transport — the Fastify-native equivalent of `../runs.js`'s `registerRunRoutes`, mounting the identical `JsonRouteSpec` objects. */
-export function registerRunRoutes(app, deps, adapter) {
-    mountJsonRoute(app, runStartRoute, deps, adapter);
-    mountJsonRoute(app, runListRoute, deps, adapter);
-    mountJsonRoute(app, runStatusRoute, deps, adapter);
-    mountJsonRoute(app, runCancelRoute, deps, adapter);
-    registerRunEventStream(app, deps);
-}
-//# sourceMappingURL=runs.js.map

package/dist/fastify/runs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"runs.js","sourceRoot":"","sources":["../../src/fastify/runs.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,2BAA2B,EAAE,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACtH,OAAO,EAAE,cAAc,EAAuB,MAAM,cAAc,CAAC;AAEnE,6TAA6T;AAC7T,SAAS,2BAA2B,CAAC,OAAuB;IAC1D,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;IAChD,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAC/D,IAAI,WAAW,KAAK,SAAS,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,WAAW,CAAC;IAC5E,MAAM,KAAK,GAAI,OAAO,CAAC,KAA6C,EAAE,WAAW,CAAC;IAClF,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AACtE,CAAC;AAED,oYAAoY;AACpY,MAAM,UAAU,sBAAsB,CAAC,GAAoB,EAAE,IAAiB;IAC5E,GAAG,CAAC,KAAK,CAAC;QACR,MAAM,EAAE,KAAK;QACb,GAAG,EAAE,yBAAyB;QAC9B,eAAe,EAAE,KAAK;QACtB,OAAO,EAAE,KAAK,EAAE,OAAuB,EAAE,KAAmB,EAAE,EAAE;YAC9D,KAAK,CAAC,MAAM,EAAE,CAAC;YACf,MAAM,KAAK,GAAI,OAAO,CAAC,MAA6B,CAAC,KAAK,IAAI,EAAE,CAAC;YACjE,MAAM,2BAA2B,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,EAAE,2BAA2B,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC;QAClG,CAAC;KACF,CAAC,CAAC;AACL,CAAC;AAED,sNAAsN;AACtN,MAAM,UAAU,iBAAiB,CAAC,GAAoB,EAAE,IAAiB,EAAE,OAAuB;IAChG,cAAc,CAAC,GAAG,EAAE,aAAa,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAClD,cAAc,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACjD,cAAc,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACnD,cAAc,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACnD,sBAAsB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACpC,CAAC"}

package/dist/run-stream.d.ts

@@ -1,60 +0,0 @@
-/**
- * @module run-stream
- *
- * An encoder-driven SSE run-stream route: subscribes to a run via `@jini-ai/daemon`'s
- * `RunLifecycle.stream`, pipes every event through a composition-root-supplied protocol encoder,
- * and writes each non-null event to the SSE response opened by `createSseResponse`.
- * `handleRunStreamRequest` is the core
- * — it only ever touches `node:http`'s `IncomingMessage`/`ServerResponse` — and
- * `registerRunStreamRoute` below is Express's own thin mounting glue (Express's `Request`/
- * `Response` already *are* Node's raw `http.IncomingMessage`/`http.ServerResponse`, so resolving
- * `req.params.runId` and handing the request/response straight through is the whole job).
- */
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { RunLifecycle } from '@jini-ai/daemon';
-import type { RunProtocolEvent } from '@jini-ai/protocol';
-import type { Express } from 'express';
-/** Backward-compatible route path used by the AG-UI composition. The handler itself is encoder-agnostic. */
-export declare const RUN_STREAM_ROUTE_PATH = "/api/runs/:runId/agui-stream";
-export interface RunStreamEncoder {
-    encode(event: RunProtocolEvent, context: {
-        readonly runId: string;
-    }): unknown | null;
-}
-export interface RunStreamInternalErrorContext {
-    readonly source: 'encoder' | 'lifecycle' | 'route';
-    readonly runId: string;
-    readonly error: unknown;
-}
-export interface RunStreamDeps {
-    readonly lifecycle: RunLifecycle;
-    /** Protocol adapter supplied by the composition root (for example `createGenUiEncoder()`). */
-    readonly encoder: RunStreamEncoder;
-    /** Host-owned sink for failures that must not escape an async Express handler. Defaults to `console.error`. */
-    readonly onInternalError?: (context: RunStreamInternalErrorContext) => void;
-}
-/**
- * Handles one encoded SSE run-stream request end to end. Opens the SSE connection immediately (an
- * SSE endpoint commits to `text/event-stream` headers before it can know whether `runId` is
- * valid), then subscribes to the run: a replay-then-live-subscribe `unknown-run`/`replay-gap`/
- * `invalid-cursor` result is reported as one `{ error }` SSE data event before closing (there is
- * no JSON-status-code channel left once SSE headers are already committed). On the happy path,
- * every event `RunLifecycle` delivers is encoded and forwarded; the connection closes itself once
- * the run's own terminal `'end'` event has been forwarded (a driver's contract with
- * `RunLifecycle` guarantees no further events follow a run's `'end')`, so nothing is lost by
- * closing right after it). If the client disconnects first, `createSseResponse`'s own
- * `req.on('close', ...)` fires first, which (via `onClose` here) unsubscribes from the run so a
- * disconnected client never leaves a dangling `RunLifecycle` subscriber.
- *
- * @param req - The raw request `createSseResponse` opens the stream against.
- * @param res - The raw response `createSseResponse` opens the stream against.
- * @param runId - The run to stream, already resolved by the caller's transport-specific glue.
- * @param deps.lifecycle - The `RunLifecycle` to subscribe to.
- * @param deps.encoder - The protocol adapter chosen by the composition root.
- * @complexity O(1) plus the supplied encoder's per-event cost and `RunLifecycle.stream`'s replay cost.
- * @overallScore 100/100
- */
-export declare function handleRunStreamRequest(req: IncomingMessage, res: ServerResponse, runId: string, deps: RunStreamDeps): Promise<void>;
-/** Mounts the encoder-driven SSE run-stream route on `app`. */
-export declare function registerRunStreamRoute(app: Express, deps: RunStreamDeps): void;
-//# sourceMappingURL=run-stream.d.ts.map

package/dist/run-stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-stream.d.ts","sourceRoot":"","sources":["../src/run-stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAyB,MAAM,iBAAiB,CAAC;AAC3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAqB,MAAM,SAAS,CAAC;AAG1D,4GAA4G;AAC5G,eAAO,MAAM,qBAAqB,iCAAiC,CAAC;AAEpE,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,GAAG,IAAI,CAAC;CACtF;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;IACnD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,8FAA8F;IAC9F,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,+GAA+G;IAC/G,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,6BAA6B,KAAK,IAAI,CAAC;CAC7E;AAwBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,IAAI,CAAC,CAuCf;AAED,+DAA+D;AAC/D,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAiB9E"}

package/dist/run-stream.js

@@ -1,108 +0,0 @@
-import { createSseResponse } from './raw-sse.js';
-/** Backward-compatible route path used by the AG-UI composition. The handler itself is encoder-agnostic. */
-export const RUN_STREAM_ROUTE_PATH = '/api/runs/:runId/agui-stream';
-function reportRunStreamInternalError(deps, source, runId, error) {
-    const context = { source, runId, error };
-    try {
-        if (deps.onInternalError) {
-            deps.onInternalError(context);
-        }
-        else {
-            // eslint-disable-next-line no-console
-            console.error(`[@jini-ai/http-kit] internal error (run-stream:${source}, runId=${runId})`, error);
-        }
-    }
-    catch (sinkError) {
-        // A diagnostic sink must never turn an already-contained stream failure into an unhandled
-        // rejection of its own.
-        // eslint-disable-next-line no-console
-        console.error(`[@jini-ai/http-kit] internal error sink failed (run-stream:${source}, runId=${runId})`, sinkError);
-    }
-}
-/**
- * Handles one encoded SSE run-stream request end to end. Opens the SSE connection immediately (an
- * SSE endpoint commits to `text/event-stream` headers before it can know whether `runId` is
- * valid), then subscribes to the run: a replay-then-live-subscribe `unknown-run`/`replay-gap`/
- * `invalid-cursor` result is reported as one `{ error }` SSE data event before closing (there is
- * no JSON-status-code channel left once SSE headers are already committed). On the happy path,
- * every event `RunLifecycle` delivers is encoded and forwarded; the connection closes itself once
- * the run's own terminal `'end'` event has been forwarded (a driver's contract with
- * `RunLifecycle` guarantees no further events follow a run's `'end')`, so nothing is lost by
- * closing right after it). If the client disconnects first, `createSseResponse`'s own
- * `req.on('close', ...)` fires first, which (via `onClose` here) unsubscribes from the run so a
- * disconnected client never leaves a dangling `RunLifecycle` subscriber.
- *
- * @param req - The raw request `createSseResponse` opens the stream against.
- * @param res - The raw response `createSseResponse` opens the stream against.
- * @param runId - The run to stream, already resolved by the caller's transport-specific glue.
- * @param deps.lifecycle - The `RunLifecycle` to subscribe to.
- * @param deps.encoder - The protocol adapter chosen by the composition root.
- * @complexity O(1) plus the supplied encoder's per-event cost and `RunLifecycle.stream`'s replay cost.
- * @overallScore 100/100
- */
-export async function handleRunStreamRequest(req, res, runId, deps) {
-    let unsubscribe;
-    const connection = createSseResponse(req, res, {
-        onClose: () => unsubscribe?.(),
-    });
-    const encoder = deps.encoder;
-    let result;
-    try {
-        result = await deps.lifecycle.stream(runId, (event) => {
-            if (connection.closed)
-                return;
-            try {
-                const encoded = encoder.encode(event, { runId });
-                if (encoded != null)
-                    connection.send(encoded);
-                if (event.kind === 'end')
-                    connection.close();
-            }
-            catch (error) {
-                reportRunStreamInternalError(deps, 'encoder', runId, error);
-                connection.close();
-            }
-        });
-    }
-    catch (error) {
-        reportRunStreamInternalError(deps, 'lifecycle', runId, error);
-        connection.close();
-        return;
-    }
-    if (result.kind !== 'ok') {
-        connection.send({ error: result.kind });
-        connection.close();
-        return;
-    }
-    // Assigned even when the run was already terminal (in which case the driver-facing 'end' event
-    // was already replayed synchronously above, already closing the connection, and `unsubscribe`
-    // here is `RunLifecycle`'s own no-op stub for that case) — keeping this assignment unconditional
-    // avoids a branch whose two arms would otherwise do the same thing.
-    unsubscribe = result.unsubscribe;
-    // The raw request can close while RunLifecycle is still awaiting durable replay. In that
-    // window `onClose` runs before `unsubscribe` exists, so clean up immediately once it arrives.
-    if (connection.closed)
-        unsubscribe();
-}
-/** Mounts the encoder-driven SSE run-stream route on `app`. */
-export function registerRunStreamRoute(app, deps) {
-    app.get(RUN_STREAM_ROUTE_PATH, async (req, res) => {
-        // `:runId` is a required path segment of RUN_STREAM_ROUTE_PATH — this handler is only ever
-        // reached via a URL that already matched it, so the param is always present at runtime even
-        // though @types/express types every param as possibly `undefined` in general.
-        const runId = req.params.runId;
-        try {
-            await handleRunStreamRequest(req, res, runId, deps);
-        }
-        catch (error) {
-            reportRunStreamInternalError(deps, 'route', runId, error);
-            if (!res.headersSent) {
-                res.status(500).json({ error: { code: 'INTERNAL_ERROR', message: 'an internal error occurred' } });
-            }
-            else if (!res.writableEnded) {
-                res.end();
-            }
-        }
-    });
-}
-//# sourceMappingURL=run-stream.js.map

package/dist/run-stream.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-stream.js","sourceRoot":"","sources":["../src/run-stream.ts"],"names":[],"mappings":"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"}