@anvia/server 1.1.4 → 1.2.0

package/README.md

@@ -1,55 +1,79 @@
 # @anvia/server
 
-Server response helpers for the Anvia client protocol and explicitly generic event streams.
+Serve Anvia completions and Agent runs over HTTP. These framework-neutral response helpers turn
+async events into streaming `Response` objects for Anvia clients, with JSONL, SSE, and replay support.
 
-## Bun
-
-Bun 1.3.14 is the currently tested and supported runtime baseline:
+## Install
 
 ```sh
-bun add @anvia/server @anvia/client
+pnpm add @anvia/server @anvia/client @anvia/core @anvia/openai
 ```
 
-Compatibility tests run these helpers through `Bun.serve`, covering framed JSONL and SSE,
-resumable replay, cancellation cleanup, and installation from packed package artifacts.
+The quickstart uses OpenAI; choose another provider adapter if needed.
 
-## Client protocol responses
+## Quickstart
 
-Adapt native runtime events at the server boundary, then frame them for the client:
+Set `OPENAI_API_KEY` on your server and mount this handler in a framework that accepts Web
+`Request` and `Response` objects:
 
 ```ts
 import { completionToClientStream, parseClientStreamRequest } from "@anvia/client";
 import { streamCompletion } from "@anvia/core";
+import { OpenAIClient } from "@anvia/openai";
 import { createClientStreamResponse } from "@anvia/server";
 
-const body = parseClientStreamRequest(await request.json());
-if (body.type !== "messages") throw new Error("This completion endpoint accepts messages only.");
-const events = completionToClientStream({
-  events: streamCompletion({ model, messages: body.messages }),
+const apiKey = process.env.OPENAI_API_KEY;
+if (!apiKey) throw new Error("Set OPENAI_API_KEY.");
+const model = new OpenAIClient({ apiKey }).completionModel({
+  modelId: "gpt-5",
+  api: "responses",
 });
 
-return createClientStreamResponse({ events }); // JSONL by default
+export async function POST(request: Request): Promise<Response> {
+  const body = parseClientStreamRequest(await request.json());
+  if (body.type !== "messages") {
+    return new Response("This endpoint accepts messages only.", { status: 400 });
+  }
+  const events = completionToClientStream({
+    events: streamCompletion({ model, messages: body.messages, abortSignal: request.signal }),
+  });
+  return createClientStreamResponse({ events });
+}
 ```
 
-`createClientStreamResponse({ events, ...options })` always emits `stream_start`, ordered
-`stream_event` frames, and `stream_end`, and sets
-`x-anvia-stream-protocol: anvia.client.v3`. Use `format: "sse"` for SSE framing.
+Connect with `createHttpClientTransport` from `@anvia/client`, or use it with the `@anvia/react`
+hooks. Add `format: "sse"` to the response options for SSE instead of the default JSONL.
+
+## Capabilities
+
+- Framed client responses with protocol headers and ordered event IDs.
+- Resumable streams backed by a store you provide, with an in-memory store for local use.
+- Separate generic event responses for application-defined protocols.
+- Lower-level JSONL and SSE stream helpers.
+
+Your application owns routing, authentication, request error handling, and durable storage.
+
+## Learn more
 
