@kaana.ai/sdk 0.0.0-stage → 1.0.0

package/dist/chat.js

@@ -0,0 +1,149 @@
+/** `POST /v1/chat/completions`, the OpenAI dialect: whole and streamed. */
+import { chatCompletionChunkSchema, chatCompletionErrorSchema, chatCompletionSchema, } from '@kaana.ai/contracts';
+import { concatBytes, decodeBase64, encodeBase64 } from './base64.js';
+import { isRetryableCode, kaanaError, KaanaProtocolError } from './errors.js';
+import { cutOff, readFrames } from './events.js';
+import { validate } from './http.js';
+import { StreamHandle } from './stream.js';
+const DONE = '[DONE]';
+export function chatStream(transport, body, options) {
+    return new StreamHandle(async function* (context) {
+        const sent = await transport.send({
+            method: 'POST',
+            path: '/chat/completions',
+            body,
+            accept: 'text/event-stream',
+            dialect: 'chat',
+            options: { ...options, signal: context.signal },
+            stream: true,
+        });
+        const requestId = sent.requestId;
+        context.setRequestId(requestId);
+        const fold = new ChatFold();
+        let output = false;
+        for await (const frame of readFrames(sent, () => output)) {
+            if (frame.data === DONE)
+                return fold.completion(requestId);
+            let payload;
+            try {
+                payload = JSON.parse(frame.data);
+            }
+            catch (_error) {
+                throw new KaanaProtocolError('The stream sent a frame that is not JSON.', requestId);
+            }
+            if (typeof payload === 'object' && payload !== null && 'error' in payload) {
+                const { error } = validate(payload, chatCompletionErrorSchema, requestId, 'stream error');
+                throw kaanaError({
+                    code: error.code,
+                    message: error.message,
+                    status: null,
+                    requestId,
+                    retryable: isRetryableCode(error.code),
+                    ...(error.param === null ? {} : { param: error.param }),
+                    afterOutput: output,
+                });
+            }
+            const chunk = validate(payload, chatCompletionChunkSchema, requestId, 'stream chunk');
+            if (chunk.choices.some((choice) => hasOutput(choice.delta))) {
+                output = true;
+                context.markOutput();
+            }
+            fold.add(chunk);
+            yield chunk;
+        }
+        throw cutOff(requestId);
+    }, options.signal);
+}
+function hasOutput(delta) {
+    return ((delta.content !== undefined && delta.content.length > 0) ||
+        delta.refusal !== undefined ||
+        delta.audio !== undefined ||
+        (delta.tool_calls !== undefined && delta.tool_calls.length > 0));
+}
+const ZERO_USAGE = {
+    prompt_tokens: 0,
+    completion_tokens: 0,
+    total_tokens: 0,
+    prompt_tokens_details: { cached_tokens: 0 },
+    completion_tokens_details: { reasoning_tokens: 0 },
+};
+/** Folds the chunks of one completion into the `ChatCompletion` it describes. */
+export class ChatFold {
+    #first;
+    #usage;
+    #choices = new Map();
+    add(chunk) {
+        this.#first ??= chunk;
+        if (chunk.usage !== undefined)
+            this.#usage = chunk.usage;
+        for (const choice of chunk.choices) {
+            const fold = this.#choices.get(choice.index) ?? {
+                content: null,
+                finishReason: null,
+                toolCalls: new Map(),
+            };
+            const delta = choice.delta;
+            if (delta.content !== undefined)
+                fold.content = (fold.content ?? '') + delta.content;
+            if (delta.audio !== undefined) {
+                fold.audio ??= { id: delta.audio.id, data: [], transcript: '', expiresAt: 0 };
+                if (delta.audio.data !== undefined)
+                    fold.audio.data.push(decodeBase64(delta.audio.data));
+                if (delta.audio.transcript !== undefined)
+                    fold.audio.transcript += delta.audio.transcript;
+                if (delta.audio.expires_at !== undefined)
+                    fold.audio.expiresAt = delta.audio.expires_at;
+            }
+            for (const call of delta.tool_calls ?? []) {
+                const known = fold.toolCalls.get(call.index) ?? { id: '', name: '', arguments: '' };
+                if (call.id !== undefined)
+                    known.id = call.id;
+                if (call.function.name !== undefined)
+                    known.name += call.function.name;
+                if (call.function.arguments !== undefined)
+                    known.arguments += call.function.arguments;
+                fold.toolCalls.set(call.index, known);
+            }
+            if (choice.finish_reason !== null)
+                fold.finishReason = choice.finish_reason;
+            this.#choices.set(choice.index, fold);
+        }
+    }
+    completion(requestId) {
+        const first = this.#first;
+        if (first === undefined) {
+            throw new KaanaProtocolError('The stream ended without a chunk.', requestId);
+        }
+        const choices = [...this.#choices]
+            .sort(([a], [b]) => a - b)
+            .map(([index, fold]) => {
+            const message = { role: 'assistant', content: fold.content };
+            if (fold.audio !== undefined) {
+                message.audio = {
+                    id: fold.audio.id,
+                    data: encodeBase64(concatBytes(fold.audio.data)),
+                    transcript: fold.audio.transcript,
+                    expires_at: fold.audio.expiresAt,
+                };
+            }
+            if (fold.toolCalls.size > 0) {
+                message.tool_calls = [...fold.toolCalls]
+                    .sort(([a], [b]) => a - b)
+                    .map(([, call]) => ({
+                    id: call.id,
+                    type: 'function',
+                    function: { name: call.name, arguments: call.arguments },
+                }));
+            }
+            return { index, message, finish_reason: fold.finishReason ?? 'stop' };
+        });
+        return validate({
+            id: first.id,
+            object: 'chat.completion',
+            created: first.created,
+            model: first.model,
+            choices,
+            usage: this.#usage ?? ZERO_USAGE,
+        }, chatCompletionSchema, requestId, 'folded completion');
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,52 @@
+/** The `Kaana` client (Kaana ADR 0002, "Superficie del SDK"). */
+import { type ChatCompletion, type ChatCompletionChunk, type ChatCompletionsRequest, type DecisionRequest, type DecisionSuccess, type EmbeddingsRequest, type EmbeddingsResponse, type GenerationRecord, type ImageGenerations, type ImageGenerationsRequest, type Model, type ModelReference, type PowerLevelEntry, type Response, type ResponseStreamEvent, type ResponsesRequest, type SpeechRequest, type Transcription } from '@kaana.ai/contracts';
+import { type SpeechResult, type SpeechStream, type TranscriptionRequest } from './audio.js';
+import { type KaanaOptions, type RequestOptions } from './http.js';
+import { type RealtimeConnectRequest, type RealtimeSession } from './realtime.js';
+import type { KaanaStream } from './stream.js';
+export declare class Kaana {
+    #private;
+    readonly models: {
+        list(options?: RequestOptions): Promise<Model[]>;
+        get(id: ModelReference, options?: RequestOptions): Promise<Model>;
+    };
+    readonly powerLevels: {
+        list(options?: RequestOptions): Promise<PowerLevelEntry[]>;
+    };
+    readonly responses: {
+        create(request: ResponsesRequest, options?: RequestOptions): Promise<Response>;
+        stream(request: ResponsesRequest, options?: RequestOptions): KaanaStream<ResponseStreamEvent, Response>;
+    };
+    readonly chat: {
+        completions: {
+            create(request: ChatCompletionsRequest, options?: RequestOptions): Promise<ChatCompletion>;
+            stream(request: ChatCompletionsRequest, options?: RequestOptions): KaanaStream<ChatCompletionChunk, ChatCompletion>;
+        };
+    };
+    readonly embeddings: {
+        create(request: EmbeddingsRequest, options?: RequestOptions): Promise<EmbeddingsResponse>;
+    };
+    readonly audio: {
+        speech(request: SpeechRequest, options?: RequestOptions): Promise<SpeechResult>;
+        speechStream(request: SpeechRequest, options?: RequestOptions): SpeechStream;
+        transcriptions: {
+            create(request: TranscriptionRequest, options?: RequestOptions): Promise<Transcription>;
+        };
+    };
+    readonly images: {
+        generate(request: ImageGenerationsRequest, options?: RequestOptions): Promise<ImageGenerations>;
+    };
+    readonly decisions: {
+        create(request: DecisionRequest, options?: RequestOptions): Promise<DecisionSuccess>;
+    };
+    readonly generations: {
+        get(id: string, options?: RequestOptions): Promise<GenerationRecord>;
+        getByIdempotencyKey(key: string, options?: RequestOptions): Promise<GenerationRecord>;
+    };
+    readonly realtime: {
+        connect(request: RealtimeConnectRequest, options?: RequestOptions): Promise<RealtimeSession>;
+    };
+    constructor(options: KaanaOptions);
+    /** The origin and version this client speaks to. */
+    get baseURL(): string;
+}

package/dist/client.js

@@ -0,0 +1,109 @@
+/** The `Kaana` client (Kaana ADR 0002, "Superficie del SDK"). */
+import { chatCompletionSchema, chatCompletionsRequestSchema, decisionRequestSchema, decisionSuccessSchema, embeddingsRequestSchema, embeddingsResponseSchema, generationRecordSchema, imageGenerationsRequestSchema, imageGenerationsSchema, modelListSchema, modelReferenceSchema, modelSchema, powerLevelListSchema, responseSchema, responsesRequestSchema, } from '@kaana.ai/contracts';
+import { speech, speechStream, transcribe, } from './audio.js';
+import { chatStream } from './chat.js';
+import { clientRefusal } from './errors.js';
+import { Transport } from './http.js';
+import { connectRealtime } from './realtime.js';
+import { responsesStream } from './responses.js';
+/** Validate a request before sending it; the original object is what is sent. */
+function body(request, schema) {
+    const parsed = schema.safeParse(request);
+    if (!parsed.success) {
+        const issue = parsed.error.issues[0];
+        throw clientRefusal(issue?.path.map(String).join('.') || 'request', issue?.message ?? 'the request does not satisfy @kaana.ai/contracts');
+    }
+    return JSON.stringify(request);
+}
+function modelPath(id) {
+    if (!modelReferenceSchema.safeParse(id).success) {
+        throw clientRefusal('id', 'a model reference is publisher/model[@revision]');
+    }
+    return id
+        .split('/')
+        .map((segment) => encodeURIComponent(segment))
+        .join('/');
+}
+export class Kaana {
+    #transport;
+    models;
+    powerLevels;
+    responses;
+    chat;
+    embeddings;
+    audio;
+    images;
+    decisions;
+    generations;
+    realtime;
+    constructor(options) {
+        const transport = new Transport(options);
+        this.#transport = transport;
+        const get = async (path, schema, options = {}, query) => (await transport.json({ method: 'GET', path, accept: 'application/json', options, ...(query ? { query } : {}) }, schema)).value;
+        const post = async (path, json, schema, options = {}, dialect = 'public') => (await transport.json({ method: 'POST', path, body: json, accept: 'application/json', options, dialect }, schema)).value;
+        this.models = {
+            list: async (options) => (await get('/models', modelListSchema, options)).data,
+            get: async (id, options) => get(`/models/${modelPath(id)}`, modelSchema, options),
+        };
+        this.powerLevels = {
+            list: async (options) => (await get('/power-levels', powerLevelListSchema, options)).data,
+        };
+        this.responses = {
+            create: async (request, options) => {
+                if (request.stream === true) {
+                    throw clientRefusal('stream', 'responses.create returns whole; use responses.stream');
+                }
+                return post('/responses', body(request, responsesRequestSchema), responseSchema, options);
+            },
+            stream: (request, options = {}) => responsesStream(transport, body({ ...request, stream: true }, responsesRequestSchema), options),
+        };
+        this.chat = {
+            completions: {
+                create: async (request, options) => {
+                    if (request.stream === true) {
+                        throw clientRefusal('stream', 'chat.completions.create returns whole; use chat.completions.stream');
+                    }
+                    return post('/chat/completions', body(request, chatCompletionsRequestSchema), chatCompletionSchema, options, 'chat');
+                },
+                stream: (request, options = {}) => chatStream(transport, body({ ...request, stream: true }, chatCompletionsRequestSchema), options),
+            },
+        };
+        this.embeddings = {
+            create: async (request, options) => post('/embeddings', body(request, embeddingsRequestSchema), embeddingsResponseSchema, options),
+        };
+        this.audio = {
+            speech: (request, options = {}) => speech(transport, request, options),
+            speechStream: (request, options = {}) => speechStream(transport, request, options),
+            transcriptions: {
+                create: (request, options = {}) => transcribe(transport, request, options),
+            },
+        };
+        this.images = {
+            generate: async (request, options) => post('/images/generations', body(request, imageGenerationsRequestSchema), imageGenerationsSchema, options),
+        };
+        this.decisions = {
+            create: async (request, options) => post('/decisions', body(request, decisionRequestSchema), decisionSuccessSchema, options),
+        };
+        this.generations = {
+            get: async (id, options) => {
+                if (typeof id !== 'string' || id.length === 0 || id.length > 128) {
+                    throw clientRefusal('id', 'a generation id is 1 to 128 characters');
+                }
+                return get(`/generations/${encodeURIComponent(id)}`, generationRecordSchema, options);
+            },
+            getByIdempotencyKey: async (key, options) => {
+                if (typeof key !== 'string' || key.length === 0 || key.length > 255) {
+                    throw clientRefusal('idempotency_key', 'an idempotency key is 1 to 255 characters');
+                }
+                return get('/generations', generationRecordSchema, options, { idempotency_key: key });
+            },
+        };
+        this.realtime = {
+            connect: (request, options = {}) => connectRealtime(transport, request, options),
+        };
+    }
+    /** The origin and version this client speaks to. */
+    get baseURL() {
+        return this.#transport.baseURL;
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Typed errors (Kaana ADR 0002, "Superficie del SDK").
+ *
+ * `code` is the PUBLIC vocabulary of `@kaana.ai/contracts`: it says what went
+ * wrong and whether to retry, never which provider served or failed. Accounts,
+ * keys, limits and balances are managed in Oxy Console (https://console.oxy.so).
+ */
+import { type PublicError, type PublicErrorCode } from '@kaana.ai/contracts';
+/** Whether an identical retry of a request that failed with `code` can succeed. */
+export declare function isRetryableCode(code: PublicErrorCode): boolean;
+export interface KaanaErrorInit {
+    code: PublicErrorCode;
+    message: string;
+    /** HTTP status, or null when the error arrived as a terminal stream event. */
+    status: number | null;
+    requestId: string | null;
+    retryable: boolean;
+    retryAfterMs?: number;
+    param?: string;
+    /** Whether output reached the caller before the failure. */
+    afterOutput?: boolean;
+}
+/** A failure the API reported in its public vocabulary. */
+export declare class KaanaError extends Error {
+    readonly code: PublicErrorCode;
+    readonly status: number | null;
+    readonly requestId: string | null;
+    readonly retryable: boolean;
+    readonly retryAfterMs?: number;
+    readonly param?: string;
+    readonly afterOutput: boolean;
+    constructor(init: KaanaErrorInit);
+}
+/** `authentication_failed`: the credential is missing, malformed, expired or revoked. */
+export declare class KaanaAuthenticationError extends KaanaError {
+}
+/** `permission_denied`, `insufficient_scope`, `commercial_permission_denied`, `policy_violation`. */
+export declare class KaanaPermissionError extends KaanaError {
+}
+/** The request itself cannot be served as written. */
+export declare class KaanaInvalidRequestError extends KaanaError {
+}
+/** `insufficient_balance`, `spending_limit_exceeded`, `quota_exceeded`. */
+export declare class KaanaBillingError extends KaanaError {
+}
+/** `rate_limited`. */
+export declare class KaanaRateLimitError extends KaanaError {
+}
+/** No route could serve the request right now, or the upstream failed. */
+export declare class KaanaUnavailableError extends KaanaError {
+}
+/** `upstream_content_filtered`. */
+export declare class KaanaContentFilteredError extends KaanaError {
+}
+/** `cancelled`, including a request the caller aborted. */
+export declare class KaanaCancelledError extends KaanaError {
+}
+/** `internal_error`. */
+export declare class KaanaInternalError extends KaanaError {
+}
+/** A response that does not satisfy `@kaana.ai/contracts`. Never retryable. */
+export declare class KaanaProtocolError extends Error {
+    readonly requestId: string | null;
+    constructor(message: string, requestId: string | null);
+}
+/** The network failed, or the request timed out, before a response arrived. */
+export declare class KaanaConnectionError extends Error {
+    readonly cause: unknown;
+    readonly timedOut: boolean;
+    constructor(message: string, options?: {
+        cause?: unknown;
+        timedOut?: boolean;
+    });
+}
+/** The typed error for a public code. */
+export declare function kaanaError(init: KaanaErrorInit): KaanaError;
+/** The typed error for a `PublicError` body or terminal event. */
+export declare function fromPublicError(error: PublicError, status: number | null, afterOutput?: boolean): KaanaError;
+/** A request the SDK refuses before sending anything. */
+export declare function clientRefusal(param: string, message: string): KaanaInvalidRequestError;
+/** The caller withdrew the request. */
+export declare function cancelledByCaller(requestId: string | null, afterOutput?: boolean): KaanaError;

package/dist/errors.js

@@ -0,0 +1,150 @@
+/**
+ * Typed errors (Kaana ADR 0002, "Superficie del SDK").
+ *
+ * `code` is the PUBLIC vocabulary of `@kaana.ai/contracts`: it says what went
+ * wrong and whether to retry, never which provider served or failed. Accounts,
+ * keys, limits and balances are managed in Oxy Console (https://console.oxy.so).
+ */
+import { NON_RETRYABLE_PUBLIC_ERROR_CODES, } from '@kaana.ai/contracts';
+const NON_RETRYABLE = new Set(NON_RETRYABLE_PUBLIC_ERROR_CODES);
+/** Whether an identical retry of a request that failed with `code` can succeed. */
+export function isRetryableCode(code) {
+    return !NON_RETRYABLE.has(code);
+}
+/** A failure the API reported in its public vocabulary. */
+export class KaanaError extends Error {
+    code;
+    status;
+    requestId;
+    retryable;
+    retryAfterMs;
+    param;
+    afterOutput;
+    constructor(init) {
+        super(init.message);
+        this.name = new.target.name;
+        this.code = init.code;
+        this.status = init.status;
+        this.requestId = init.requestId;
+        this.retryable = init.retryable;
+        if (init.retryAfterMs !== undefined)
+            this.retryAfterMs = init.retryAfterMs;
+        if (init.param !== undefined)
+            this.param = init.param;
+        this.afterOutput = init.afterOutput ?? false;
+    }
+}
+/** `authentication_failed`: the credential is missing, malformed, expired or revoked. */
+export class KaanaAuthenticationError extends KaanaError {
+}
+/** `permission_denied`, `insufficient_scope`, `commercial_permission_denied`, `policy_violation`. */
+export class KaanaPermissionError extends KaanaError {
+}
+/** The request itself cannot be served as written. */
+export class KaanaInvalidRequestError extends KaanaError {
+}
+/** `insufficient_balance`, `spending_limit_exceeded`, `quota_exceeded`. */
+export class KaanaBillingError extends KaanaError {
+}
+/** `rate_limited`. */
+export class KaanaRateLimitError extends KaanaError {
+}
+/** No route could serve the request right now, or the upstream failed. */
+export class KaanaUnavailableError extends KaanaError {
+}
+/** `upstream_content_filtered`. */
+export class KaanaContentFilteredError extends KaanaError {
+}
+/** `cancelled`, including a request the caller aborted. */
+export class KaanaCancelledError extends KaanaError {
+}
+/** `internal_error`. */
+export class KaanaInternalError extends KaanaError {
+}
+/** A response that does not satisfy `@kaana.ai/contracts`. Never retryable. */
+export class KaanaProtocolError extends Error {
+    requestId;
+    constructor(message, requestId) {
+        super(message);
+        this.name = 'KaanaProtocolError';
+        this.requestId = requestId;
+    }
+}
+/** The network failed, or the request timed out, before a response arrived. */
+export class KaanaConnectionError extends Error {
+    cause;
+    timedOut;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = 'KaanaConnectionError';
+        this.cause = options.cause;
+        this.timedOut = options.timedOut ?? false;
+    }
+}
+const CLASS_BY_CODE = {
+    authentication_failed: KaanaAuthenticationError,
+    permission_denied: KaanaPermissionError,
+    insufficient_scope: KaanaPermissionError,
+    commercial_permission_denied: KaanaPermissionError,
+    policy_violation: KaanaPermissionError,
+    invalid_request: KaanaInvalidRequestError,
+    model_not_found: KaanaInvalidRequestError,
+    unsupported_modality: KaanaInvalidRequestError,
+    context_length_exceeded: KaanaInvalidRequestError,
+    request_too_large: KaanaInvalidRequestError,
+    output_limit_exceeded: KaanaInvalidRequestError,
+    idempotency_conflict: KaanaInvalidRequestError,
+    byok_credential_invalid: KaanaInvalidRequestError,
+    insufficient_balance: KaanaBillingError,
+    spending_limit_exceeded: KaanaBillingError,
+    quota_exceeded: KaanaBillingError,
+    rate_limited: KaanaRateLimitError,
+    no_route_available: KaanaUnavailableError,
+    service_unavailable: KaanaUnavailableError,
+    provider_error: KaanaUnavailableError,
+    provider_timeout: KaanaUnavailableError,
+    provider_overloaded: KaanaUnavailableError,
+    upstream_content_filtered: KaanaContentFilteredError,
+    cancelled: KaanaCancelledError,
+    internal_error: KaanaInternalError,
+};
+/** The typed error for a public code. */
+export function kaanaError(init) {
+    const ErrorType = CLASS_BY_CODE[init.code] ?? KaanaError;
+    return new ErrorType(init);
+}
+/** The typed error for a `PublicError` body or terminal event. */
+export function fromPublicError(error, status, afterOutput = false) {
+    return kaanaError({
+        code: error.code,
+        message: error.message,
+        status,
+        requestId: error.requestId,
+        retryable: error.retryable,
+        ...(error.retryAfterMs === undefined ? {} : { retryAfterMs: error.retryAfterMs }),
+        ...(error.param === undefined ? {} : { param: error.param }),
+        afterOutput,
+    });
+}
+/** A request the SDK refuses before sending anything. */
+export function clientRefusal(param, message) {
+    return new KaanaInvalidRequestError({
+        code: 'invalid_request',
+        message,
+        status: null,
+        requestId: null,
+        retryable: false,
+        param,
+    });
+}
+/** The caller withdrew the request. */
+export function cancelledByCaller(requestId, afterOutput = false) {
+    return new KaanaCancelledError({
+        code: 'cancelled',
+        message: 'the request was aborted by the caller',
+        status: null,
+        requestId,
+        retryable: false,
+        afterOutput,
+    });
+}

package/dist/events.d.ts

@@ -0,0 +1,11 @@
+/** Reading a `text/event-stream` response into validated frames. */
+import { KaanaConnectionError } from './errors.js';
+import { type Sent } from './http.js';
+import { type SseFrame } from './sse.js';
+/** The response body as a stream, or a clear failure where the runtime has none. */
+export declare function streamingBody(sent: Sent): ReadableStream<Uint8Array>;
+export declare function readFrames(sent: Sent, output: () => boolean): AsyncGenerator<SseFrame>;
+/** Parse one frame's JSON. */
+export declare function frameJson(frame: SseFrame, requestId: string): unknown;
+/** A stream that ended without its terminal event was cut off. */
+export declare function cutOff(requestId: string): KaanaConnectionError;

package/dist/events.js

@@ -0,0 +1,51 @@
+/** Reading a `text/event-stream` response into validated frames. */
+import { cancelledByCaller, KaanaConnectionError, KaanaProtocolError } from './errors.js';
+import { bodyReadFailure, mediaTypeOf } from './http.js';
+import { decodeEventStream } from './sse.js';
+/** The response body as a stream, or a clear failure where the runtime has none. */
+export function streamingBody(sent) {
+    const body = sent.response.body;
+    if (body === null || typeof body.getReader !== 'function') {
+        sent.abort();
+        sent.release();
+        throw new KaanaConnectionError("This runtime's fetch exposes no streaming response body, which streaming methods need. " +
+            'In React Native, install a fetch that streams (for example a streaming fetch polyfill); ' +
+            'the non-streaming methods work without one.');
+    }
+    return body;
+}
+export async function* readFrames(sent, output) {
+    if (mediaTypeOf(sent.response) !== 'text/event-stream') {
+        sent.abort();
+        sent.release();
+        throw new KaanaProtocolError(`A streaming request was answered with ${mediaTypeOf(sent.response) ?? 'no Content-Type'} instead of text/event-stream.`, sent.requestId);
+    }
+    const body = streamingBody(sent);
+    try {
+        for await (const frame of decodeEventStream(body, sent.requestId))
+            yield frame;
+    }
+    catch (error) {
+        if (error instanceof KaanaProtocolError)
+            throw error;
+        if (sent.aborted())
+            throw cancelledByCaller(sent.requestId, output());
+        throw bodyReadFailure(sent, error);
+    }
+    finally {
+        sent.release();
+    }
+}
+/** Parse one frame's JSON. */
+export function frameJson(frame, requestId) {
+    try {
+        return JSON.parse(frame.data);
+    }
+    catch (_error) {
+        throw new KaanaProtocolError(`The stream sent a ${frame.event || 'unnamed'} frame that is not JSON.`, requestId);
+    }
+}
+/** A stream that ended without its terminal event was cut off. */
+export function cutOff(requestId) {
+    return new KaanaConnectionError(`The stream of request ${requestId} ended before its terminal event.`);
+}