@apifuse/provider-sdk 2.1.0-beta.6 → 2.1.0-beta.9

package/dist/server/types.d.ts

@@ -0,0 +1,136 @@
+import { z } from "zod";
+export declare const ConnectionModeSchema: z.ZodEnum<{
+    credentials: "credentials";
+    none: "none";
+    oauth2: "oauth2";
+    "platform-managed": "platform-managed";
+}>;
+export declare const OperationConnectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    mode: z.ZodEnum<{
+        credentials: "credentials";
+        none: "none";
+        oauth2: "oauth2";
+        "platform-managed": "platform-managed";
+    }>;
+    secrets: z.ZodRecord<z.ZodString, z.ZodString>;
+    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    externalRef: z.ZodString;
+}, z.core.$strip>;
+export declare const OperationRequestSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    connection: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        mode: z.ZodEnum<{
+            credentials: "credentials";
+            none: "none";
+            oauth2: "oauth2";
+            "platform-managed": "platform-managed";
+        }>;
+        secrets: z.ZodRecord<z.ZodString, z.ZodString>;
+        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        externalRef: z.ZodString;
+    }, z.core.$strip>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    trace: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const ErrorEnvelopeSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    requestId: z.ZodOptional<z.ZodString>;
+    fix: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const OperationSuccessResponseSchema: z.ZodObject<{
+    data: z.ZodUnknown;
+    meta: z.ZodOptional<z.ZodObject<{
+        cached: z.ZodOptional<z.ZodBoolean>;
+        stale: z.ZodOptional<z.ZodBoolean>;
+        cache: z.ZodOptional<z.ZodObject<{
+            hit: z.ZodBoolean;
+            stale: z.ZodBoolean;
+            keys: z.ZodArray<z.ZodString>;
+            source: z.ZodOptional<z.ZodEnum<{
+                loader: "loader";
+                memory: "memory";
+                mixed: "mixed";
+                redis: "redis";
+            }>>;
+        }, z.core.$strip>>;
+        retry: z.ZodOptional<z.ZodObject<{
+            attempts: z.ZodNumber;
+            retries: z.ZodNumber;
+            preset: z.ZodOptional<z.ZodEnum<{
+                aggressive_read: "aggressive_read";
+                off: "off";
+                rate_limit_aware: "rate_limit_aware";
+                safe_read: "safe_read";
+                transport_transient: "transport_transient";
+            }>>;
+            transport: z.ZodEnum<{
+                native: "native";
+            }>;
+            lastErrorCode: z.ZodOptional<z.ZodString>;
+            lastStatus: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export declare const OperationErrorResponseSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        requestId: z.ZodOptional<z.ZodString>;
+        fix: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const AuthFlowRequestSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    flowId: z.ZodString;
+    connectionId: z.ZodOptional<z.ZodString>;
+    externalRef: z.ZodOptional<z.ZodString>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    providerId: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    connection: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        mode: z.ZodEnum<{
+            credentials: "credentials";
+            none: "none";
+            oauth2: "oauth2";
+            "platform-managed": "platform-managed";
+        }>;
+        secrets: z.ZodRecord<z.ZodString, z.ZodString>;
+        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        externalRef: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const AuthFlowSuccessResponseSchema: z.ZodObject<{
+    data: z.ZodUnknown;
+    contextPatch: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const AuthFlowErrorResponseSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        requestId: z.ZodOptional<z.ZodString>;
+        fix: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ConnectionMode = z.infer<typeof ConnectionModeSchema>;
+export type OperationConnection = z.infer<typeof OperationConnectionSchema>;
+export type OperationRequest = z.infer<typeof OperationRequestSchema>;
+export type OperationSuccessResponse = z.infer<typeof OperationSuccessResponseSchema>;
+export type OperationErrorResponse = z.infer<typeof OperationErrorResponseSchema>;
+export type OperationResponse = OperationSuccessResponse | OperationErrorResponse;
+export type AuthFlowRequest = z.infer<typeof AuthFlowRequestSchema>;
+export type AuthFlowSuccessResponse = z.infer<typeof AuthFlowSuccessResponseSchema>;
+export type AuthFlowErrorResponse = z.infer<typeof AuthFlowErrorResponseSchema>;
+export type AuthFlowResponse = AuthFlowSuccessResponse | AuthFlowErrorResponse;

package/dist/server/types.js

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import { HttpRetryPreset } from "../types";
+export const ConnectionModeSchema = z.enum([
+    "oauth2",
+    "credentials",
+    "platform-managed",
+    "none",
+]);
+export const OperationConnectionSchema = z.object({
+    id: z.string(),
+    mode: ConnectionModeSchema,
+    secrets: z.record(z.string(), z.string()),
+    scopes: z.array(z.string()).optional(),
+    metadata: z.record(z.string(), z.unknown()),
+    externalRef: z.string(),
+});
+export const OperationRequestSchema = z.object({
+    requestId: z.string(),
+    input: z.record(z.string(), z.unknown()),
+    connection: OperationConnectionSchema.optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+    trace: z.record(z.string(), z.string()).optional(),
+});
+export const ErrorEnvelopeSchema = z.object({
+    code: z.string(),
+    message: z.string(),
+    requestId: z.string().optional(),
+    fix: z.string().optional(),
+    details: z.unknown().optional(),
+});
+export const OperationSuccessResponseSchema = z.object({
+    data: z.unknown(),
+    meta: z
+        .object({
+        cached: z.boolean().optional(),
+        stale: z.boolean().optional(),
+        cache: z
+            .object({
+            hit: z.boolean(),
+            stale: z.boolean(),
+            keys: z.array(z.string()),
+            source: z.enum(["redis", "memory", "loader", "mixed"]).optional(),
+        })
+            .optional(),
+        retry: z
+            .object({
+            attempts: z.number().int().min(1),
+            retries: z.number().int().min(0),
+            preset: z
+                .enum([
+                HttpRetryPreset.Off,
+                HttpRetryPreset.TransportTransient,
+                HttpRetryPreset.SafeRead,
+                HttpRetryPreset.AggressiveRead,
+                HttpRetryPreset.RateLimitAware,
+            ])
+                .optional(),
+            transport: z.enum(["native"]),
+            lastErrorCode: z.string().optional(),
+            lastStatus: z.number().int().optional(),
+        })
+            .optional(),
+    })
+        .passthrough()
+        .optional(),
+});
+export const OperationErrorResponseSchema = z.object({
+    error: ErrorEnvelopeSchema,
+});
+export const AuthFlowRequestSchema = z.object({
+    requestId: z.string(),
+    flowId: z.string(),
+    connectionId: z.string().optional(),
+    externalRef: z.string().optional(),
+    tenantId: z.string().optional(),
+    providerId: z.string().optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+    input: z.record(z.string(), z.unknown()).optional(),
+    context: z.record(z.string(), z.unknown()).optional(),
+    connection: OperationConnectionSchema.optional(),
+});
+export const AuthFlowSuccessResponseSchema = z.object({
+    data: z.unknown(),
+    contextPatch: z.record(z.string(), z.unknown().nullable()).optional(),
+});
+export const AuthFlowErrorResponseSchema = OperationErrorResponseSchema;

package/dist/stealth/profiles.d.ts

@@ -0,0 +1,4 @@
+import type { StealthProfile } from "../types";
+export declare function generateLayer2Headers(profile: StealthProfile): Record<string, string>;
+export declare function getStealthProfile(name: string): StealthProfile;
+export declare function listStealthProfiles(): string[];

package/dist/stealth/profiles.js

@@ -0,0 +1,259 @@
+import { SDKError } from "../errors";
+const CHROMIUM_HEADER_ORDER = [
+    ":method",
+    ":authority",
+    ":scheme",
+    ":path",
+    "user-agent",
+    "accept",
+    "accept-encoding",
+    "accept-language",
+    "cache-control",
+    "pragma",
+    "cookie",
+    "sec-ch-ua",
+    "sec-ch-ua-mobile",
+    "sec-ch-ua-platform",
+];
+const FIREFOX_HEADER_ORDER = [
+    ":method",
+    ":path",
+    ":authority",
+    ":scheme",
+    "user-agent",
+    "accept",
+    "accept-language",
+    "accept-encoding",
+    "referer",
+    "cookie",
+    "upgrade-insecure-requests",
+    "sec-fetch-dest",
+    "sec-fetch-mode",
+    "sec-fetch-site",
+    "sec-fetch-user",
+];
+const SAFARI_HEADER_ORDER = [
+    ":method",
+    ":scheme",
+    ":path",
+    ":authority",
+    "accept",
+    "user-agent",
+    "accept-language",
+    "accept-encoding",
+    "cookie",
+    "upgrade-insecure-requests",
+];
+const CHROMIUM_H2_SETTINGS = {
+    HEADER_TABLE_SIZE: 65536,
+    ENABLE_PUSH: 0,
+    INITIAL_WINDOW_SIZE: 6291456,
+    MAX_HEADER_LIST_SIZE: 262144,
+};
+const FIREFOX_H2_SETTINGS = {
+    HEADER_TABLE_SIZE: 65536,
+    INITIAL_WINDOW_SIZE: 131072,
+    MAX_FRAME_SIZE: 16384,
+    MAX_HEADER_LIST_SIZE: 65536,
+};
+const SAFARI_H2_SETTINGS = {
+    HEADER_TABLE_SIZE: 4096,
+    ENABLE_PUSH: 0,
+    INITIAL_WINDOW_SIZE: 4194304,
+    MAX_CONCURRENT_STREAMS: 100,
+};
+const CHROMIUM_JA3 = "771,4865-4866-4867-49195-49199-49196-49200-52393-52392-49171-49172-156-157-47-53,0-23-65281-10-11-35-16-5-13-18-51-45-43-27-17513-65037,29-23-24,0";
+const FIREFOX_JA3 = "771,4865-4867-4866-49195-49199-52393-52392-49196-49200-49162-49172-156-157-47-53,0-23-65281-10-11-35-16-5-13-28-27-43-45-51,29-23-24-25,0";
+const SAFARI_JA3 = "771,4865-4866-4867-49196-49195-52393-49200-49199-49188-49192-159-158-107-103-57-51-157-156-61-60-53-47-255,0-23-65281-10-11-16-5-13-18-51-45-43-27,29-23-24-25,0";
+function createProfile(name, definition) {
+    return {
+        name,
+        platform: definition.platform,
+        version: definition.version,
+        userAgent: definition.userAgent,
+        tlsClientIdentifier: definition.tlsClientIdentifier,
+        ja3: definition.ja3,
+        ja4: definition.ja4,
+        h2Settings: definition.h2Settings
+            ? { ...definition.h2Settings }
+            : undefined,
+        headerOrder: definition.headerOrder
+            ? [...definition.headerOrder]
+            : undefined,
+    };
+}
+function extractBrowserMajorVersion(profile) {
+    const chromeVersion = profile.userAgent.match(/Chrome\/(\d+)/)?.[1];
+    if (chromeVersion) {
+        return chromeVersion;
+    }
+    const identifierVersion = profile.tlsClientIdentifier?.match(/(\d+)(?!.*\d)/)?.[1];
+    if (identifierVersion) {
+        return identifierVersion;
+    }
+    return profile.version.split(".")[0] ?? profile.version;
+}
+function toPlatformHeaderValue(platform) {
+    switch (platform) {
+        case "macos":
+            return '"macOS"';
+        case "windows":
+            return '"Windows"';
+        case "linux":
+            return '"Linux"';
+        case "android":
+            return '"Android"';
+        case "ios":
+            return '"iOS"';
+    }
+}
+export function generateLayer2Headers(profile) {
+    const headers = {
+        "Accept-Language": "ko-KR,ko;q=0.9,en-US;q=0.8",
+    };
+    const identifier = profile.tlsClientIdentifier?.toLowerCase() ?? "";
+    const majorVersion = extractBrowserMajorVersion(profile);
+    if (identifier.startsWith("chrome_") || identifier.startsWith("edge_")) {
+        const isEdge = identifier.startsWith("edge_") || /\bEdg\//.test(profile.userAgent);
+        headers["Sec-Ch-Ua"] = isEdge
+            ? `"Chromium";v="${majorVersion}", "Microsoft Edge";v="${majorVersion}", "Not)A;Brand";v="99"`
+            : `"Chromium";v="${majorVersion}", "Google Chrome";v="${majorVersion}", "Not)A;Brand";v="99"`;
+        headers["Sec-Ch-Ua-Platform"] = toPlatformHeaderValue(profile.platform);
+        headers["Sec-Ch-Ua-Mobile"] =
+            profile.platform === "android" || profile.platform === "ios"
+                ? "?1"
+                : "?0";
+    }
+    return headers;
+}
+const STEALTH_PROFILE_ALIASES = {
+    "chrome-desktop": "chrome-146",
+};
+const STEALTH_PROFILES = {
+    "chrome-146": createProfile("chrome-146", {
+        platform: "macos",
+        version: "146.0.0.0",
+        userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
+        tlsClientIdentifier: "chrome_146",
+        ja3: CHROMIUM_JA3,
+        h2Settings: CHROMIUM_H2_SETTINGS,
+        headerOrder: CHROMIUM_HEADER_ORDER,
+    }),
+    "firefox-147": createProfile("firefox-147", {
+        platform: "macos",
+        version: "147.0",
+        userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0",
+        tlsClientIdentifier: "firefox_147",
+        ja3: FIREFOX_JA3,
+        h2Settings: FIREFOX_H2_SETTINGS,
+        headerOrder: FIREFOX_HEADER_ORDER,
+    }),
+    "firefox-135": createProfile("firefox-135", {
+        platform: "macos",
+        version: "135.0",
+        userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0",
+        tlsClientIdentifier: "firefox_135",
+        ja3: FIREFOX_JA3,
+        h2Settings: FIREFOX_H2_SETTINGS,
+        headerOrder: FIREFOX_HEADER_ORDER,
+    }),
+    "firefox-133": createProfile("firefox-133", {
+        platform: "macos",
+        version: "133.0",
+        userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:133.0) Gecko/20100101 Firefox/133.0",
+        tlsClientIdentifier: "firefox_133",
+        ja3: FIREFOX_JA3,
+        h2Settings: FIREFOX_H2_SETTINGS,
+        headerOrder: FIREFOX_HEADER_ORDER,
+    }),
+    "firefox-132": createProfile("firefox-132", {
+        platform: "macos",
+        version: "132.0",
+        userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:132.0) Gecko/20100101 Firefox/132.0",
+        tlsClientIdentifier: "firefox_132",
+        ja3: FIREFOX_JA3,
+        h2Settings: FIREFOX_H2_SETTINGS,
+        headerOrder: FIREFOX_HEADER_ORDER,
+    }),
+    "safari-16": createProfile("safari-16", {
+        platform: "macos",
+        version: "16.0",
+        userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Safari/605.1.15",
+        tlsClientIdentifier: "safari_16_0",
+        ja3: SAFARI_JA3,
+        h2Settings: SAFARI_H2_SETTINGS,
+        headerOrder: SAFARI_HEADER_ORDER,
+    }),
+    "safari-15": createProfile("safari-15", {
+        platform: "macos",
+        version: "15.6.1",
+        userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15",
+        tlsClientIdentifier: "safari_15_6_1",
+        ja3: SAFARI_JA3,
+        h2Settings: SAFARI_H2_SETTINGS,
+        headerOrder: SAFARI_HEADER_ORDER,
+    }),
+    "ios-safari-26": createProfile("ios-safari-26", {
+        platform: "ios",
+        version: "26.0",
+        userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 26_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1",
+        tlsClientIdentifier: "safari_ios_26_0",
+        ja3: SAFARI_JA3,
+        h2Settings: SAFARI_H2_SETTINGS,
+        headerOrder: SAFARI_HEADER_ORDER,
+    }),
+    "ios-safari-18": createProfile("ios-safari-18", {
+        platform: "ios",
+        version: "18.0",
+        userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1",
+        tlsClientIdentifier: "safari_ios_18_0",
+        ja3: SAFARI_JA3,
+        h2Settings: SAFARI_H2_SETTINGS,
+        headerOrder: SAFARI_HEADER_ORDER,
+    }),
+    "ios-safari-17": createProfile("ios-safari-17", {
+        platform: "ios",
+        version: "17.0",
+        userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1",
+        tlsClientIdentifier: "safari_ios_17_0",
+        ja3: SAFARI_JA3,
+        h2Settings: SAFARI_H2_SETTINGS,
+        headerOrder: SAFARI_HEADER_ORDER,
+    }),
+    "generic-desktop": createProfile("generic-desktop", {
+        platform: "macos",
+        version: "146.0.0.0",
+        userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
+        tlsClientIdentifier: "chrome_146",
+        ja3: CHROMIUM_JA3,
+        h2Settings: CHROMIUM_H2_SETTINGS,
+        headerOrder: CHROMIUM_HEADER_ORDER,
+    }),
+    "generic-mobile": createProfile("generic-mobile", {
+        platform: "ios",
+        version: "26.0",
+        userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 26_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1",
+        tlsClientIdentifier: "safari_ios_26_0",
+        ja3: SAFARI_JA3,
+        h2Settings: SAFARI_H2_SETTINGS,
+        headerOrder: SAFARI_HEADER_ORDER,
+    }),
+};
+export function getStealthProfile(name) {
+    const canonicalName = STEALTH_PROFILE_ALIASES[name] ?? name;
+    const profile = STEALTH_PROFILES[canonicalName];
+    if (!profile) {
+        throw new SDKError(`Unknown stealth profile: ${name}`);
+    }
+    return {
+        ...profile,
+        h2Settings: profile.h2Settings ? { ...profile.h2Settings } : undefined,
+        headerOrder: profile.headerOrder ? [...profile.headerOrder] : undefined,
+    };
+}
+export function listStealthProfiles() {
+    return [
+        ...Object.keys(STEALTH_PROFILES),
+        ...Object.keys(STEALTH_PROFILE_ALIASES),
+    ];
+}

package/dist/stream.d.ts

@@ -0,0 +1,44 @@
+import type { SseMessage } from "./types";
+export interface SseEvent<TData = unknown> {
+    event: string;
+    data: TData;
+    id?: string;
+    retry?: number;
+}
+export interface SseErrorData {
+    code: string;
+    message: string;
+    requestId?: string;
+    retryable?: boolean;
+    details?: unknown;
+}
+export declare const APIFUSE_STREAM_ERROR_EVENT = "apifuse.error";
+export declare const APIFUSE_STREAM_DONE_EVENT = "apifuse.done";
+export declare function event<TData>(eventName: string, data: TData, options?: {
+    id?: string;
+    retry?: number;
+}): SseEvent<TData>;
+export declare function error(code: string, message: string, options?: Omit<SseErrorData, "code" | "message"> & {
+    id?: string;
+    retry?: number;
+}): SseEvent<SseErrorData>;
+export declare function done(): SseEvent<Record<string, never>>;
+export declare function done<TData>(data: TData, options?: {
+    id?: string;
+    retry?: number;
+}): SseEvent<TData>;
+export declare function encodeSseEvent(input: SseEvent): string;
+export declare function readableBytes(body: ReadableStream<Uint8Array>): AsyncIterable<Uint8Array>;
+export declare function readableTextChunks(body: ReadableStream<Uint8Array>): AsyncIterable<string>;
+export declare function readableLines(body: ReadableStream<Uint8Array>): AsyncIterable<string>;
+export declare function parseSseStream(body: ReadableStream<Uint8Array>): AsyncIterable<SseMessage>;
+export declare const stream: {
+    event: typeof event;
+    error: typeof error;
+    done: typeof done;
+    encodeSseEvent: typeof encodeSseEvent;
+    parseSseStream: typeof parseSseStream;
+    readableBytes: typeof readableBytes;
+    readableTextChunks: typeof readableTextChunks;
+    readableLines: typeof readableLines;
+};

package/dist/stream.js

@@ -0,0 +1,151 @@
+export const APIFUSE_STREAM_ERROR_EVENT = "apifuse.error";
+export const APIFUSE_STREAM_DONE_EVENT = "apifuse.done";
+export function event(eventName, data, options = {}) {
+    return {
+        event: eventName,
+        data,
+        ...(options.id ? { id: options.id } : {}),
+        ...(options.retry !== undefined ? { retry: options.retry } : {}),
+    };
+}
+export function error(code, message, options = {}) {
+    const { id, retry, ...dataOptions } = options;
+    return event(APIFUSE_STREAM_ERROR_EVENT, { code, message, ...dataOptions }, { ...(id ? { id } : {}), ...(retry !== undefined ? { retry } : {}) });
+}
+export function done(data, options = {}) {
+    return event(APIFUSE_STREAM_DONE_EVENT, data ?? {}, options);
+}
+export function encodeSseEvent(input) {
+    const lines = [];
+    if (input.id !== undefined)
+        lines.push(`id: ${sseFieldValue(input.id, "id")}`);
+    if (input.event)
+        lines.push(`event: ${sseFieldValue(input.event, "event")}`);
+    if (input.retry !== undefined) {
+        if (!Number.isInteger(input.retry) || input.retry < 0) {
+            throw new TypeError("SSE retry must be a non-negative integer.");
+        }
+        lines.push(`retry: ${input.retry}`);
+    }
+    const data = typeof input.data === "string" ? input.data : JSON.stringify(input.data);
+    for (const line of data.split(/\r?\n/)) {
+        lines.push(`data: ${line}`);
+    }
+    return `${lines.join("\n")}\n\n`;
+}
+function sseFieldValue(value, field) {
+    if (/[\r\n]/.test(value)) {
+        throw new TypeError(`SSE ${field} must not contain CR or LF.`);
+    }
+    return value;
+}
+export async function* readableBytes(body) {
+    const reader = body.getReader();
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                return;
+            if (value)
+                yield value;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+export async function* readableTextChunks(body) {
+    const decoder = new TextDecoder();
+    for await (const chunk of readableBytes(body)) {
+        yield decoder.decode(chunk, { stream: true });
+    }
+    const tail = decoder.decode();
+    if (tail)
+        yield tail;
+}
+export async function* readableLines(body) {
+    let buffer = "";
+    for await (const chunk of readableTextChunks(body)) {
+        buffer += chunk;
+        for (;;) {
+            const index = buffer.search(/\r?\n/);
+            if (index < 0)
+                break;
+            const line = buffer.slice(0, index);
+            const newlineLength = buffer[index] === "\r" && buffer[index + 1] === "\n" ? 2 : 1;
+            buffer = buffer.slice(index + newlineLength);
+            yield line;
+        }
+    }
+    if (buffer)
+        yield buffer;
+}
+function createSseMessage(eventName, data, options) {
+    return {
+        event: eventName || "message",
+        data,
+        ...(options.id !== undefined ? { id: options.id } : {}),
+        ...(options.retry !== undefined ? { retry: options.retry } : {}),
+        json() {
+            return parseJson(data);
+        },
+    };
+}
+function parseJson(data) {
+    return JSON.parse(data);
+}
+export async function* parseSseStream(body) {
+    let eventName = "message";
+    let dataLines = [];
+    let id;
+    let retry;
+    const dispatch = function* () {
+        if (dataLines.length === 0 && id === undefined && retry === undefined) {
+            return;
+        }
+        yield createSseMessage(eventName, dataLines.join("\n"), { id, retry });
+        eventName = "message";
+        dataLines = [];
+        retry = undefined;
+    };
+    for await (const line of readableLines(body)) {
+        if (line === "") {
+            yield* dispatch();
+            continue;
+        }
+        if (line.startsWith(":"))
+            continue;
+        const separator = line.indexOf(":");
+        const field = separator < 0 ? line : line.slice(0, separator);
+        const rawValue = separator < 0 ? "" : line.slice(separator + 1);
+        const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+        switch (field) {
+            case "event":
+                eventName = value;
+                break;
+            case "data":
+                dataLines.push(value);
+                break;
+            case "id":
+                id = value;
+                break;
+            case "retry": {
+                const parsed = Number(value);
+                if (Number.isInteger(parsed) && parsed >= 0)
+                    retry = parsed;
+                break;
+            }
+        }
+    }
+    yield* dispatch();
+}
+export const stream = {
+    event,
+    error,
+    done,
+    encodeSseEvent,
+    parseSseStream,
+    readableBytes,
+    readableTextChunks,
+    readableLines,
+};