@anvia/client 1.6.0 → 1.8.0

package/dist/event-transport-CcP1zaST.js

@@ -0,0 +1,103 @@
+import { i as readSseStream, n as readJsonlStream } from "./streams-BXxF27Hp.js";
+// src/transport/fetch.ts
+var EventStreamHttpError = class extends Error {
+	response;
+	body;
+	constructor(response, body) {
+		super(`Event stream request failed with status ${response.status}`);
+		this.response = response;
+		this.body = body;
+		this.name = "EventStreamHttpError";
+	}
+};
+async function* fetchEventStream(options) {
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	if (fetchImpl === void 0) throw new Error("fetchEventStream requires a fetch implementation.");
+	const response = await fetchImpl(options.input, fetchOptions(options));
+	if (!response.ok) throw new EventStreamHttpError(response, await response.text());
+	options.validateResponse?.(response);
+	if (response.body === null) throw new Error("Event stream response does not include a body.");
+	const format = options.format === void 0 || options.format === "auto" ? inferEventStreamFormat(response.headers.get("content-type")) : options.format;
+	const readOptions = {};
+	if (options.onParseError !== void 0) readOptions.onParseError = options.onParseError;
+	if (format === "sse") yield* readSseStream(response.body, readOptions);
+	else yield* readJsonlStream(response.body, readOptions);
+}
+function fetchOptions(options) {
+	const { input: _input, format: _format, fetch: _fetch, validateResponse: _validate, onParseError: _onParseError, ...init } = options;
+	return init;
+}
+function inferEventStreamFormat(contentType) {
+	return contentType?.toLowerCase().includes("text/event-stream") ? "sse" : "jsonl";
+}
+// src/transport/event-transport.ts
+function createFetchEventTransport(options) {
+	return { async *send(transportOptions) {
+		const endpoint = typeof options.endpoint === "function" ? options.endpoint(transportOptions) : options.endpoint;
+		const headers = mergeHeaders(await resolveHeaders(options.headers, transportOptions), transportOptions.headers);
+		const method = options.method ?? "POST";
+		const body = await resolveBody(options.body, transportOptions, headers, method);
+		const init = {
+			...options.init,
+			input: endpoint,
+			method,
+			headers,
+			format: options.format ?? "auto"
+		};
+		if (body !== void 0) init.body = body;
+		if (transportOptions.abortSignal !== void 0) init.signal = transportOptions.abortSignal;
+		if (options.fetch !== void 0) init.fetch = options.fetch;
+		if (options.validateResponse !== void 0) init.validateResponse = options.validateResponse;
+		if (options.onParseError !== void 0) init.onParseError = options.onParseError;
+		for await (const event of fetchEventStream(init)) yield options.mapEvent === void 0 ? event : options.mapEvent(event);
+	} };
+}
+function createDirectEventTransport(options) {
+	return { async *send(context) {
+		const iterator = options.handler(context)[Symbol.asyncIterator]();
+		let closePromise;
+		const close = () => {
+			closePromise ??= Promise.resolve(iterator.return?.());
+			return closePromise;
+		};
+		const onAbort = () => {
+			close();
+		};
+		context.abortSignal?.addEventListener("abort", onAbort, { once: true });
+		try {
+			while (!context.abortSignal?.aborted) {
+				const next = await iterator.next();
+				if (next.done) break;
+				yield next.value;
+			}
+		} finally {
+			context.abortSignal?.removeEventListener("abort", onAbort);
+			await close();
+		}
+	} };
+}
+async function resolveHeaders(headers, context) {
+	return typeof headers === "function" ? headers(context) : headers;
+}
+async function resolveBody(body, context, headers, method) {
+	if (body !== void 0) return body({
+		...context,
+		headers
+	});
+	if (method.toUpperCase() === "GET" || method.toUpperCase() === "HEAD") return void 0;
+	if (!headers.has("content-type")) headers.set("content-type", "application/json");
+	return JSON.stringify(context.request);
+}
+function mergeHeaders(...values) {
+	const headers = new Headers();
+	for (const value of values) {
+		if (value === void 0) continue;
+		new Headers(value).forEach((headerValue, key) => {
+			headers.set(key, headerValue);
+		});
+	}
+	return headers;
+}
+export { fetchEventStream as i, createFetchEventTransport as n, EventStreamHttpError as r, createDirectEventTransport as t };
+
+//# sourceMappingURL=event-transport-CcP1zaST.js.map

