@kaito-http/core 4.0.0-beta.3 → 4.0.0-beta.31

package/dist/schema/schema.d.ts

@@ -0,0 +1,391 @@
+import { SchemaObject, ReferenceObject } from 'openapi3-ts/oas31';
+
+type JSONPrimitive = string | number | boolean | null;
+type JSONValue = JSONPrimitive | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+declare function isPrimitiveJSONValue(value: unknown): value is JSONPrimitive;
+interface BaseSchemaDef<Input extends JSONValue> {
+    example?: Input | undefined;
+    description?: string | undefined;
+}
+interface Issue {
+    message: string;
+    path: string[];
+}
+type ParseResult<T> = {
+    success: true;
+    result: T;
+} | {
+    success: false;
+    issues: Set<Issue>;
+};
+declare class SchemaError extends Error {
+    readonly issues: Set<Issue>;
+    constructor(issues: Set<Issue>);
+}
+declare class ParseContext {
+    #private;
+    private static readonly ISSUE;
+    readonly ISSUE: typeof ParseContext.ISSUE;
+    addIssue(message: string, path: string[]): typeof ParseContext.ISSUE;
+    addIssues(issues: Iterable<Issue>, path: string[]): typeof ParseContext.ISSUE;
+    get issues(): Set<Issue>;
+    static result<T>(fn: (ctx: ParseContext) => T | typeof ParseContext.ISSUE): ParseResult<T>;
+    static with<T>(fn: (ctx: ParseContext) => T | typeof ParseContext.ISSUE): {
+        type: "FATAL";
+        issues: Set<Issue>;
+        data?: never;
+    } | {
+        type: "PARSED";
+        issues: Set<Issue>;
+        data: T;
+    };
+}
+type AnySchemaFor<T extends JSONValue> = BaseSchema<T, T, BaseSchemaDef<T>>;
+declare abstract class BaseSchema<Input extends JSONValue, Output, Def extends BaseSchemaDef<Input>> {
+    /** @internal */
+    readonly _input: Input;
+    /** @internal */
+    readonly _output: Output;
+    abstract parse(json: unknown): Output;
+    abstract parseSafe(json: unknown): ParseResult<Output>;
+    abstract serialize(value: Output): Input;
+    protected readonly def: Def;
+    abstract toOpenAPI(): SchemaObject | ReferenceObject;
+    protected getSchemaObject(): {
+        description?: string;
+        example?: Input;
+    };
+    protected clone(def: Partial<Def>): this;
+    protected constructor(def: Def);
+    or<OtherInput extends JSONValue, OtherOutput, Def extends BaseSchemaDef<OtherInput>>(other: BaseSchema<OtherInput, OtherOutput, Def>): KUnion<(this | BaseSchema<OtherInput, OtherOutput, Def>)["_input"], (this | BaseSchema<OtherInput, OtherOutput, Def>)["_output"]>;
+    example(example: Input): this;
+    example(): Input | undefined;
+    description(description: string): this;
+    description(): string | undefined;
+    /**
+     * Traverse immediate children schemas.
+     */
+    abstract visit(visitor: (schema: BaseSchema<any, any, any>) => void): void;
+}
+type Check<T extends string, P extends {} = {}> = {
+    type: T;
+    message?: string | undefined;
+} & Omit<P, 'message'>;
+type StringFormat = 'date' | 'date-time' | 'password' | 'byte' | 'binary' | 'email' | 'uuid' | 'uri' | 'hostname' | 'ipv4' | 'ipv6';
+declare const STRING_FORMAT_REGEXES: {
+    readonly uuid: RegExp;
+    readonly email: RegExp;
+    readonly ipv4: RegExp;
+    readonly ipv6: RegExp;
+    readonly date: RegExp;
+    readonly uri: RegExp;
+    readonly hostname: RegExp;
+};
+interface StringChecks {
+    min?: Check<'min', {
+        val: number;
+    }>;
+    max?: Check<'max', {
+        val: number;
+    }>;
+    regex?: Check<'regex', {
+        regex: RegExp;
+    }>;
+    format?: Check<'format', {
+        format: StringFormat;
+    }>;
+    startsWith?: Check<'startsWith', {
+        prefix: string;
+    }>;
+    endsWith?: Check<'endsWith', {
+        suffix: string;
+    }>;
+}
+interface StringDef extends BaseSchemaDef<string>, StringChecks {
+}
+declare class KString extends BaseSchema<string, string, StringDef> {
+    static create: () => KString;
+    serialize(value: string): string;
+    private setCheck;
+    toOpenAPI(): SchemaObject | ReferenceObject;
+    /**
+     * Sets the minimum length of the string
+     *
+     * @param min The minimum length of the string
+     * @returns A clone of the schema with the minimum length set
+     */
+    min(min: number, message?: string): this;
+    /**
+     * Sets the maximum length of the string
+     *
+     * @param max The maximum length of the string
+     * @returns A clone of the schema with the maximum length set
+     */
+    max(max: number, message?: string): this;
+    regex(regex: RegExp, message?: string): this;
+    startsWith(prefix: string, message?: string): this;
+    endsWith(suffix: string, message?: string): this;
+    private format;
+    uri(message?: string): this;
+    /**
+     * Deprecated because OpenAPI uses the term "uri"
+     * but this method exists for making migration from
+     * Zod easier.
+     *
+     * @deprecated Use {@link uri} instead
+     */
+    url(message?: string): this;
+    email(message?: string): this;
+    uuid(message?: string): this;
+    ipv4(message?: string): this;
+    ipv6(message?: string): this;
+    date(message?: string): this;
+    dateTime(message?: string): this;
+    password(message?: string): this;
+    byte(message?: string): this;
+    binary(message?: string): this;
+    hostname(message?: string): this;
+    parseSafe(json: unknown): ParseResult<string>;
+    parse(json: unknown): string;
+    visit(): void;
+}
+type NumberFormat = 'float' | 'double' | 'int32' | 'int64';
+interface NumberChecks {
+    min?: Check<'min', {
+        val: number;
+    }>;
+    max?: Check<'max', {
+        val: number;
+    }>;
+    integer?: Check<'integer'>;
+    multipleOf?: Check<'multipleOf', {
+        val: number;
+    }>;
+    format?: Check<'format', {
+        format: NumberFormat;
+    }>;
+}
+interface NumberDef extends BaseSchemaDef<number>, NumberChecks {
+}
+declare class KNumber extends BaseSchema<number, number, NumberDef> {
+    static create: () => KNumber;
+    serialize(value: number): number;
+    private setCheck;
+    toOpenAPI(): SchemaObject | ReferenceObject;
+    min(min: number): this;
+    max(max: number): this;
+    integer(): this;
+    multipleOf(multipleOf: number): this;
+    float(): this;
+    double(): this;
+    int32(): this;
+    int64(): this;
+    parseSafe(json: unknown): ParseResult<number>;
+    parse(json: unknown): number;
+    visit(): void;
+}
+interface BooleanDef extends BaseSchemaDef<boolean> {
+}
+declare class KBoolean extends BaseSchema<boolean, boolean, BooleanDef> {
+    static create: () => KBoolean;
+    serialize(value: boolean): boolean;
+    toOpenAPI(): SchemaObject | ReferenceObject;
+    parseSafe(json: unknown): ParseResult<boolean>;
+    parse(json: unknown): boolean;
+    visit(): void;
+}
+interface ArrayChecks {
+    minItems?: Check<'minItems', {
+        val: number;
+    }>;
+    maxItems?: Check<'maxItems', {
+        val: number;
+    }>;
+    uniqueItems?: Check<'uniqueItems', {
+        val: boolean;
+    }>;
+}
+interface ArrayDef<Input extends JSONValue, Output> extends BaseSchemaDef<Input[]>, ArrayChecks {
+    items: BaseSchema<Input, Output, BaseSchemaDef<Input>>;
+}
+declare class KArray<Input extends JSONValue, Output> extends BaseSchema<Input[], Output[], ArrayDef<Input, Output>> {
+    static create: <ItemsInput extends JSONValue, ItemsOutput, Def extends BaseSchemaDef<ItemsInput>>(items: BaseSchema<ItemsInput, ItemsOutput, Def>) => KArray<ItemsInput, ItemsOutput>;
+    serialize(value: Output[]): Input[];
+    private setCheck;
+    toOpenAPI(): SchemaObject | ReferenceObject;
+    min(minItems: number): this;
+    max(maxItems: number): this;
+    unique(): this;
+    notUnique(): this;
+    parseSafe(json: unknown): ParseResult<Output[]>;
+    parse(json: unknown): Output[];
+    visit(visitor: (schema: BaseSchema<any, any, any>) => void): void;
+}
+interface NullDef extends BaseSchemaDef<null> {
+}
+declare class KNull extends BaseSchema<null, null, NullDef> {
+    static create: () => KNull;
+    serialize(value: null): null;
+    toOpenAPI(): SchemaObject | ReferenceObject;
+    parseSafe(json: unknown): ParseResult<null>;
+    parse(json: unknown): null;
+    visit(): void;
+}
+interface ObjectDef<Input extends Record<keyof Output, JSONValue>, Output extends Record<keyof Input, JSONValue>> extends BaseSchemaDef<Input> {
+    shape: {
+        [K in keyof Input]: BaseSchema<Input[K], Output[K], BaseSchemaDef<Input[K]>>;
+    };
+}
+declare class KObject<Input extends Record<keyof Output, JSONValue>, Output extends Record<keyof Input, any>> extends BaseSchema<Input, Output, ObjectDef<Input, Output>> {
+    static create: <Input_1 extends Record<keyof Output_1, any>, Output_1 extends Record<keyof Input_1, any>>(shape: { [K in keyof Input_1 | keyof Output_1]: BaseSchema<Input_1[K], Output_1[K], BaseSchemaDef<Input_1[K]>>; }) => KObject<Input_1, Output_1>;
+    serialize(value: Output): Input;
+    toOpenAPI(): SchemaObject;
+    parseSafe(json: unknown): ParseResult<Output>;
+    parse(json: unknown): Output;
+    get shape(): { [K in keyof Input]: BaseSchema<Input[K], Output[K], BaseSchemaDef<Input[K]>>; };
+    visit(visitor: (schema: BaseSchema<any, any, any>) => void): void;
+}
+declare class KObjectFromURLSearchParams<Input extends Record<keyof Output, JSONValue>, Output extends Record<keyof Input, JSONValue>> extends KObject<Input, Output> {
+    static create: <Input_1 extends Record<keyof Output_1, JSONValue>, Output_1 extends Record<keyof Input_1, JSONValue>>(shape: { [K in keyof Input_1 | keyof Output_1]: BaseSchema<Input_1[K], Output_1[K], BaseSchemaDef<Input_1[K]>>; }) => KObjectFromURLSearchParams<Input_1, Output_1>;
+    serialize(value: Output): Input;
+    toOpenAPI(): SchemaObject;
+    parseSafe(json: unknown): ParseResult<Output>;
+}
+interface RefDef<Input extends Record<keyof Output, JSONValue>, Output extends Record<keyof Input, JSONValue>> extends ObjectDef<Input, Output> {
+    name: string;
+    summary?: string | undefined;
+}
+declare class KRef<Input extends Record<keyof Output, JSONValue>, Output extends Record<keyof Input, any>> extends BaseSchema<Input, Output, RefDef<Input, Output>> {
+    static create: <Input_1 extends Record<keyof Output_1, JSONValue>, Output_1 extends Record<keyof Input_1, any>>(name: string, shape: { [K in keyof Input_1 | keyof Output_1]: BaseSchema<Input_1[K], Output_1[K], BaseSchemaDef<Input_1[K]>>; }) => KRef<Input_1, Output_1>;
+    serialize(value: Output): Input;
+    visit(visitor: (schema: BaseSchema<any, any, any>) => void): void;
+    example(): never;
+    toOpenAPI(): ReferenceObject;
+    parseSafe(json: unknown): ParseResult<Output>;
+    parse(json: unknown): Output;
+    summary(): string | undefined;
+    summary(summary: string): this;
+    get shape(): { [K in keyof Input]: BaseSchema<Input[K], Output[K], BaseSchemaDef<Input[K]>>; };
+    get name(): string;
+}
+interface ScalarOptions<ClientRepresentation extends JSONValue, ServerRepresentation> {
+    /**
+     * Parse the value from the unsafe JSON
+     */
+    schema: BaseSchema<ClientRepresentation, ClientRepresentation, BaseSchemaDef<ClientRepresentation>>;
+    /**
+     * Turn the parsed JSON value into something the server can use
+     * @param jsonValue The parsed JSON value
+     * @returns The server representation
+     */
+    toServer: (jsonValue: ClientRepresentation) => ServerRepresentation;
+    /**
+     * Turn the server respresentation back into a JSON value
+     * @param serverValue The value from the server we want to convert back into the client
+     * @returns Convert the data back into a JSON value that the server can understand
+     */
+    toClient: (serverValue: ServerRepresentation) => ClientRepresentation;
+}
+interface ScalarDef<ClientRepresentation extends JSONPrimitive, ServerRepresentation> extends BaseSchemaDef<ClientRepresentation>, ScalarOptions<ClientRepresentation, ServerRepresentation> {
+}
+declare class KScalar<ClientRepresentation extends JSONPrimitive, ServerRepresentation> extends BaseSchema<ClientRepresentation, ServerRepresentation, ScalarDef<ClientRepresentation, ServerRepresentation>> {
+    static create: <ClientRepresentation_1 extends JSONPrimitive, ServerRepresentation_1>(options: ScalarOptions<ClientRepresentation_1, ServerRepresentation_1>) => KScalar<ClientRepresentation_1, ServerRepresentation_1>;
+    constructor(def: ScalarDef<ClientRepresentation, ServerRepresentation>);
+    serialize(value: ServerRepresentation): ClientRepresentation;
+    toOpenAPI(): SchemaObject | ReferenceObject;
+    parseSafe(json: unknown): ParseResult<ServerRepresentation>;
+    parse(json: unknown): ServerRepresentation;
+    visit(visitor: (schema: BaseSchema<any, any, any>) => void): void;
+}
+interface UnionDef<Input extends JSONValue, Output> extends BaseSchemaDef<Input> {
+    items: [
+        a: BaseSchema<Input, Output, BaseSchemaDef<Input>>,
+        b: BaseSchema<Input, Output, BaseSchemaDef<Input>>,
+        ...remaining: BaseSchema<Input, Output, BaseSchemaDef<Input>>[]
+    ];
+}
+declare class KUnion<Input extends JSONValue, Output> extends BaseSchema<Input, Output, UnionDef<Input, Output>> {
+    static create: <Items extends [a: BaseSchema<JSONValue, unknown, BaseSchemaDef<JSONValue>>, b: BaseSchema<JSONValue, unknown, BaseSchemaDef<JSONValue>>, ...remaining: BaseSchema<JSONValue, unknown, BaseSchemaDef<JSONValue>>[]]>(items: Items) => KUnion<Items[number]["_input"], Items[number]["_output"]>;
+    static enum: <const T extends readonly [string, ...string[]]>(values: T) => KUnion<T[number], T[number]>;
+    serialize(value: Output): Input;
+    toOpenAPI(): SchemaObject | ReferenceObject;
+    parseSafe(json: unknown): ParseResult<Output>;
+    parse(json: unknown): Output;
+    visit(visitor: (schema: BaseSchema<any, any, any>) => void): void;
+}
+interface LiteralDef<Value extends string | number | boolean> extends BaseSchemaDef<Value> {
+    value: Value;
+}
+declare class KLiteral<Value extends string | number | boolean> extends BaseSchema<Value, Value, LiteralDef<Value>> {
+    parse(json: unknown): Value;
+    static create: <Value_1 extends string | number | boolean>(value: Value_1) => KLiteral<Value_1>;
+    serialize(value: Value): Value;
+    toOpenAPI(): SchemaObject;
+    parseSafe(json: unknown): ParseResult<Value>;
+    visit(): void;
+}
+interface NativeEnumDef<T extends Record<string, string | number>> extends BaseSchemaDef<T[keyof T]> {
+    enum: T;
+}
+declare class KNativeEnum<T extends Record<string, string | number>> extends BaseSchema<T[keyof T], T[keyof T], NativeEnumDef<T>> {
+    static create: <T_1 extends Record<string, string | number>>(enumObject: T_1) => KNativeEnum<T_1>;
+    serialize(value: T[keyof T]): T[keyof T];
+    toOpenAPI(): SchemaObject;
+    parseSafe(json: unknown): ParseResult<T[keyof T]>;
+    parse(json: unknown): T[keyof T];
+    visit(): void;
+}
+interface RecordDef<KeyInput extends string, KeyOutput extends string, ValueInput extends JSONValue, ValueOutput> extends BaseSchemaDef<Record<KeyInput, ValueInput>> {
+    keys: BaseSchema<KeyInput, KeyOutput, BaseSchemaDef<KeyInput>>;
+    values: BaseSchema<ValueInput, ValueOutput, BaseSchemaDef<ValueInput>>;
+}
+declare class KRecord<KeyInput extends string, KeyOutput extends string, ValueInput extends JSONValue, ValueOutput> extends BaseSchema<Record<KeyInput, ValueInput>, Record<KeyOutput, ValueOutput>, RecordDef<KeyInput, KeyOutput, ValueInput, ValueOutput>> {
+    static create: <KeyInput_1 extends string, KeyOutput_1 extends string, ValueInput_1 extends JSONValue, ValueOutput_1>(keys: BaseSchema<KeyInput_1, KeyOutput_1, BaseSchemaDef<KeyInput_1>>, values: BaseSchema<ValueInput_1, ValueOutput_1, BaseSchemaDef<ValueInput_1>>) => KRecord<KeyInput_1, KeyOutput_1, ValueInput_1, ValueOutput_1>;
+    serialize(value: Record<KeyOutput, ValueOutput>): Record<KeyInput, ValueInput>;
+    toOpenAPI(): SchemaObject;
+    parseSafe(json: unknown): ParseResult<Record<KeyOutput, ValueOutput>>;
+    parse(json: unknown): Record<KeyOutput, ValueOutput>;
+    visit(visitor: (schema: BaseSchema<any, any, any>) => void): void;
+}
+interface LazyDef<Input extends JSONValue, Output> extends BaseSchemaDef<Input> {
+    getter: () => BaseSchema<Input, Output, BaseSchemaDef<Input>>;
+}
+declare class KLazy<Input extends JSONValue, Output> extends BaseSchema<Input, Output, LazyDef<Input, Output>> {
+    private schema?;
+    static create: <Input_1 extends JSONValue, Output_1>(getter: () => BaseSchema<Input_1, Output_1, BaseSchemaDef<Input_1>>) => KLazy<Input_1, Output_1>;
+    private getSchema;
+    serialize(value: Output): Input;
+    toOpenAPI(): SchemaObject | ReferenceObject;
+    parseSafe(json: unknown): ParseResult<Output>;
+    parse(json: unknown): Output;
+    visit(visitor: (schema: BaseSchema<any, any, any>) => void): void;
+}
+declare const k: {
+    string: () => KString;
+    number: () => KNumber;
+    boolean: () => KBoolean;
+    array: <ItemsInput extends JSONValue, ItemsOutput, Def extends BaseSchemaDef<ItemsInput>>(items: BaseSchema<ItemsInput, ItemsOutput, Def>) => KArray<ItemsInput, ItemsOutput>;
+    null: () => KNull;
+    ref: <Input extends Record<keyof Output, JSONValue>, Output extends Record<keyof Input, any>>(name: string, shape: { [K in keyof Input | keyof Output]: BaseSchema<Input[K], Output[K], BaseSchemaDef<Input[K]>>; }) => KRef<Input, Output>;
+    record: <KeyInput extends string, KeyOutput extends string, ValueInput extends JSONValue, ValueOutput>(keys: BaseSchema<KeyInput, KeyOutput, BaseSchemaDef<KeyInput>>, values: BaseSchema<ValueInput, ValueOutput, BaseSchemaDef<ValueInput>>) => KRecord<KeyInput, KeyOutput, ValueInput, ValueOutput>;
+    object: <Input extends Record<keyof Output, any>, Output extends Record<keyof Input, any>>(shape: { [K in keyof Input | keyof Output]: BaseSchema<Input[K], Output[K], BaseSchemaDef<Input[K]>>; }) => KObject<Input, Output>;
+    scalar: <ClientRepresentation extends JSONPrimitive, ServerRepresentation>(options: ScalarOptions<ClientRepresentation, ServerRepresentation>) => KScalar<ClientRepresentation, ServerRepresentation>;
+    literal: <Value extends string | number | boolean>(value: Value) => KLiteral<Value>;
+    enum: <const T extends readonly [string, ...string[]]>(values: T) => KUnion<T[number], T[number]>;
+    nativeEnum: <T extends Record<string, string | number>>(enumObject: T) => KNativeEnum<T>;
+    union: <Items extends [a: BaseSchema<JSONValue, unknown, BaseSchemaDef<JSONValue>>, b: BaseSchema<JSONValue, unknown, BaseSchemaDef<JSONValue>>, ...remaining: BaseSchema<JSONValue, unknown, BaseSchemaDef<JSONValue>>[]]>(items: Items) => KUnion<Items[number]["_input"], Items[number]["_output"]>;
+    lazy: <Input extends JSONValue, Output>(getter: () => BaseSchema<Input, Output, BaseSchemaDef<Input>>) => KLazy<Input, Output>;
+    /**
+     * Schema for any valid JSON value
+     */
+    json: () => BaseSchema<JSONValue, JSONValue, BaseSchemaDef<JSONValue>>;
+    /**
+     * @internal
+     * @experimental
+     */
+    objectFromURLSearchParams: <Input extends Record<keyof Output, JSONValue>, Output extends Record<keyof Input, JSONValue>>(shape: { [K in keyof Input | keyof Output]: BaseSchema<Input[K], Output[K], BaseSchemaDef<Input[K]>>; }) => KObjectFromURLSearchParams<Input, Output>;
+};
+
+export { type AnySchemaFor, type ArrayChecks, type ArrayDef, BaseSchema, type BaseSchemaDef, type BooleanDef, type Issue, type JSONPrimitive, type JSONValue, KArray, KBoolean, KLazy, KLiteral, KNativeEnum, KNull, KNumber, KObject, KObjectFromURLSearchParams, KRecord, KRef, KScalar, KString, KUnion, type LazyDef, type LiteralDef, type NativeEnumDef, type NullDef, type NumberChecks, type NumberDef, type NumberFormat, type ObjectDef, ParseContext, type ParseResult, type RecordDef, type RefDef, STRING_FORMAT_REGEXES, type ScalarDef, type ScalarOptions, SchemaError, type StringChecks, type StringDef, type StringFormat, type UnionDef, isPrimitiveJSONValue, k };