-For resumable streams, pass `{ resumable: { streamId, store } }` when creating the response and
-call `resumeClientStreamResponse({ streamId, after, store })` for a resume request.
+- [Server streaming guide](https://github.com/anvia-hq/anvia/blob/main/docs/packages/server.md)
+- [Client protocol](https://github.com/anvia-hq/anvia/tree/main/packages/client#readme)
+- [React hooks](https://github.com/anvia-hq/anvia/tree/main/packages/react#readme)
 
-## Generic event responses
+## Durable execution routes
 
-`createEventStreamResponse({ events, ...options })` and `resumeEventStreamResponse(options)` are
-separate, generic helpers. They serialize the event type supplied by the application and do not
-claim that it is the Anvia client protocol.
+The optional `@anvia/server/durable` entrypoint exports `createDurableHandler` for
+`@anvia/durable` runtimes. It provides submission, session-scoped run listing, snapshots,
+SSE events with persisted IDs, approval responses, retry, cancellation, and reconciliation.
+An `authorize(request, resource)` callback is required for all reads and writes. The host
+owns runtime startup (`resume`) and shutdown (`close`). Client disconnects detach observers.
 
-The lower-level exports are:
+Install `@anvia/durable` when using this subpath. See the
+[durable HTTP guide](../../docs/packages/durable.md#http-server-and-client).
 
-- `createJsonlStream({ events, ...options })`
-- `createSseStream({ events, ...options })`
-- `createResumableStream({ events, ...options })`
-- `resumeStreamEvents(options)`
-- `createMemoryResumableStreamStore()`
+Generic `SseStreamOptions` also supports `eventId(event)` for native SSE IDs and
+`onCancel()` to interrupt a pending producer read before its iterator is returned.
 
-There are no compatibility aliases for the removed ambiguous response APIs.
+Durable graph routes under `/durable/graphs` expose submission, paginated discovery, topology
+snapshots, task SSE events, and cancellation. Graph-wide operations authorize every task;
+individual child-run routes authorize against the graph's owning session. See the
+[task graph guide](../../docs/packages/durable.md#task-dependencies-and-exposed-graphs).

package/dist/chunk-E2M7MXTL.js

@@ -0,0 +1,450 @@
+// src/errors.ts
+import { isJsonValue } from "@anvia/client";
+function errorEvent(error) {
+  return {
+    type: "error",
+    error: serializeError(error)
+  };
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    const serialized = {
+      name: error.name,
+      message: error.message
+    };
+    const code = error.code;
+    if (typeof code === "string") {
+      serialized.code = code;
+    }
+    const retryable = error.retryable;
+    if (typeof retryable === "boolean") {
+      serialized.retryable = retryable;
+    }
+    if (isJsonValue(error.details)) {
+      serialized.details = error.details;
+    }
+    return serialized;
+  }
+  if (!isJsonValue(error)) {
+    return { message: String(error) };
+  }
+  return error;
+}
+
+// src/jsonl.ts
+function createJsonlStream(options) {
+  const encoder = new TextEncoder();
+  const iterator = options.events[Symbol.asyncIterator]();
+  const serialize = options.serialize ?? serializeJson;
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const next = await iterator.next();
+        if (next.done === true) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(encoder.encode(`${serialize(next.value)}
+`));
+      } catch (error) {
+        controller.enqueue(encoder.encode(`${serialize(errorEvent(error))}
+`));
+        controller.close();
+      }
+    },
+    async cancel() {
+      await iterator.return?.();
+    }
+  });
+}
+function serializeJson(value) {
+  return JSON.stringify(value);
+}
+
+// src/resumable.ts
+function createResumableStream(options) {
+  const streamId = options.id;
+  let openPromise;
+  function start() {
+    if (openPromise !== void 0) {
+      return openPromise;
+    }
+    openPromise = options.store.open({ streamId }).then(() => void 0);
+    void drainResumableStream(options.events, options, openPromise);
+    return openPromise;
+  }
+  return {
+    async *[Symbol.asyncIterator]() {
+      await start();
+      yield* resumeStreamEvents({ id: streamId, store: options.store });
+    }
+  };
+}
+async function* resumeStreamEvents(options) {
+  const streamId = options.id;
+  yield { type: "stream_start", streamId, eventId: 0 };
+  const subscribeInput = { streamId };
+  if (options.after !== void 0) {
+    subscribeInput.after = options.after;
+  }
+  for await (const record of options.store.subscribe(subscribeInput)) {
+    yield recordToEnvelope(record);
+  }
+  const state = await options.store.status({ streamId });
+  yield stateToEndEnvelope(streamId, state);
+}
+function createMemoryResumableStreamStore() {
+  const streams = /* @__PURE__ */ new Map();
+  function state(stream) {
+    if (stream === void 0) {
+      return { status: "missing", lastEventId: 0 };
+    }
+    return {
+      status: stream.status,
+      lastEventId: stream.records.at(-1)?.eventId ?? 0
+    };
+  }
+  return {
+    async open(input) {
+      const existing = streams.get(input.streamId);
+      if (existing !== void 0) {
+        closeSubscribers(existing);
+      }
+      const stream = {
+        records: [],
+        status: "running",
+        subscribers: /* @__PURE__ */ new Set()
+      };
+      streams.set(input.streamId, stream);
+      return state(stream);
+    },
+    async append(input) {
+      const stream = streams.get(input.streamId);
+      if (stream === void 0) {
+        throw new Error(`Resumable stream "${input.streamId}" is not open`);
+      }
+      if (stream.status !== "running") {
+        throw new Error(`Resumable stream "${input.streamId}" is already ${stream.status}`);
+      }
+      const record = {
+        streamId: input.streamId,
+        eventId: stream.records.length + 1,
+        event: input.event,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      stream.records.push(record);
+      for (const subscriber of stream.subscribers) {
+        if (record.eventId > subscriber.after) {
+          subscriber.queue.enqueue(record);
+        }
+      }
+      return record;
+    },
+    subscribe(input) {
+      const after = input.after ?? 0;
+      return {
+        [Symbol.asyncIterator]() {
+          const stream = streams.get(input.streamId);
+          const queue = createAsyncQueue();
+          if (stream === void 0) {
+            queue.close();
+            return queue[Symbol.asyncIterator]();
+          }
+          for (const record of stream.records) {
+            if (record.eventId > after) {
+              queue.enqueue(record);
+            }
+          }
+          if (stream.status !== "running") {
+            queue.close();
+            return queue[Symbol.asyncIterator]();
+          }
+          const subscriber = { after, queue };
+          stream.subscribers.add(subscriber);
+          const iterator = queue[Symbol.asyncIterator]();
+          return {
+            next: () => iterator.next(),
+            async return() {
+              stream.subscribers.delete(subscriber);
+              queue.close();
+              return { value: void 0, done: true };
+            }
+          };
+        }
+      };
+    },
+    async status(input) {
+      return state(streams.get(input.streamId));
+    },
+    async close(input) {
+      const stream = streams.get(input.streamId);
+      if (stream === void 0) {
+        return { status: input.status, lastEventId: 0 };
+      }
+      stream.status = input.status;
+      closeSubscribers(stream);
+      return state(stream);
+    }
+  };
+}
+async function drainResumableStream(events, options, openPromise) {
+  const streamId = options.id;
+  try {
+    await openPromise;
+    for await (const event of events) {
+      await options.store.append({ streamId, event });
+    }
+    await options.store.close({ streamId, status: "completed" });
+  } catch (error) {
+    const event = errorEvent(error);
+    try {
+      await options.store.append({ streamId, event });
+    } catch {
+    }
+    try {
+      await options.store.close({ streamId, status: "error" });
+    } catch {
+    }
+  }
+}
+function recordToEnvelope(record) {
+  return {
+    type: "stream_event",
+    streamId: record.streamId,
+    eventId: record.eventId,
+    event: record.event
+  };
+}
+function stateToEndEnvelope(streamId, state) {
+  return {
+    type: "stream_end",
+    streamId,
+    eventId: state.lastEventId,
+    status: state.status
+  };
+}
+function closeSubscribers(stream) {
+  for (const subscriber of stream.subscribers) {
+    subscriber.queue.close();
+  }
+  stream.subscribers.clear();
+}
+function createAsyncQueue() {
+  const values = [];
+  const waiters = [];
+  let closed = false;
+  let error;
+  function flush() {
+    while (waiters.length > 0 && values.length > 0) {
+      const waiter = waiters.shift();
+      const value = values.shift();
+      waiter?.resolve({ value, done: false });
+    }
+    if (values.length > 0 || waiters.length === 0 || !closed) {
+      return;
+    }
+    while (waiters.length > 0) {
+      const waiter = waiters.shift();
+      if (waiter === void 0) {
+        continue;
+      }
+      if (error !== void 0) {
+        waiter.reject(error);
+      } else {
+        waiter.resolve({ value: void 0, done: true });
+      }
+    }
+  }
+  return {
+    enqueue(value) {
+      if (closed) {
+        return;
+      }
+      values.push(value);
+      flush();
+    },
+    close() {
+      closed = true;
+      flush();
+    },
+    throw(thrown) {
+      closed = true;
+      error = thrown;
+      flush();
+    },
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          if (values.length > 0) {
+            const value = values.shift();
+            return Promise.resolve({ value, done: false });
+          }
+          if (error !== void 0) {
+            return Promise.reject(error);
+          }
+          if (closed) {
+            return Promise.resolve({ value: void 0, done: true });
+          }
+          return new Promise((resolve, reject) => {
+            waiters.push({ resolve, reject });
+          });
+        }
+      };
+    }
+  };
+}
+
+// src/sse.ts
+function createSseStream(options) {
+  validateSseOptions(options);
+  const encoder = new TextEncoder();
+  const iterator = options.events[Symbol.asyncIterator]();
+  const serialize = options.serialize ?? serializeJson2;
+  let cancelled = false;
+  return new ReadableStream({
+    start(controller) {
+      if (options.retry !== void 0) {
+        controller.enqueue(encoder.encode(`retry: ${options.retry}
+
+`));
+      }
+    },
+    async pull(controller) {
+      try {
+        const next = await iterator.next();
+        if (cancelled) return;
+        if (next.done === true) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(
+          encoder.encode(formatSseEvent(next.value, serialize, options.eventName, options.eventId))
+        );
+      } catch (error) {
+        if (cancelled) return;
+        const event = errorEvent(error);
+        controller.enqueue(encoder.encode(formatSseEvent(event, serialize, options.eventName)));
+        controller.close();
+      }
+    },
+    async cancel() {
+      cancelled = true;
+      await options.onCancel?.();
+      await iterator.return?.();
+    }
+  });
+}
+function formatSseEvent(event, serialize, eventName, eventId) {
+  const name = typeof eventName === "function" ? eventName(event) : eventName;
+  const lines = [];
+  const id = eventId?.(event);
+  if (id !== void 0) {
+    validateSseEventName(id);
+    lines.push(`id: ${id}`);
+  }
+  if (name !== void 0 && name.length > 0) {
+    validateSseEventName(name);
+    lines.push(`event: ${name}`);
+  }
+  for (const line of serialize(event).split(/\r?\n/)) {
+    lines.push(`data: ${line}`);
+  }
+  lines.push("", "");
+  return lines.join("\n");
+}
+function serializeJson2(value) {
+  return JSON.stringify(value);
+}
+function validateSseOptions(options) {
+  if (options.retry !== void 0 && !isValidRetry(options.retry)) {
+    throw new TypeError("SSE retry must be a finite non-negative integer");
+  }
+  if (typeof options.eventName === "string") {
+    validateSseEventName(options.eventName);
+  }
+}
+function isValidRetry(value) {
+  return Number.isFinite(value) && Number.isInteger(value) && value >= 0;
+}
+function validateSseEventName(name) {
+  for (const character of name) {
+    const code = character.charCodeAt(0);
+    if (code === 0 || code === 10 || code === 13) {
+      throw new TypeError("SSE event names must not contain null bytes or line breaks");
+    }
+  }
+}
+
+// src/response.ts
+function createEventStreamResponse(options) {
+  const eventsForResponse = options.resumable === void 0 ? options.events : createResumableStream({ events: options.events, ...options.resumable });
+  return encodeEventStreamResponse({
+    events: eventsForResponse,
+    ...copyResponseOptions(options)
+  });
+}
+function resumeEventStreamResponse(options) {
+  return encodeEventStreamResponse({
+    events: resumeStreamEvents({
+      id: options.streamId,
+      after: options.after,
+      store: options.store
+    }),
+    ...copyResponseOptions(options)
+  });
+}
+function encodeEventStreamResponse(options) {
+  const format = options.format ?? "jsonl";
+  const headers = new Headers(options.headers);
+  if (!headers.has("cache-control")) {
+    headers.set("cache-control", "no-cache, no-transform");
+  }
+  if (!headers.has("connection")) {
+    headers.set("connection", "keep-alive");
+  }
+  if (!headers.has("x-accel-buffering")) {
+    headers.set("x-accel-buffering", "no");
+  }
+  const body = format === "sse" ? createSseStream({ events: options.events, ...options.sse }) : createJsonlStream({ events: options.events, ...options.jsonl });
+  if (!headers.has("content-type")) {
+    headers.set(
+      "content-type",
+      format === "sse" ? "text/event-stream; charset=utf-8" : "application/x-ndjson; charset=utf-8"
+    );
+  }
+  const responseInit = { headers };
+  if (options.status !== void 0) {
+    responseInit.status = options.status;
+  }
+  if (options.statusText !== void 0) {
+    responseInit.statusText = options.statusText;
+  }
+  return new Response(body, responseInit);
+}
+function copyResponseOptions(options) {
+  const next = {};
+  if (options.format !== void 0) next.format = options.format;
+  if (options.headers !== void 0) next.headers = options.headers;
+  if (options.status !== void 0) next.status = options.status;
+  if (options.statusText !== void 0) next.statusText = options.statusText;
+  if (options.jsonl !== void 0) {
+    next.jsonl = options.jsonl;
+  }
+  if (options.sse !== void 0) {
+    next.sse = options.sse;
+  }
+  return next;
+}
+
+export {
+  errorEvent,
+  createJsonlStream,
+  createResumableStream,
+  resumeStreamEvents,
+  createMemoryResumableStreamStore,
+  createSseStream,
+  createEventStreamResponse,
+  resumeEventStreamResponse,
+  encodeEventStreamResponse
+};
+//# sourceMappingURL=chunk-E2M7MXTL.js.map