package/dist/event-transport-CcP1zaST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-transport-CcP1zaST.js","names":[],"sources":["../src/transport/fetch.ts","../src/transport/event-transport.ts"],"sourcesContent":["import { type EventStreamReadOptions, readJsonlStream, readSseStream } from \"./streams\";\nimport type { EventStreamFormat } from \"./types\";\n\nexport type FetchEventStreamOptions = Omit<RequestInit, \"headers\"> & {\n  input: string | URL | Request;\n  format?: EventStreamFormat | \"auto\";\n  fetch?: typeof fetch;\n  headers?: HeadersInit;\n  validateResponse?: (response: Response) => void;\n  onParseError?: EventStreamReadOptions[\"onParseError\"];\n};\n\nexport class EventStreamHttpError extends Error {\n  constructor(\n    readonly response: Response,\n    readonly body: string,\n  ) {\n    super(`Event stream request failed with status ${response.status}`);\n    this.name = \"EventStreamHttpError\";\n  }\n}\n\nexport async function* fetchEventStream<TEvent>(\n  options: FetchEventStreamOptions,\n): AsyncIterable<TEvent> {\n  const fetchImpl = options.fetch ?? globalThis.fetch;\n  if (fetchImpl === undefined) throw new Error(\"fetchEventStream requires a fetch implementation.\");\n\n  const response = await fetchImpl(options.input, fetchOptions(options));\n  if (!response.ok) throw new EventStreamHttpError(response, await response.text());\n  options.validateResponse?.(response);\n  if (response.body === null) throw new Error(\"Event stream response does not include a body.\");\n\n  const format =\n    options.format === undefined || options.format === \"auto\"\n      ? inferEventStreamFormat(response.headers.get(\"content-type\"))\n      : options.format;\n  const readOptions: EventStreamReadOptions = {};\n  if (options.onParseError !== undefined) readOptions.onParseError = options.onParseError;\n  if (format === \"sse\") {\n    yield* readSseStream<TEvent>(response.body, readOptions);\n  } else {\n    yield* readJsonlStream<TEvent>(response.body, readOptions);\n  }\n}\n\nfunction fetchOptions(options: FetchEventStreamOptions): RequestInit {\n  const {\n    input: _input,\n    format: _format,\n    fetch: _fetch,\n    validateResponse: _validate,\n    onParseError: _onParseError,\n    ...init\n  } = options;\n  return init;\n}\n\nfunction inferEventStreamFormat(contentType: string | null): EventStreamFormat {\n  return contentType?.toLowerCase().includes(\"text/event-stream\") ? \"sse\" : \"jsonl\";\n}\n","import { type FetchEventStreamOptions, fetchEventStream } from \"./fetch\";\nimport type { EventStreamFormat, EventTransport, EventTransportSendOptions } from \"./types\";\n\nexport type EventTransportContext<TRequest> = EventTransportSendOptions<TRequest>;\n\nexport type EventTransportBodyContext<TRequest> = Omit<\n  EventTransportContext<TRequest>,\n  \"headers\"\n> & {\n  headers: Headers;\n};\n\nexport type CreateFetchEventTransportOptions<TRequest, TEvent> = {\n  endpoint: string | URL | ((context: EventTransportContext<TRequest>) => string | URL);\n  method?: string;\n  format?: EventStreamFormat | \"auto\";\n  fetch?: typeof fetch;\n  headers?:\n    | HeadersInit\n    | ((context: EventTransportContext<TRequest>) => HeadersInit | Promise<HeadersInit>);\n  body?: (\n    context: EventTransportBodyContext<TRequest>,\n  ) => BodyInit | null | undefined | Promise<BodyInit | null | undefined>;\n  init?: Omit<RequestInit, \"body\" | \"headers\" | \"method\" | \"signal\">;\n  mapEvent?: (event: unknown) => TEvent;\n  validateResponse?: (response: Response) => void;\n  /** Receives malformed frames that were skipped instead of aborting the stream. */\n  onParseError?: FetchEventStreamOptions[\"onParseError\"];\n};\n\nexport function createFetchEventTransport<TRequest, TEvent = unknown>(\n  options: CreateFetchEventTransportOptions<TRequest, TEvent>,\n): EventTransport<TRequest, TEvent> {\n  return {\n    async *send(transportOptions) {\n      const endpoint =\n        typeof options.endpoint === \"function\"\n          ? options.endpoint(transportOptions)\n          : options.endpoint;\n      const requestHeaders = await resolveHeaders(options.headers, transportOptions);\n      const headers = mergeHeaders(requestHeaders, transportOptions.headers);\n      const method = options.method ?? \"POST\";\n      const body = await resolveBody(options.body, transportOptions, headers, method);\n      const init: FetchEventStreamOptions = {\n        ...options.init,\n        input: endpoint,\n        method,\n        headers,\n        format: options.format ?? \"auto\",\n      };\n      if (body !== undefined) init.body = body;\n      if (transportOptions.abortSignal !== undefined) init.signal = transportOptions.abortSignal;\n      if (options.fetch !== undefined) init.fetch = options.fetch;\n      if (options.validateResponse !== undefined) init.validateResponse = options.validateResponse;\n      if (options.onParseError !== undefined) init.onParseError = options.onParseError;\n\n      for await (const event of fetchEventStream<unknown>(init)) {\n        yield options.mapEvent === undefined ? (event as TEvent) : options.mapEvent(event);\n      }\n    },\n  };\n}\n\nexport function createDirectEventTransport<TRequest, TEvent>(options: {\n  handler(context: EventTransportContext<TRequest>): AsyncIterable<TEvent>;\n}): EventTransport<TRequest, TEvent> {\n  return {\n    async *send(context) {\n      const iterator = options.handler(context)[Symbol.asyncIterator]();\n      let closePromise: Promise<unknown> | undefined;\n      const close = () => {\n        closePromise ??= Promise.resolve(iterator.return?.());\n        return closePromise;\n      };\n      const onAbort = () => {\n        void close();\n      };\n      context.abortSignal?.addEventListener(\"abort\", onAbort, { once: true });\n      try {\n        while (!context.abortSignal?.aborted) {\n          const next = await iterator.next();\n          if (next.done) break;\n          yield next.value;\n        }\n      } finally {\n        context.abortSignal?.removeEventListener(\"abort\", onAbort);\n        await close();\n      }\n    },\n  };\n}\n\nasync function resolveHeaders<TRequest>(\n  headers: CreateFetchEventTransportOptions<TRequest, unknown>[\"headers\"],\n  context: EventTransportContext<TRequest>,\n): Promise<HeadersInit | undefined> {\n  return typeof headers === \"function\" ? headers(context) : headers;\n}\n\nasync function resolveBody<TRequest>(\n  body: CreateFetchEventTransportOptions<TRequest, unknown>[\"body\"],\n  context: EventTransportContext<TRequest>,\n  headers: Headers,\n  method: string,\n): Promise<BodyInit | null | undefined> {\n  if (body !== undefined) return body({ ...context, headers });\n  if (method.toUpperCase() === \"GET\" || method.toUpperCase() === \"HEAD\") return undefined;\n  if (!headers.has(\"content-type\")) headers.set(\"content-type\", \"application/json\");\n  return JSON.stringify(context.request);\n}\n\nfunction mergeHeaders(...values: Array<HeadersInit | undefined>): Headers {\n  const headers = new Headers();\n  for (const value of values) {\n    if (value === undefined) continue;\n    new Headers(value).forEach((headerValue, key) => {\n      headers.set(key, headerValue);\n    });\n  }\n  return headers;\n}\n"],"mappings":"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"}