package/dist/schema/schema.js

@@ -0,0 +1,44 @@
+import {
+  BaseSchema,
+  KArray,
+  KBoolean,
+  KLazy,
+  KLiteral,
+  KNativeEnum,
+  KNull,
+  KNumber,
+  KObject,
+  KObjectFromURLSearchParams,
+  KRecord,
+  KRef,
+  KScalar,
+  KString,
+  KUnion,
+  ParseContext,
+  STRING_FORMAT_REGEXES,
+  SchemaError,
+  isPrimitiveJSONValue,
+  k
+} from "../chunk-DRJX3OJG.js";
+export {
+  BaseSchema,
+  KArray,
+  KBoolean,
+  KLazy,
+  KLiteral,
+  KNativeEnum,
+  KNull,
+  KNumber,
+  KObject,
+  KObjectFromURLSearchParams,
+  KRecord,
+  KRef,
+  KScalar,
+  KString,
+  KUnion,
+  ParseContext,
+  STRING_FORMAT_REGEXES,
+  SchemaError,
+  isPrimitiveJSONValue,
+  k
+};

package/dist/stream/stream.cjs

@@ -27,39 +27,27 @@ __export(stream_exports, {
   sseFromAnyReadable: () => sseFromAnyReadable
 });
 module.exports = __toCommonJS(stream_exports);
