@kitn.ai/ui 0.20.1 → 0.22.0

package/dist/wire/read.d.ts

@@ -0,0 +1,26 @@
+import { AssistantStreamSink, ConsumeOptions, ModelTurn, WireFormat } from './chunk.js';
+export type StreamSource = Response | ReadableStream<Uint8Array> | AsyncIterable<Uint8Array | string>;
+export interface ReadOptions extends ConsumeOptions {
+    format: WireFormat;
+}
+/** A non-ok HTTP response from the model endpoint, with the provider's own error
+ *  body attached when there is one. Thrown before a single chunk is read, so a
+ *  caller can distinguish "the request failed" from "the stream carried an
+ *  error", which is `ModelTurn.error`. */
+export declare class WireError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    /** The response body parsed as JSON, or undefined when it was not JSON (an
+     *  HTML error page from a proxy, most often). */
+    readonly body: unknown;
+    /** The raw response body, always. */
+    readonly bodyText: string;
+    constructor(status: number, statusText: string, bodyText: string, body: unknown);
+}
+/** Read one turn off the wire in `opts.format` and drive `sink` with it. */
+export declare function readModelStream(source: StreamSource, sink: AssistantStreamSink, opts: ReadOptions): Promise<ModelTurn>;
+/** OpenAI chat-completions SSE. Also what all nine catalog integrations except
+ *  `mock` re-frame to server-side, so this is the common path. */
+export declare function readOpenAIStream(source: StreamSource, sink: AssistantStreamSink, opts?: ConsumeOptions): Promise<ModelTurn>;
+/** Anthropic Messages SSE. */
+export declare function readAnthropicStream(source: StreamSource, sink: AssistantStreamSink, opts?: ConsumeOptions): Promise<ModelTurn>;

package/dist/wire/sink-helpers.d.ts

@@ -0,0 +1,21 @@
+import { AssistantStreamSink } from './chunk.js';
+/** Mark a tool call's panel done with the result the host computed. */
+export declare function applyToolOutput(sink: AssistantStreamSink, toolCallId: string, output: Record<string, unknown>): void;
+/** Mark a tool call's panel failed. */
+export declare function applyToolFailure(sink: AssistantStreamSink, toolCallId: string, message: string): void;
+/**
+ * A sink wrapper that swallows text instead of appending it, and hands the
+ * buffered text back at the end.
+ *
+ * Needed for STRUCTURED OUTPUTS: when `response_format` is a JSON schema the
+ * assistant's whole message is raw JSON, so streaming it into `<kai-thread>`
+ * shows the user a wall of braces. Buffer, parse, then `appendText` the human
+ * part, which behaves as a SET because nothing text-shaped ever reached the
+ * message (the kit has no replace-the-text operation; `appendTextPart` only ever
+ * extends or opens a text part).
+ *
+ * Reasoning, tools and sources pass straight through. Only text is held back.
+ */
+export declare function bufferText(sink: AssistantStreamSink): AssistantStreamSink & {
+    buffered(): string;
+};

package/dist/wire/sse.d.ts

@@ -0,0 +1,33 @@
+export type ByteSource = AsyncIterable<Uint8Array | string> | ReadableStream<Uint8Array>;
+/** Adapt a WHATWG ReadableStream to an async iterable. Never rely on
+ *  `for await (... of res.body)`: Safari still lacks async iteration on it.
+ *
+ *  On EARLY EXIT the underlying stream is CANCELLED, not just unlocked.
+ *  `releaseLock()` alone hands the reader back while the body stays open, which
+ *  leaks the socket. The adapter stops reading mid-stream on a real and
+ *  not-rare path (an in-band provider error after a 200), and every consumer
+ *  `break`/`throw` inside `for await` lands here too, so this is where the
+ *  connection has to be closed.
+ *
+ *  What must NOT land here is normal completion. `drained` is only honest if
+ *  every layer above reads to EOF rather than returning on a sentinel — see
+ *  `sseJson` and `[DONE]`. */
+export declare function readableToAsyncIterable(stream: ReadableStream<Uint8Array>): AsyncGenerator<Uint8Array>;
+/** Yield the payload of each SSE `data:` frame. `[DONE]` is yielded as-is; the
+ *  caller decides to stop. */
+export declare function sseDataFrames(source: ByteSource): AsyncGenerator<string>;
+/** Decode an SSE byte stream into JSON payloads, stopping at `[DONE]` and
+ *  skipping frames that are not JSON. A provider that emits a stray non-JSON
+ *  line should not take the turn down.
+ *
+ *  `[DONE]` stops the YIELDING, not the READING. Returning at the sentinel
+ *  unwinds the generator chain while the reader has not yet seen `done: true`,
+ *  so `readableToAsyncIterable` treats normal completion as an early exit and
+ *  CANCELS the body — and since every OpenAI-format stream ends in `[DONE]`,
+ *  that aborts the response on the normal path, one `net::ERR_ABORTED` per
+ *  turn. Reading on to EOF instead lets the producer's own close end the
+ *  iteration, which is the only thing that makes `drained` mean what it says.
+ *  In practice that costs exactly one more `read()`: a server that has sent
+ *  `[DONE]` has finished the response body. Frames after the sentinel are
+ *  dropped, so what a caller sees is unchanged. */
+export declare function sseJson<T>(source: ByteSource): AsyncGenerator<T>;

package/dist/wire.d.ts

@@ -1,53 +1,5 @@
-import { CardEnvelope, CardContext, CardEvent } from '../primitives/card-contract';
-export declare const CARD_WIRE_PROTOCOL: "kitn-card";
-export interface WireFrame<M extends WireMessage = WireMessage> {
-    protocol: typeof CARD_WIRE_PROTOCOL;
-    /** The NEGOTIATED contract version (set by the per-bridge packer). */
-    version: string;
-    /** Per-bridge instance nonce (host-minted, echoed on every up-frame). */
-    nonce: string;
-    message: M;
-}
-export type DownMessage = {
-    dir: 'down';
-    kind: 'hello';
-    supportedVersions: string[];
-} | {
-    dir: 'down';
-    kind: 'render';
-    envelope: CardEnvelope;
-} | {
-    dir: 'down';
-    kind: 'context';
-    context: CardContext;
-} | {
-    dir: 'down';
-    kind: 'teardown';
-};
-export type UpMessage = {
-    dir: 'up';
-    kind: 'ready';
-    acceptedVersion: string;
-    capabilities?: {
-        types?: string[];
-    };
-} | {
-    dir: 'up';
-    kind: 'event';
-    event: CardEvent;
-} | {
-    dir: 'up';
-    kind: 'focus-edge';
-    edge: 'start' | 'end';
-} | {
-    dir: 'up';
-    kind: 'fault';
-    code: WireFaultCode;
-    message: string;
-};
-export type WireFaultCode = 'version-unsupported' | 'bad-frame' | 'render-failed' | 'origin-rejected';
-export type WireMessage = DownMessage | UpMessage;
-export declare function createPacker(version: string, nonce: string): <M extends WireMessage>(message: M) => WireFrame<M>;
-/** Structural + direction guard. Host calls with 'up', runtime with 'down'.
- *  STRUCTURAL only — nonce/version equality + schema validation happen after. */
-export declare function isCardWireFrame(data: unknown, expectedDir: 'up' | 'down'): data is WireFrame;
+// GENERATED by scripts/emit-subpath-dts.mjs — do not edit.
+// Sibling declarations for dist/wire.js, so that RELATIVE imports
+// of this bundle (which bypass package.json "exports") still resolve to types.
+// Without this, tsc resolves the path to the .js and reports TS7016.
+export * from './wire/index.js';