package/dist/event-transport-rXxwo4BK.d.ts

@@ -0,0 +1,88 @@
+type EventStreamFormat = "jsonl" | "sse";
+type EventTransportSendOptions<TRequest> = {
+  request: TRequest;
+  abortSignal?: AbortSignal;
+  headers?: HeadersInit;
+};
+type EventTransport<TRequest, TEvent> = {
+  send(options: EventTransportSendOptions<TRequest>): AsyncIterable<TEvent>;
+};
+/** A malformed JSONL line or SSE data payload that could not be parsed as JSON. */
+declare class EventStreamParseError extends Error {
+  readonly format: EventStreamFormat;
+  /** The raw JSONL line or joined SSE `data` payload. */
+  readonly raw: string;
+  /** 1-based physical line number of the malformed JSONL line. */
+  readonly line: number | undefined;
+  /** SSE event name of the malformed frame. */
+  readonly event: string | undefined;
+  /** SSE last event ID in effect when the malformed frame was dispatched. */
+  readonly lastEventId: string | undefined;
+  constructor(options: {
+    format: EventStreamFormat;
+    raw: string;
+    cause: unknown;
+    line?: number;
+    event?: string;
+    lastEventId?: string;
+  });
+}
+type EventStreamReadOptions = {
+  /**
+   * Receives frames whose payload is not valid JSON. Malformed frames are skipped and the
+   * stream continues. Throwing from this callback aborts the stream with that error.
+   */
+  onParseError?: (error: EventStreamParseError) => void;
+  /** Throw the parse error instead of skipping malformed frames. */
+  strict?: boolean;
+};
+/** A dispatched Server-Sent Event with its parsed JSON payload. */
+type SseFrame<TEvent> = {
+  data: TEvent;
+  /** Event name from the `event:` field, `"message"` when absent. */
+  event: string;
+  /** Last event ID set by an `id:` field in this or an earlier frame, `""` when none. */
+  lastEventId: string;
+  /** Most recent valid `retry:` reconnection time in milliseconds. */
+  retry?: number;
+};
+declare function readJsonlStream<TEvent>(stream: ReadableStream<Uint8Array>, options?: EventStreamReadOptions): AsyncIterable<TEvent>;
+declare function readSseStream<TEvent>(stream: ReadableStream<Uint8Array>, options?: EventStreamReadOptions): AsyncIterable<TEvent>;
+declare function readSseFrames<TEvent>(stream: ReadableStream<Uint8Array>, options?: EventStreamReadOptions): AsyncIterable<SseFrame<TEvent>>;
+type FetchEventStreamOptions = Omit<RequestInit, "headers"> & {
+  input: string | URL | Request;
+  format?: EventStreamFormat | "auto";
+  fetch?: typeof fetch;
+  headers?: HeadersInit;
+  validateResponse?: (response: Response) => void;
+  onParseError?: EventStreamReadOptions["onParseError"];
+};
+declare class EventStreamHttpError extends Error {
+  readonly response: Response;
+  readonly body: string;
+  constructor(response: Response, body: string);
+}
+declare function fetchEventStream<TEvent>(options: FetchEventStreamOptions): AsyncIterable<TEvent>;
+type EventTransportContext<TRequest> = EventTransportSendOptions<TRequest>;
+type EventTransportBodyContext<TRequest> = Omit<EventTransportContext<TRequest>, "headers"> & {
+  headers: Headers;
+};
+type CreateFetchEventTransportOptions<TRequest, TEvent> = {
+  endpoint: string | URL | ((context: EventTransportContext<TRequest>) => string | URL);
+  method?: string;
+  format?: EventStreamFormat | "auto";
+  fetch?: typeof fetch;
+  headers?: HeadersInit | ((context: EventTransportContext<TRequest>) => HeadersInit | Promise<HeadersInit>);
+  body?: (context: EventTransportBodyContext<TRequest>) => BodyInit | null | undefined | Promise<BodyInit | null | undefined>;
+  init?: Omit<RequestInit, "body" | "headers" | "method" | "signal">;
+  mapEvent?: (event: unknown) => TEvent;
+  validateResponse?: (response: Response) => void;
+  /** Receives malformed frames that were skipped instead of aborting the stream. */
+  onParseError?: FetchEventStreamOptions["onParseError"];
+};
+declare function createFetchEventTransport<TRequest, TEvent = unknown>(options: CreateFetchEventTransportOptions<TRequest, TEvent>): EventTransport<TRequest, TEvent>;
+declare function createDirectEventTransport<TRequest, TEvent>(options: {
+  handler(context: EventTransportContext<TRequest>): AsyncIterable<TEvent>;
+}): EventTransport<TRequest, TEvent>;
+export { FetchEventStreamOptions as a, EventStreamReadOptions as c, readSseFrames as d, readSseStream as f, EventTransportSendOptions as h, EventStreamHttpError as i, SseFrame as l, EventTransport as m, createDirectEventTransport as n, fetchEventStream as o, EventStreamFormat as p, createFetchEventTransport as r, EventStreamParseError as s, CreateFetchEventTransportOptions as t, readJsonlStream as u };
+//# sourceMappingURL=event-transport-rXxwo4BK.d.ts.map