-var KaitoSSEResponse = class extends Response {
-  constructor(body, init) {
-    const headers = new Headers(init?.headers);
-    headers.set("Content-Type", "text/event-stream");
-    headers.set("Cache-Control", "no-cache");
-    headers.set("Connection", "keep-alive");
-    super(body, {
-      ...init,
-      headers
-    });
-  }
-  get [Symbol.toStringTag]() {
-    return "KaitoSSEResponse";
+var KaitoSSEResponse = class {
+  events;
+  constructor(events) {
+    this.events = events;
   }
 };
 function sseEventToString(event) {
-  let result = "";
+  const lines = [];
   if (event.event) {
-    result += `event:${event.event}
-`;
+    lines.push(`event:${event.event}`);
   }
   if (event.id) {
-    result += `id:${event.id}
-`;
+    lines.push(`id:${event.id}`);
   }
   if (event.retry) {
-    result += `retry:${event.retry}
-`;
+    lines.push(`retry:${event.retry}`);
   }
   if (event.data !== void 0) {
-    result += `data:${JSON.stringify(event.data)}`;
+    lines.push(`data:${JSON.stringify(event.data)}`);
   }
-  return result;
+  return lines.join("\n");
 }
 var SSEController = class {
   controller;
@@ -67,7 +55,7 @@ var SSEController = class {
     this.controller = controller;
   }
   enqueue(event) {
-    this.controller.enqueue(sseEventToString(event) + "\n\n");
+    this.controller.enqueue(event);
   }
   close() {
     this.controller.close();

package/dist/stream/stream.d.cts

@@ -1,6 +1,9 @@
-declare class KaitoSSEResponse<_T> extends Response {
-    constructor(body: ReadableStream<string>, init?: ResponseInit);
-    get [Symbol.toStringTag](): string;
+import { JSONValue } from '../schema/schema.cjs';
+import 'openapi3-ts/oas31';
+
+declare class KaitoSSEResponse<T> {
+    readonly events: ReadableStream<T>;
+    constructor(events: ReadableStream<T>);
 }
 type SSEEvent<T, E extends string> = ({
     data: T;
@@ -17,20 +20,20 @@ type SSEEvent<T, E extends string> = ({
  * @param event The SSE Event
  * @returns A stringified version
  */
-declare function sseEventToString(event: SSEEvent<unknown, string>): string;
-declare class SSEController<U, E extends string> implements Disposable {
+declare function sseEventToString(event: SSEEvent<JSONValue, string>): string;
+declare class SSEController<U, E extends string, T extends SSEEvent<U, E>> implements Disposable {
     private readonly controller;
-    constructor(controller: ReadableStreamDefaultController<string>);
-    enqueue(event: SSEEvent<U, E>): void;
+    constructor(controller: ReadableStreamDefaultController<T>);
+    enqueue(event: T): void;
     close(): void;
     [Symbol.dispose](): void;
 }
-interface SSESource<U, E extends string> {
+interface SSESource<U, E extends string, T extends SSEEvent<U, E>> {
     cancel?: UnderlyingSourceCancelCallback;
-    start?(controller: SSEController<U, E>): Promise<void>;
-    pull?(controller: SSEController<U, E>): Promise<void>;
+    start?(controller: SSEController<U, E, T>): Promise<void>;
+    pull?(controller: SSEController<U, E, T>): Promise<void>;
 }
-declare function sse<U, E extends string, T extends SSEEvent<U, E>>(source: SSESource<U, E> | AsyncGenerator<T, unknown, unknown> | (() => AsyncGenerator<T, unknown, unknown>)): KaitoSSEResponse<T>;
+declare function sse<U, E extends string, T extends SSEEvent<U, E>>(source: SSESource<U, E, T> | AsyncGenerator<T, unknown, unknown> | (() => AsyncGenerator<T, unknown, unknown>)): KaitoSSEResponse<T>;
 declare function sseFromAnyReadable<R, U, E extends string>(stream: ReadableStream<R>, transform: (chunk: R) => SSEEvent<U, E>): KaitoSSEResponse<SSEEvent<U, E>>;
 
 export { KaitoSSEResponse, SSEController, type SSEEvent, type SSESource, sse, sseEventToString, sseFromAnyReadable };

package/dist/stream/stream.d.ts

@@ -1,6 +1,9 @@
-declare class KaitoSSEResponse<_T> extends Response {
-    constructor(body: ReadableStream<string>, init?: ResponseInit);
-    get [Symbol.toStringTag](): string;
+import { JSONValue } from '../schema/schema.js';
+import 'openapi3-ts/oas31';
+
+declare class KaitoSSEResponse<T> {
+    readonly events: ReadableStream<T>;
+    constructor(events: ReadableStream<T>);
 }
 type SSEEvent<T, E extends string> = ({
     data: T;
@@ -17,20 +20,20 @@ type SSEEvent<T, E extends string> = ({
  * @param event The SSE Event
  * @returns A stringified version
  */
-declare function sseEventToString(event: SSEEvent<unknown, string>): string;
-declare class SSEController<U, E extends string> implements Disposable {
+declare function sseEventToString(event: SSEEvent<JSONValue, string>): string;
+declare class SSEController<U, E extends string, T extends SSEEvent<U, E>> implements Disposable {
     private readonly controller;
-    constructor(controller: ReadableStreamDefaultController<string>);
-    enqueue(event: SSEEvent<U, E>): void;
+    constructor(controller: ReadableStreamDefaultController<T>);
+    enqueue(event: T): void;
     close(): void;
     [Symbol.dispose](): void;
 }
-interface SSESource<U, E extends string> {
+interface SSESource<U, E extends string, T extends SSEEvent<U, E>> {
     cancel?: UnderlyingSourceCancelCallback;
-    start?(controller: SSEController<U, E>): Promise<void>;
-    pull?(controller: SSEController<U, E>): Promise<void>;
+    start?(controller: SSEController<U, E, T>): Promise<void>;
+    pull?(controller: SSEController<U, E, T>): Promise<void>;
 }
-declare function sse<U, E extends string, T extends SSEEvent<U, E>>(source: SSESource<U, E> | AsyncGenerator<T, unknown, unknown> | (() => AsyncGenerator<T, unknown, unknown>)): KaitoSSEResponse<T>;
+declare function sse<U, E extends string, T extends SSEEvent<U, E>>(source: SSESource<U, E, T> | AsyncGenerator<T, unknown, unknown> | (() => AsyncGenerator<T, unknown, unknown>)): KaitoSSEResponse<T>;
 declare function sseFromAnyReadable<R, U, E extends string>(stream: ReadableStream<R>, transform: (chunk: R) => SSEEvent<U, E>): KaitoSSEResponse<SSEEvent<U, E>>;
 
 export { KaitoSSEResponse, SSEController, type SSEEvent, type SSESource, sse, sseEventToString, sseFromAnyReadable };