package/dist/chunk-E2M7MXTL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/jsonl.ts","../src/resumable.ts","../src/sse.ts","../src/response.ts"],"sourcesContent":["import { isJsonValue } from \"@anvia/client\";\nimport type { EventStreamErrorEvent } from \"./types\";\n\nexport function errorEvent(error: unknown): EventStreamErrorEvent {\n  return {\n    type: \"error\",\n    error: serializeError(error),\n  };\n}\n\nfunction serializeError(error: unknown): unknown {\n  if (error instanceof Error) {\n    const serialized: {\n      name: string;\n      message: string;\n      code?: string;\n      retryable?: boolean;\n      details?: unknown;\n    } = {\n      name: error.name,\n      message: error.message,\n    };\n    // Runtime-specific Error subclasses (for example bun:sqlite's SqliteError)\n    // can keep diagnostic fields such as `code` on the prototype, where\n    // JSON.stringify drops them. Copy the protocol's diagnostic fields\n    // explicitly so the wire payload stays valid and diagnosable.\n    const code = (error as { code?: unknown }).code;\n    if (typeof code === \"string\") {\n      serialized.code = code;\n    }\n    const retryable = (error as { retryable?: unknown }).retryable;\n    if (typeof retryable === \"boolean\") {\n      serialized.retryable = retryable;\n    }\n    if (isJsonValue((error as { details?: unknown }).details)) {\n      serialized.details = (error as { details?: unknown }).details;\n    }\n    return serialized;\n  }\n\n  if (!isJsonValue(error)) {\n    // A thrown non-Error that is not JSON-safe would serialize as `{}` or lose\n    // its diagnostics entirely; degrade to a string payload instead.\n    return { message: String(error) };\n  }\n  return error;\n}\n","import { errorEvent } from \"./errors\";\nimport type { JsonlStreamOptions } from \"./types\";\n\nexport function createJsonlStream<TEvent>(\n  options: JsonlStreamOptions<TEvent> & { events: AsyncIterable<TEvent> },\n): ReadableStream<Uint8Array> {\n  const encoder = new TextEncoder();\n  const iterator = options.events[Symbol.asyncIterator]();\n  const serialize = options.serialize ?? serializeJson;\n\n  return new ReadableStream<Uint8Array>({\n    async pull(controller) {\n      try {\n        const next = await iterator.next();\n        if (next.done === true) {\n          controller.close();\n          return;\n        }\n\n        controller.enqueue(encoder.encode(`${serialize(next.value)}\\n`));\n      } catch (error) {\n        controller.enqueue(encoder.encode(`${serialize(errorEvent(error))}\\n`));\n        controller.close();\n      }\n    },\n    async cancel() {\n      await iterator.return?.();\n    },\n  });\n}\n\nfunction serializeJson(value: unknown): string {\n  return JSON.stringify(value);\n}\n","import { errorEvent } from \"./errors\";\nimport type {\n  CreateResumableStreamOptions,\n  ResumableStreamEnvelope,\n  ResumableStreamRecord,\n  ResumableStreamState,\n  ResumableStreamStatus,\n  ResumableStreamStore,\n  ResumableStreamSubscribeInput,\n  ResumeStreamEventsOptions,\n} from \"./types\";\n\ntype Subscriber<TEvent> = {\n  after: number;\n  queue: AsyncQueue<ResumableStreamRecord<TEvent>>;\n};\n\ntype MemoryStream<TEvent> = {\n  records: ResumableStreamRecord<TEvent>[];\n  status: ResumableStreamStatus;\n  subscribers: Set<Subscriber<TEvent>>;\n};\n\ntype AsyncQueue<T> = AsyncIterable<T> & {\n  enqueue(value: T): void;\n  close(): void;\n  throw(error: unknown): void;\n};\n\nexport function createResumableStream<TEvent>(\n  options: CreateResumableStreamOptions<TEvent> & { events: AsyncIterable<TEvent> },\n): AsyncIterable<ResumableStreamEnvelope<TEvent>> {\n  const streamId = options.id;\n  let openPromise: Promise<void> | undefined;\n\n  function start(): Promise<void> {\n    if (openPromise !== undefined) {\n      return openPromise;\n    }\n\n    openPromise = options.store.open({ streamId }).then(() => undefined);\n    void drainResumableStream(options.events, options, openPromise);\n    return openPromise;\n  }\n\n  return {\n    async *[Symbol.asyncIterator]() {\n      await start();\n      yield* resumeStreamEvents({ id: streamId, store: options.store });\n    },\n  };\n}\n\nexport async function* resumeStreamEvents<TEvent>(\n  options: ResumeStreamEventsOptions<TEvent>,\n): AsyncIterable<ResumableStreamEnvelope<TEvent>> {\n  const streamId = options.id;\n  yield { type: \"stream_start\", streamId, eventId: 0 };\n\n  const subscribeInput: ResumableStreamSubscribeInput = { streamId };\n  if (options.after !== undefined) {\n    subscribeInput.after = options.after;\n  }\n  for await (const record of options.store.subscribe(subscribeInput)) {\n    yield recordToEnvelope(record);\n  }\n\n  const state = await options.store.status({ streamId });\n  yield stateToEndEnvelope<TEvent>(streamId, state);\n}\n\nexport function createMemoryResumableStreamStore<TEvent = unknown>(): ResumableStreamStore<TEvent> {\n  const streams = new Map<string, MemoryStream<TEvent>>();\n\n  function state(stream: MemoryStream<TEvent> | undefined): ResumableStreamState {\n    if (stream === undefined) {\n      return { status: \"missing\", lastEventId: 0 };\n    }\n    return {\n      status: stream.status,\n      lastEventId: stream.records.at(-1)?.eventId ?? 0,\n    };\n  }\n\n  return {\n    async open(input) {\n      const existing = streams.get(input.streamId);\n      if (existing !== undefined) {\n        closeSubscribers(existing);\n      }\n\n      const stream: MemoryStream<TEvent> = {\n        records: [],\n        status: \"running\",\n        subscribers: new Set(),\n      };\n      streams.set(input.streamId, stream);\n      return state(stream);\n    },\n\n    async append(input) {\n      const stream = streams.get(input.streamId);\n      if (stream === undefined) {\n        throw new Error(`Resumable stream \"${input.streamId}\" is not open`);\n      }\n      if (stream.status !== \"running\") {\n        throw new Error(`Resumable stream \"${input.streamId}\" is already ${stream.status}`);\n      }\n\n      const record: ResumableStreamRecord<TEvent> = {\n        streamId: input.streamId,\n        eventId: stream.records.length + 1,\n        event: input.event,\n        createdAt: new Date(),\n      };\n      stream.records.push(record);\n\n      for (const subscriber of stream.subscribers) {\n        if (record.eventId > subscriber.after) {\n          subscriber.queue.enqueue(record);\n        }\n      }\n\n      return record;\n    },\n\n    subscribe(input) {\n      const after = input.after ?? 0;\n      return {\n        [Symbol.asyncIterator](): AsyncIterator<ResumableStreamRecord<TEvent>> {\n          const stream = streams.get(input.streamId);\n          const queue = createAsyncQueue<ResumableStreamRecord<TEvent>>();\n          if (stream === undefined) {\n            queue.close();\n            return queue[Symbol.asyncIterator]();\n          }\n\n          for (const record of stream.records) {\n            if (record.eventId > after) {\n              queue.enqueue(record);\n            }\n          }\n\n          if (stream.status !== \"running\") {\n            queue.close();\n            return queue[Symbol.asyncIterator]();\n          }\n\n          const subscriber: Subscriber<TEvent> = { after, queue };\n          stream.subscribers.add(subscriber);\n          const iterator = queue[Symbol.asyncIterator]();\n\n          return {\n            next: () => iterator.next(),\n            async return() {\n              stream.subscribers.delete(subscriber);\n              queue.close();\n              return { value: undefined, done: true };\n            },\n          };\n        },\n      };\n    },\n\n    async status(input) {\n      return state(streams.get(input.streamId));\n    },\n\n    async close(input) {\n      const stream = streams.get(input.streamId);\n      if (stream === undefined) {\n        return { status: input.status, lastEventId: 0 };\n      }\n      stream.status = input.status;\n      closeSubscribers(stream);\n      return state(stream);\n    },\n  };\n}\n\nasync function drainResumableStream<TEvent>(\n  events: AsyncIterable<TEvent>,\n  options: CreateResumableStreamOptions<TEvent>,\n  openPromise: Promise<void>,\n): Promise<void> {\n  const streamId = options.id;\n  try {\n    await openPromise;\n    for await (const event of events) {\n      await options.store.append({ streamId, event });\n    }\n    await options.store.close({ streamId, status: \"completed\" });\n  } catch (error) {\n    const event = errorEvent(error);\n    try {\n      await options.store.append({ streamId, event });\n    } catch {\n      // The response iterator reports store-open failures; avoid a background rejection.\n    }\n    try {\n      await options.store.close({ streamId, status: \"error\" });\n    } catch {\n      // The store may not have opened.\n    }\n  }\n}\n\nfunction recordToEnvelope<TEvent>(\n  record: ResumableStreamRecord<TEvent>,\n): ResumableStreamEnvelope<TEvent> {\n  return {\n    type: \"stream_event\",\n    streamId: record.streamId,\n    eventId: record.eventId,\n    event: record.event,\n  };\n}\n\nfunction stateToEndEnvelope<TEvent>(\n  streamId: string,\n  state: ResumableStreamState,\n): ResumableStreamEnvelope<TEvent> {\n  return {\n    type: \"stream_end\",\n    streamId,\n    eventId: state.lastEventId,\n    status: state.status,\n  };\n}\n\nfunction closeSubscribers<TEvent>(stream: MemoryStream<TEvent>): void {\n  for (const subscriber of stream.subscribers) {\n    subscriber.queue.close();\n  }\n  stream.subscribers.clear();\n}\n\nfunction createAsyncQueue<T>(): AsyncQueue<T> {\n  const values: T[] = [];\n  const waiters: Array<{\n    resolve: (result: IteratorResult<T>) => void;\n    reject: (error: unknown) => void;\n  }> = [];\n  let closed = false;\n  let error: unknown;\n\n  function flush(): void {\n    while (waiters.length > 0 && values.length > 0) {\n      const waiter = waiters.shift();\n      const value = values.shift() as T;\n      waiter?.resolve({ value, done: false });\n    }\n\n    if (values.length > 0 || waiters.length === 0 || !closed) {\n      return;\n    }\n\n    while (waiters.length > 0) {\n      const waiter = waiters.shift();\n      if (waiter === undefined) {\n        continue;\n      }\n      if (error !== undefined) {\n        waiter.reject(error);\n      } else {\n        waiter.resolve({ value: undefined, done: true });\n      }\n    }\n  }\n\n  return {\n    enqueue(value) {\n      if (closed) {\n        return;\n      }\n      values.push(value);\n      flush();\n    },\n    close() {\n      closed = true;\n      flush();\n    },\n    throw(thrown) {\n      closed = true;\n      error = thrown;\n      flush();\n    },\n    [Symbol.asyncIterator]() {\n      return {\n        next() {\n          if (values.length > 0) {\n            const value = values.shift() as T;\n            return Promise.resolve({ value, done: false });\n          }\n          if (error !== undefined) {\n            return Promise.reject(error);\n          }\n          if (closed) {\n            return Promise.resolve({ value: undefined, done: true });\n          }\n          return new Promise((resolve, reject) => {\n            waiters.push({ resolve, reject });\n          });\n        },\n      };\n    },\n  };\n}\n","import { errorEvent } from \"./errors\";\nimport type { EventStreamErrorEvent, SseStreamOptions } from \"./types\";\n\nexport function createSseStream<TEvent>(\n  options: SseStreamOptions<TEvent> & { events: AsyncIterable<TEvent> },\n): ReadableStream<Uint8Array> {\n  validateSseOptions(options);\n  const encoder = new TextEncoder();\n  const iterator = options.events[Symbol.asyncIterator]();\n  const serialize = options.serialize ?? serializeJson;\n  let cancelled = false;\n\n  return new ReadableStream<Uint8Array>({\n    start(controller) {\n      if (options.retry !== undefined) {\n        controller.enqueue(encoder.encode(`retry: ${options.retry}\\n\\n`));\n      }\n    },\n    async pull(controller) {\n      try {\n        const next = await iterator.next();\n        if (cancelled) return;\n        if (next.done === true) {\n          controller.close();\n          return;\n        }\n\n        controller.enqueue(\n          encoder.encode(formatSseEvent(next.value, serialize, options.eventName, options.eventId)),\n        );\n      } catch (error) {\n        if (cancelled) return;\n        const event = errorEvent(error);\n        controller.enqueue(encoder.encode(formatSseEvent(event, serialize, options.eventName)));\n        controller.close();\n      }\n    },\n    async cancel() {\n      cancelled = true;\n      await options.onCancel?.();\n      await iterator.return?.();\n    },\n  });\n}\n\nfunction formatSseEvent<TEvent>(\n  event: TEvent | EventStreamErrorEvent,\n  serialize: (event: TEvent | EventStreamErrorEvent) => string,\n  eventName: SseStreamOptions<TEvent>[\"eventName\"],\n  eventId?: SseStreamOptions<TEvent>[\"eventId\"],\n): string {\n  const name = typeof eventName === \"function\" ? eventName(event) : eventName;\n  const lines: string[] = [];\n  const id = eventId?.(event);\n  if (id !== undefined) {\n    validateSseEventName(id);\n    lines.push(`id: ${id}`);\n  }\n\n  if (name !== undefined && name.length > 0) {\n    validateSseEventName(name);\n    lines.push(`event: ${name}`);\n  }\n\n  for (const line of serialize(event).split(/\\r?\\n/)) {\n    lines.push(`data: ${line}`);\n  }\n\n  lines.push(\"\", \"\");\n  return lines.join(\"\\n\");\n}\n\nfunction serializeJson(value: unknown): string {\n  return JSON.stringify(value);\n}\n\nfunction validateSseOptions<TEvent>(options: SseStreamOptions<TEvent>): void {\n  if (options.retry !== undefined && !isValidRetry(options.retry)) {\n    throw new TypeError(\"SSE retry must be a finite non-negative integer\");\n  }\n  if (typeof options.eventName === \"string\") {\n    validateSseEventName(options.eventName);\n  }\n}\n\nfunction isValidRetry(value: number): boolean {\n  return Number.isFinite(value) && Number.isInteger(value) && value >= 0;\n}\n\nfunction validateSseEventName(name: string): void {\n  for (const character of name) {\n    const code = character.charCodeAt(0);\n    if (code === 0 || code === 10 || code === 13) {\n      throw new TypeError(\"SSE event names must not contain null bytes or line breaks\");\n    }\n  }\n}\n","import { createJsonlStream } from \"./jsonl\";\nimport { createResumableStream, resumeStreamEvents } from \"./resumable\";\nimport { createSseStream } from \"./sse\";\nimport type {\n  CreateEventStreamResponseOptions,\n  EventStreamFormat,\n  JsonlStreamOptions,\n  ResumableStreamEnvelope,\n  ResumeEventStreamResponseOptions,\n  SseStreamOptions,\n} from \"./types\";\n\ntype ResponseStreamEvent<TEvent> = TEvent | ResumableStreamEnvelope<TEvent>;\n\ntype EventStreamResponseOptions<TEvent> = {\n  format?: EventStreamFormat;\n  headers?: HeadersInit;\n  status?: number;\n  statusText?: string;\n  jsonl?: JsonlStreamOptions<ResponseStreamEvent<TEvent>>;\n  sse?: SseStreamOptions<ResponseStreamEvent<TEvent>>;\n};\n\nexport function createEventStreamResponse<TEvent>(\n  options: CreateEventStreamResponseOptions<TEvent> & { events: AsyncIterable<TEvent> },\n): Response {\n  const eventsForResponse: AsyncIterable<ResponseStreamEvent<TEvent>> =\n    options.resumable === undefined\n      ? (options.events as AsyncIterable<ResponseStreamEvent<TEvent>>)\n      : createResumableStream({ events: options.events, ...options.resumable });\n\n  return encodeEventStreamResponse({\n    events: eventsForResponse,\n    ...copyResponseOptions(options),\n  });\n}\n\nexport function resumeEventStreamResponse<TEvent>(\n  options: ResumeEventStreamResponseOptions<TEvent>,\n): Response {\n  return encodeEventStreamResponse({\n    events: resumeStreamEvents({\n      id: options.streamId,\n      after: options.after,\n      store: options.store,\n    }),\n    ...copyResponseOptions(options),\n  });\n}\n\nexport function encodeEventStreamResponse<TEvent>(\n  options: EventStreamResponseOptions<TEvent> & {\n    events: AsyncIterable<ResponseStreamEvent<TEvent>>;\n  },\n): Response {\n  const format = options.format ?? \"jsonl\";\n  const headers = new Headers(options.headers);\n\n  if (!headers.has(\"cache-control\")) {\n    headers.set(\"cache-control\", \"no-cache, no-transform\");\n  }\n  if (!headers.has(\"connection\")) {\n    headers.set(\"connection\", \"keep-alive\");\n  }\n  if (!headers.has(\"x-accel-buffering\")) {\n    headers.set(\"x-accel-buffering\", \"no\");\n  }\n\n  const body =\n    format === \"sse\"\n      ? createSseStream({ events: options.events, ...options.sse })\n      : createJsonlStream({ events: options.events, ...options.jsonl });\n\n  if (!headers.has(\"content-type\")) {\n    headers.set(\n      \"content-type\",\n      format === \"sse\" ? \"text/event-stream; charset=utf-8\" : \"application/x-ndjson; charset=utf-8\",\n    );\n  }\n\n  const responseInit: ResponseInit = { headers };\n  if (options.status !== undefined) {\n    responseInit.status = options.status;\n  }\n  if (options.statusText !== undefined) {\n    responseInit.statusText = options.statusText;\n  }\n\n  return new Response(body, responseInit);\n}\n\nfunction copyResponseOptions<TEvent>(options: {\n  format?: EventStreamFormat;\n  headers?: HeadersInit;\n  status?: number;\n  statusText?: string;\n  jsonl?: unknown;\n  sse?: unknown;\n}): EventStreamResponseOptions<TEvent> {\n  const next: EventStreamResponseOptions<TEvent> = {};\n  if (options.format !== undefined) next.format = options.format;\n  if (options.headers !== undefined) next.headers = options.headers;\n  if (options.status !== undefined) next.status = options.status;\n  if (options.statusText !== undefined) next.statusText = options.statusText;\n  if (options.jsonl !== undefined) {\n    next.jsonl = options.jsonl as JsonlStreamOptions<ResponseStreamEvent<TEvent>>;\n  }\n  if (options.sse !== undefined) {\n    next.sse = options.sse as SseStreamOptions<ResponseStreamEvent<TEvent>>;\n  }\n  return next;\n}\n"],"mappings":"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","names":["serializeJson"]}

package/dist/durable.d.ts

@@ -0,0 +1,24 @@
+import { DurableRuntime } from '@anvia/durable';
+
+type DurableHttpAction = "list" | "submit" | "inspect" | "events" | "respond" | "resolve-tool" | "retry" | "cancel" | "signal" | "resolve-effect";
+type DurableAuthorization = {
+    action: DurableHttpAction;
+    sessionId: string;
+    runId?: string;
+    agentId?: string;
+    graphId?: string;
+    taskId?: string;
+    rootTaskId?: string;
+    taskName?: string;
+};
+type DurableHandlerOptions = {
+    runtime: DurableRuntime;
+    /** Authenticate and authorize every operation, including reads. Deny by returning false. */
+    authorize: (request: Request, resource: DurableAuthorization) => boolean | Promise<boolean>;
+    basePath?: string;
+    maxBodyBytes?: number;
+};
+/** Fetch-compatible routes. The application owns runtime startup, shutdown, and authentication. */
+declare function createDurableHandler(options: DurableHandlerOptions): (request: Request) => Promise<Response>;
+
+export { type DurableAuthorization, type DurableHandlerOptions, type DurableHttpAction, createDurableHandler };