package/dist/event-transport-rXxwo4BK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-transport-rXxwo4BK.d.ts","names":[],"sources":["../src/transport/types.ts","../src/transport/streams.ts","../src/transport/fetch.ts","../src/transport/event-transport.ts"],"mappings":"A,KAAY;KAEA,0BAA0B;EACpC,SAAS;EACT,cAAc;EACd,UAAU;;KAGA,eAAe,UAAU;EACnC,KAAK,SAAS,0BAA0B,YAAY,cAAc;;;cCNvD,8BAA8B;WAChC,QAAQ;;WAER;;WAEA;;WAEA;;WAEA;EAEG,YAAA;IACV,QAAQ;IACR;IACA;IACA;IACA;IACA;;;KAcQ;;;;;EAKV,gBAAgB,OAAO;;EAEvB;;;KAIU,SAAS;EACnB,MAAM;;EAEN;;EAEA;;EAEA;;iBAGqB,gBAAgB,QACrC,QAAQ,eAAe,aACvB,UAAS,yBACR,cAAc;iBAWM,cAAc,QACnC,QAAQ,eAAe,aACvB,UAAS,yBACR,cAAc;iBAIM,cAAc,QACnC,QAAQ,eAAe,aACvB,UAAS,yBACR,cAAc,SAAS;KC5Ed,0BAA0B,KAAK;EACzC,gBAAgB,MAAM;EACtB,SAAS;EACT,eAAe;EACf,UAAU;EACV,oBAAoB,UAAU;EAC9B,eAAe;;cAGJ,6BAA6B;WAE7B,UAAU;WACV;EADA,YAAA,UAAU,UACV;;iBAOU,iBAAiB,QACtC,SAAS,0BACR,cAAc;KCrBL,sBAAsB,YAAY,0BAA0B;KAE5D,0BAA0B,YAAY,KAChD,sBAAsB;EAGtB,SAAS;;KAGC,iCAAiC,UAAU;EACrD,mBAAmB,QAAQ,SAAS,sBAAsB,uBAAuB;EACjF;EACA,SAAS;EACT,eAAe;EACf,UACI,gBACE,SAAS,sBAAsB,cAAc,cAAc,QAAQ;EACzE,QACE,SAAS,0BAA0B,cAChC,8BAA8B,QAAQ;EAC3C,OAAO,KAAK;EACZ,YAAY,mBAAmB;EAC/B,oBAAoB,UAAU;;EAE9B,eAAe;;iBAGD,0BAA0B,UAAU,kBAClD,SAAS,iCAAiC,UAAU,UACnD,eAAe,UAAU;iBA+BZ,2BAA2B,UAAU,QAAQ;EAC3D,QAAQ,SAAS,sBAAsB,YAAY,cAAc;IAC/D,eAAe,UAAU"}