@theoremjs/react 0.0.0-stage → 0.3.0

package/client/decision-transport.js

@@ -0,0 +1,102 @@
+/**
+ * The browser side of a decision profile: what the host lets the page see of
+ * it, and the one call that asks its questions about some state.
+ *
+ * @module
+ */
+import { resolveObservabilityPolicy, traceRecordSchema, z, } from '@theoremjs/agents';
+import { fetchJson } from "./transport.js";
+import { checkWire } from "./wire-line.js";
+/** A score level's name: its text, or the first text inside a structured entry. */
+function entryLabel(entry, fallback) {
+    if (typeof entry === 'string')
+        return entry;
+    const entries = Array.isArray(entry) ? entry : Object.keys(entry);
+    return entries.length ? entryLabel(entries[0], fallback) : fallback;
+}
+/** The page's view of a decision profile and the questions its host asks. */
+export function decisionInterface(profile, questions) {
+    return {
+        type: 'decision',
+        identity: { handle: profile.identity.handle },
+        contract: profile.decision.contract,
+        ...(profile.inputs.maxStateBytes === undefined
+            ? {}
+            : { maxStateBytes: profile.inputs.maxStateBytes }),
+        questions: Object.entries(questions).map(([id, question]) => ({
+            id,
+            type: question.type,
+            labels: question.type === 'choice'
+                ? Object.keys(question.criteria)
+                : question.type === 'score'
+                    ? question.criteria.map((entry, level) => entryLabel(entry, String(level)))
+                    : [],
+        })),
+        ...(profile.observability
+            ? { observability: { record: resolveObservabilityPolicy(profile.observability).record } }
+            : {}),
+    };
+}
+const probability = z.number().min(0).max(1);
+const probabilities = z
+    .record(z.string(), probability)
+    .refine((record) => Math.abs(Object.values(record).reduce((sum, value) => sum + value, 0) - 1) <= 0.001);
+const answerSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('choice'),
+        choice: z.string(),
+        confidence: probability,
+        probabilities,
+    }),
+    z.object({ type: z.literal('noul'), noul: probability }),
+    z.object({
+        type: z.literal('score'),
+        score: z.number().nonnegative(),
+        confidence: probability,
+        legend: z.record(z.string(), z.string().min(1)),
+        probabilities,
+    }),
+]);
+const replySchema = z.object({
+    result: z.object({
+        model: z.string().min(1),
+        answers: z.record(z.string(), answerSchema),
+        usage: z
+            .object({
+            inputTokens: z.number().int().nonnegative(),
+            outputTokens: z.number().int().nonnegative(),
+            costUsd: z.number().nonnegative().optional(),
+        })
+            .optional(),
+    }),
+    traces: z.array(traceRecordSchema).optional(),
+});
+/** A host's decide reply, checked: the answers, and any trace records it delivers. */
+export function readDecisionReply(raw) {
+    // lexicon-exempt: internal diagnostic; the user reads error.bad_response
+    return checkWire(replySchema, raw, 'the decision');
+}
+const describedSchema = z.object({
+    interface: z.object({
+        type: z.literal('decision'),
+        identity: z.object({ handle: z.string() }),
+        contract: z.string(),
+        maxStateBytes: z.number().optional(),
+        questions: z.array(z.object({
+            id: z.string(),
+            type: z.enum(['choice', 'noul', 'score']),
+            labels: z.array(z.string()),
+        })),
+        observability: z.object({ record: z.boolean() }).optional(),
+    }),
+});
+/** Transport for a host mounted with `createTheoremDecisionHandler`. Default endpoint `/api/decision`. */
+export function createDecisionTransport(options = {}) {
+    const base = (options.endpoint ?? '/api/decision').replace(/\/$/, '');
+    return {
+        async describe(signal) {
+            return checkWire(describedSchema, await fetchJson(base, { signal }, options), 'the decision description').interface;
+        },
+        decide: async (state, signal) => readDecisionReply(await fetchJson(`${base}/decide`, { body: { state }, signal }, options)),
+    };
+}

package/client/decode-composer-draft.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Restore composer fields from a serializable pending `UserTurnDraft`.
+ */
+import type { UserTurnDraft } from '@theoremjs/agents/interface';
+export type ComposerDraftFields = {
+    text: string;
+    files: File[];
+    voice: File[];
+};
+/** Map an encoded pending draft back into live composer file fields. */
+export declare function composerFieldsFromDraft(draft: UserTurnDraft): ComposerDraftFields;

package/client/decode-composer-draft.js

@@ -0,0 +1,12 @@
+/**
+ * Restore composer fields from a serializable pending `UserTurnDraft`.
+ */
+import { pendingAttachmentsToFiles } from "./encode-files.js";
+/** Map an encoded pending draft back into live composer file fields. */
+export function composerFieldsFromDraft(draft) {
+    return {
+        text: draft.text ?? '',
+        files: pendingAttachmentsToFiles(draft.attachments ?? []),
+        voice: pendingAttachmentsToFiles(draft.voice ?? []),
+    };
+}

package/client/encode-composer-draft.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Encode composer fields into a serializable `UserTurnDraft` for pending intents.
+ */
+import type { UserTurnDraft } from '@theoremjs/agents/interface';
+export declare function encodeComposerDraft(args: {
+    text: string;
+    pendingFiles?: readonly File[];
+    pendingVoice?: readonly File[];
+}): Promise<UserTurnDraft>;

package/client/encode-composer-draft.js

@@ -0,0 +1,34 @@
+/**
+ * Encode composer fields into a serializable `UserTurnDraft` for pending intents.
+ */
+import { encodeFiles } from "./encode-files.js";
+export async function encodeComposerDraft(args) {
+    const text = args.text.trim();
+    const files = args.pendingFiles ?? [];
+    const voice = args.pendingVoice ?? [];
+    const encodedFiles = files.length ? await encodeFiles(files) : [];
+    const encodedVoice = voice.length ? await encodeFiles(voice) : [];
+    return {
+        ...(text ? { text } : {}),
+        ...(encodedFiles.length
+            ? {
+                attachments: encodedFiles.map((blob, index) => ({
+                    name: blob.name,
+                    mimeType: blob.mimeType,
+                    sizeBytes: files[index]?.size ?? 0,
+                    data: blob.data,
+                })),
+            }
+            : {}),
+        ...(encodedVoice.length
+            ? {
+                voice: encodedVoice.map((blob, index) => ({
+                    name: blob.name,
+                    mimeType: blob.mimeType,
+                    sizeBytes: voice[index]?.size ?? 0,
+                    data: blob.data,
+                })),
+            }
+            : {}),
+    };
+}

package/client/encode-files.d.ts

@@ -0,0 +1,18 @@
+import type { PendingAttachment, TranscriptBlock } from '@theoremjs/agents/interface';
+export declare function filesToPending(files: readonly File[]): PendingAttachment[];
+/**
+ * Rebuild `File`s from encoded pending attachments (stash / queue restore).
+ * Attachments without `data` cannot be restored and are skipped.
+ */
+export declare function pendingAttachmentsToFiles(attachments: readonly PendingAttachment[]): File[];
+export declare function encodeFiles(files: readonly File[]): Promise<Array<{
+    name: string;
+    mimeType: string;
+    data: string;
+}>>;
+/** Copy encoded base64 onto matching user attachment/voice transcript blocks for UI preview. */
+export declare function attachPreviewData(blocks: readonly TranscriptBlock[], attachments?: ReadonlyArray<{
+    data: string;
+}>, voice?: ReadonlyArray<{
+    data: string;
+}>): TranscriptBlock[];

package/client/encode-files.js

@@ -0,0 +1,54 @@
+import { base64ToBytes, bytesToBase64 } from '@theoremjs/agents/kernel';
+export function filesToPending(files) {
+    return files.map((file) => ({
+        name: file.name,
+        mimeType: file.type || 'application/octet-stream',
+        sizeBytes: file.size,
+    }));
+}
+/**
+ * Rebuild `File`s from encoded pending attachments (stash / queue restore).
+ * Attachments without `data` cannot be restored and are skipped.
+ */
+export function pendingAttachmentsToFiles(attachments) {
+    const files = [];
+    for (const attachment of attachments) {
+        if (typeof attachment.data !== 'string' || attachment.data.length === 0)
+            continue;
+        const bytes = base64ToBytes(attachment.data);
+        const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+        files.push(new File([buffer], attachment.name, {
+            type: attachment.mimeType || 'application/octet-stream',
+        }));
+    }
+    return files;
+}
+export async function encodeFiles(files) {
+    const out = [];
+    for (const file of files) {
+        out.push({
+            name: file.name,
+            mimeType: file.type || 'application/octet-stream',
+            data: bytesToBase64(new Uint8Array(await file.arrayBuffer())),
+        });
+    }
+    return out;
+}
+/** Copy encoded base64 onto matching user attachment/voice transcript blocks for UI preview. */
+export function attachPreviewData(blocks, attachments, voice) {
+    let attachmentIndex = 0;
+    let voiceIndex = 0;
+    return blocks.map((block) => {
+        if (block.kind === 'user-attachment') {
+            const data = attachments?.[attachmentIndex]?.data;
+            attachmentIndex += 1;
+            return data !== undefined ? { ...block, data } : block;
+        }
+        if (block.kind === 'user-voice') {
+            const data = voice?.[voiceIndex]?.data;
+            voiceIndex += 1;
+            return data !== undefined ? { ...block, data } : block;
+        }
+        return block;
+    });
+}

package/client/failure.d.ts

@@ -0,0 +1,32 @@
+/**
+ * One failure, two worlds, in the browser: the builder reads `errorKind` and
+ * `errorInternal`; the user reads `error`, the profile's wording for it.
+ *
+ * @module
+ */
+import { type ErrorKind, type LexiconOverrides } from '@theoremjs/agents';
+import type { AttachmentValidationIssue, InterfaceTurnSession } from '@theoremjs/agents/interface';
+export type ClientFailure = {
+    /** What the user reads: the host's wording, else the profile lexicon's for the failure. */
+    error: string;
+    errorKind: ErrorKind;
+    /** Raw detail for the builder; never shown to the user. */
+    errorInternal?: string;
+};
+/**
+ * Word a caught value for the user with the profile's `lexicon` (the interface's
+ * `lexicon`). A host-reported failure keeps the host's wording.
+ */
+export declare function clientFailure(err: unknown, lexicon?: LexiconOverrides): ClientFailure;
+/** A turn that did not run or did not finish. */
+export type TurnFailure = ClientFailure & {
+    ok: false;
+    /** The files the profile refused, one entry per reason (the kernel's check). */
+    issues?: AttachmentValidationIssue[];
+    /** The user stopped it; nothing to show. */
+    aborted?: boolean;
+    /** The conversation with what the turn got through before it stopped; the next turn resumes from it. */
+    session?: InterfaceTurnSession;
+};
+/** A caught value as a turn failure; an aborted `signal` marks it the user's stop. */
+export declare function turnFailure(err: unknown, lexicon?: LexiconOverrides, signal?: AbortSignal): TurnFailure;

package/client/failure.js

@@ -0,0 +1,34 @@
+/**
+ * One failure, two worlds, in the browser: the builder reads `errorKind` and
+ * `errorInternal`; the user reads `error`, the profile's wording for it.
+ *
+ * @module
+ */
+import { describeError, errorKind, lexiconText, publicError, } from '@theoremjs/agents';
+import { isTheoremStreamError } from "./transport.js";
+/**
+ * Word a caught value for the user with the profile's `lexicon` (the interface's
+ * `lexicon`). A host-reported failure keeps the host's wording.
+ */
+export function clientFailure(err, lexicon) {
+    if (isTheoremStreamError(err)) {
+        return {
+            error: err.publicMessage ?? lexiconText(`error.${err.kind}`, {}, lexicon),
+            errorKind: err.kind,
+            ...(err.internalMessage ? { errorInternal: err.internalMessage } : {}),
+        };
+    }
+    const error = publicError(err, lexicon);
+    const internal = describeError(err);
+    return {
+        error,
+        errorKind: errorKind(err),
+        ...(internal && internal !== error ? { errorInternal: internal } : {}),
+    };
+}
+/** A caught value as a turn failure; an aborted `signal` marks it the user's stop. */
+export function turnFailure(err, lexicon, signal) {
+    const failure = clientFailure(err, lexicon);
+    const aborted = failure.errorKind === 'cancelled' || signal?.aborted === true;
+    return { ok: false, ...failure, ...(aborted ? { aborted: true } : {}) };
+}

package/client/generation-selection.d.ts

@@ -0,0 +1,15 @@
+import { type ComposerProfileInterface } from '@theoremjs/agents/interface';
+/** A model and effort for the next turn. */
+export type GenerationSelection = {
+    model?: string;
+    effort?: string;
+};
+/** The profile's default model (its first, when it names none). */
+export declare function defaultModel(iface: ComposerProfileInterface): string | undefined;
+/**
+ * The selection for `iface`, given what was `selected` under the `previous` interface (none on
+ * first load). A pick that was on the previous default follows the new one, and a pick `iface` no
+ * longer has falls back to its default; any other pick is kept. Model and effort are each judged
+ * this way, the effort against its model's default, and a new model takes its own default effort.
+ */
+export declare function followGenerationDefaults(iface: ComposerProfileInterface, selected: GenerationSelection, previous: ComposerProfileInterface | undefined): GenerationSelection;

package/client/generation-selection.js

@@ -0,0 +1,24 @@
+import { defaultInterfaceEffort } from '@theoremjs/agents/interface';
+/** The profile's default model (its first, when it names none). */
+export function defaultModel(iface) {
+    return iface.defaultModel ?? Object.keys(iface.models)[0];
+}
+/**
+ * The selection for `iface`, given what was `selected` under the `previous` interface (none on
+ * first load). A pick that was on the previous default follows the new one, and a pick `iface` no
+ * longer has falls back to its default; any other pick is kept. Model and effort are each judged
+ * this way, the effort against its model's default, and a new model takes its own default effort.
+ */
+export function followGenerationDefaults(iface, selected, previous) {
+    const keepModel = selected.model !== undefined &&
+        Object.hasOwn(iface.models, selected.model) &&
+        (previous === undefined || selected.model !== defaultModel(previous));
+    const model = keepModel ? selected.model : defaultModel(iface);
+    const efforts = model === undefined ? undefined : iface.models[model]?.efforts;
+    const keepEffort = model === selected.model &&
+        selected.effort !== undefined &&
+        efforts !== undefined &&
+        Object.hasOwn(efforts, selected.effort) &&
+        (previous === undefined || selected.effort !== defaultInterfaceEffort(previous, model));
+    return { model, effort: keepEffort ? selected.effort : defaultInterfaceEffort(iface, model) };
+}

package/client/host-call.d.ts

@@ -0,0 +1,51 @@
+/**
+ * A host call's standing, read from its folded state: the phase it's in, and
+ * what to say when it failed.
+ *
+ * @module
+ */
+import type { TranscriptBlock } from '@theoremjs/agents/interface';
+import type { ClientFailure } from './failure.ts';
+import { type JsonSchema } from './schema-fields.ts';
+export type ToolCall = Extract<TranscriptBlock, {
+    kind: 'tool';
+}>['tool'];
+export type HostCallStatus = 'running' | 'gate' | 'complete' | 'error' | 'cancel';
+/** What a call's standing reads from. */
+export type HostCallState = {
+    call: ToolCall | null;
+    failure: ClientFailure | null;
+    isRunning: boolean;
+};
+/** The phase a call is in; a stream that broke is an error, one that stopped short a cancel. */
+export declare function hostCallStatus({ call, failure, isRunning }: HostCallState): HostCallStatus;
+/** Why a call failed, as a banner reads it: it never reached its tool, or the tool failed. */
+export declare function hostCallFailure({ call, failure }: HostCallState): {
+    title: string;
+    description?: string;
+} | null;
+/** What the console shows: the picked tool, its request text, its call on show, and the calls before it. */
+export type HostConsoleView<Tool, Call> = {
+    tool: Tool | undefined;
+    text: string;
+    shown: Call | null;
+    earlier: Call[];
+};
+/**
+ * The console's view of its state. An unknown pick falls back to the first
+ * tool; a tool's request is its draft, else a sample of its schema; the call on
+ * show is the one opened from history, else the tool's latest.
+ */
+export declare function hostConsoleView<Tool extends {
+    name: string;
+    inputSchema: JsonSchema;
+}, Call extends {
+    id: string;
+    name: string;
+}>(args: {
+    tools: readonly Tool[];
+    picked: string | undefined;
+    drafts: Readonly<Record<string, string>>;
+    calls: readonly Call[];
+    shownId: string | null;
+}): HostConsoleView<Tool, Call>;

package/client/host-call.js

@@ -0,0 +1,42 @@
+/**
+ * A host call's standing, read from its folded state: the phase it's in, and
+ * what to say when it failed.
+ *
+ * @module
+ */
+import { sampleFromSchema } from "./schema-fields.js";
+import { json } from "./shaped-data.js";
+const SETTLED = new Set(['gate', 'complete', 'error', 'cancel']);
+/** The phase a call is in; a stream that broke is an error, one that stopped short a cancel. */
+export function hostCallStatus({ call, failure, isRunning }) {
+    const phase = call?.state?.phase;
+    if (phase !== undefined && SETTLED.has(phase))
+        return phase;
+    if (failure)
+        return 'error';
+    return isRunning ? 'running' : 'cancel';
+}
+/** Why a call failed, as a banner reads it: it never reached its tool, or the tool failed. */
+export function hostCallFailure({ call, failure }) {
+    if (failure)
+        return { title: failure.error };
+    const state = call?.state;
+    if (state?.phase !== 'error')
+        return null;
+    const { error, message } = state.failure;
+    if (!error)
+        return { title: message };
+    return error === message ? { title: error } : { title: error, description: message };
+}
+/**
+ * The console's view of its state. An unknown pick falls back to the first
+ * tool; a tool's request is its draft, else a sample of its schema; the call on
+ * show is the one opened from history, else the tool's latest.
+ */
+export function hostConsoleView(args) {
+    const tool = args.tools.find((candidate) => candidate.name === args.picked) ?? args.tools[0];
+    const text = tool ? (args.drafts[tool.name] ?? json(sampleFromSchema(tool.inputSchema))) : '';
+    const ofTool = args.calls.filter((call) => call.name === tool?.name);
+    const shown = ofTool.find((call) => call.id === args.shownId) ?? ofTool[0] ?? null;
+    return { tool, text, shown, earlier: args.calls.filter((call) => call !== shown) };
+}

package/client/host-transport.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The browser side of a host profile: the tools the host lets the page call,
+ * each with the schemas its request and response are drawn from, and the calls
+ * themselves, streamed as the kernel runs them.
+ *
+ * @module
+ */
+import { type Profile, type ToolAccess, type ToolPermission, z } from '@theoremjs/agents';
+import type { TraceFeed } from './trace-feed.ts';
+import { type HttpOptions, type TheoremInvokeRequest, type TurnEventSink } from './transport.ts';
+/** How a tool reaches its work: a function on the host, an HTTP endpoint, or an MCP server. */
+export declare const HOST_TOOL_KINDS: readonly ["function", "http", "mcp"];
+export type HostToolKind = (typeof HOST_TOOL_KINDS)[number];
+/** One tool as the page sees it. Its endpoint, headers, and credentials stay on the host. */
+export type HostToolView = {
+    name: string;
+    description: string;
+    kind: HostToolKind;
+    access: ToolAccess;
+    permission: ToolPermission;
+    /** JSON Schema for the call's input: the form is drawn from it. */
+    inputSchema: Record<string, unknown>;
+    /** JSON Schema for the tool's output: the result is laid out from it. */
+    outputSchema: Record<string, unknown>;
+};
+/** What a host profile shows the page. */
+export type HostInterface = {
+    type: 'host';
+    id: string;
+    tools: HostToolView[];
+    observability?: {
+        record: boolean;
+    };
+};
+/** A tool as registered: the fields the page's view keeps. */
+export type HostToolSource = {
+    type: string;
+    name: string;
+    description: string;
+    access: ToolAccess;
+    permission: ToolPermission;
+    inputSchema: Record<string, unknown>;
+    outputSchema: Record<string, unknown>;
+};
+/** The page's view of a host profile: its allowed tools, in the order it allows them. */
+export declare function hostInterface(profile: Pick<Extract<Profile, {
+    type: 'host';
+}>, 'id' | 'tools' | 'observability'>, tools: (name: string) => HostToolSource | undefined): HostInterface;
+/** One call of one of the host's tools. */
+export type TheoremHostCallRequest = {
+    name: string;
+    input: unknown;
+};
+/** A `/call` body as `createTheoremHostHandler` reads it. */
+export declare const theoremHostCallRequestSchema: z.ZodType<TheoremHostCallRequest>;
+export interface HostTransport {
+    describe(signal?: AbortSignal): Promise<HostInterface>;
+    /** Runs one tool; its events stream to `onEvent`, ending in `done`. */
+    call(request: TheoremHostCallRequest, onEvent: TurnEventSink, signal?: AbortSignal): Promise<void>;
+    /** The user's answer to a call the host paused on a gate. */
+    invoke(request: TheoremInvokeRequest, onEvent: TurnEventSink, signal?: AbortSignal): Promise<void>;
+    /** Where the host's trace records land, for the inspector. */
+    traces?: TraceFeed;
+}
+/** Transport for a host mounted with `createTheoremHostHandler`. Default endpoint `/api/host`. */
+export declare function createHostTransport(options?: HttpOptions & {
+    endpoint?: string;
+}): HostTransport;

package/client/host-transport.js

@@ -0,0 +1,74 @@
+/**
+ * The browser side of a host profile: the tools the host lets the page call,
+ * each with the schemas its request and response are drawn from, and the calls
+ * themselves, streamed as the kernel runs them.
+ *
+ * @module
+ */
+import { resolveObservabilityPolicy, TOOL_ACCESS, TOOL_PERMISSION, TURN_EVENT_SCHEMAS, z, } from '@theoremjs/agents';
+import { fetchJson, postNdjson, } from "./transport.js";
+import { checkWire } from "./wire-line.js";
+/** How a tool reaches its work: a function on the host, an HTTP endpoint, or an MCP server. */
+export const HOST_TOOL_KINDS = ['function', 'http', 'mcp'];
+function isHostToolKind(type) {
+    return HOST_TOOL_KINDS.includes(type);
+}
+/** The page's view of a host profile: its allowed tools, in the order it allows them. */
+export function hostInterface(profile, tools) {
+    return {
+        type: 'host',
+        id: profile.id,
+        tools: profile.tools.allow.flatMap((name) => {
+            const tool = tools(name);
+            if (!tool || !isHostToolKind(tool.type))
+                return [];
+            return [
+                {
+                    name: tool.name,
+                    description: tool.description,
+                    kind: tool.type,
+                    access: tool.access,
+                    permission: tool.permission,
+                    inputSchema: tool.inputSchema,
+                    outputSchema: tool.outputSchema,
+                },
+            ];
+        }),
+        ...(profile.observability
+            ? { observability: { record: resolveObservabilityPolicy(profile.observability).record } }
+            : {}),
+    };
+}
+const theoremHostCallRequest = z.object({ name: z.string().min(1).max(128), input: z.unknown() });
+true;
+/** A `/call` body as `createTheoremHostHandler` reads it. */
+export const theoremHostCallRequestSchema = theoremHostCallRequest;
+const schemaObject = z.record(z.string(), z.unknown());
+const describedSchema = z.object({
+    interface: z.object({
+        type: z.literal('host'),
+        id: z.string(),
+        tools: z.array(z.object({
+            name: z.string(),
+            description: z.string(),
+            kind: z.enum(HOST_TOOL_KINDS),
+            access: z.enum(TOOL_ACCESS),
+            permission: z.enum(TOOL_PERMISSION),
+            inputSchema: schemaObject,
+            outputSchema: schemaObject,
+        })),
+        observability: z.object({ record: z.boolean() }).optional(),
+    }),
+});
+/** Transport for a host mounted with `createTheoremHostHandler`. Default endpoint `/api/host`. */
+export function createHostTransport(options = {}) {
+    const base = (options.endpoint ?? '/api/host').replace(/\/$/, '');
+    return {
+        async describe(signal) {
+            // lexicon-exempt: internal diagnostic; the user reads error.bad_response
+            return checkWire(describedSchema, await fetchJson(base, { signal }, options), 'the host description').interface;
+        },
+        call: (body, onEvent, signal) => postNdjson(`${base}/call`, body, TURN_EVENT_SCHEMAS, onEvent, { ...options, signal }),
+        invoke: ({ replay: _replay, ...body }, onEvent, signal) => postNdjson(`${base}/invoke`, body, TURN_EVENT_SCHEMAS, onEvent, { ...options, signal }),
+    };
+}

package/client/image-output.d.ts

@@ -0,0 +1,6 @@
+/** Display helpers for image-profile output. */
+/**
+ * Profile `image.aspectRatio` (`"16:9"`) as width / height, for Astryx
+ * `AspectRatio`. Undefined when unset or malformed — the provider picks.
+ */
+export declare function parseAspectRatio(value: string | undefined): number | undefined;

package/client/image-output.js

@@ -0,0 +1,13 @@
+/** Display helpers for image-profile output. */
+/**
+ * Profile `image.aspectRatio` (`"16:9"`) as width / height, for Astryx
+ * `AspectRatio`. Undefined when unset or malformed — the provider picks.
+ */
+export function parseAspectRatio(value) {
+    const match = value?.trim().match(/^(\d+(?:\.\d+)?)\s*:\s*(\d+(?:\.\d+)?)$/);
+    if (!match)
+        return undefined;
+    const width = Number(match[1]);
+    const height = Number(match[2]);
+    return width > 0 && height > 0 ? width / height : undefined;
+}

package/client/index.d.ts

@@ -0,0 +1,20 @@
+export { float32Rms, float32RmsToLevel, INPUT_LEVEL_GAIN, timeDomainBytesToLevel, } from './audio-level.ts';
+export { createDecisionTransport, type DecisionInterface, decisionInterface, type DecisionQuestionView, type DecisionReply, type DecisionTransport, readDecisionReply, } from './decision-transport.ts';
+export { filesToPending, pendingAttachmentsToFiles } from './encode-files.ts';
+export { createHostTransport, HOST_TOOL_KINDS, type HostInterface, hostInterface, type HostToolKind, type HostToolSource, type HostToolView, type HostTransport, type TheoremHostCallRequest, } from './host-transport.ts';
+export { layoutResult, type ResultChart, type ResultFigure, type ResultImage, type ResultLayout } from './tool-result.ts';
+export { type JsonSchema, sampleFromSchema, type SchemaControl, type SchemaField, schemaControl, schemaFields } from './schema-fields.ts';
+export { composerFieldsFromDraft, type ComposerDraftFields } from './decode-composer-draft.ts';
+export { encodeComposerDraft } from './encode-composer-draft.ts';
+export { type ClientFailure, clientFailure, type TurnFailure } from './failure.ts';
+export { type LiveConnectPhase, type LiveSessionStatus, type LiveState, liveState, } from './live/live-state.ts';
+export type { LiveToolGatePrompt } from './live/live-tool.ts';
+export { LiveSessionClient } from './live-client.ts';
+export { isOAuthComplete, notifyOAuthComplete } from './oauth-popup.ts';
+export { applyTurnResultToTranscript, resumeInterfaceTool, type StreamView, streamInterfaceDraftTurn, streamInterfaceTurn, } from './run-session.ts';
+export type { AnsweringGate, ToolDecisionAction, ToolGateResolution, } from './tool-resume.ts';
+export { continueGatedToolInvocation, } from './tool-resume.ts';
+export { citationsFromBlock, type SourceCitation, type SourceCitationBlock } from './source-citations.ts';
+export { createTraceFeed, type TraceFeed } from './trace-feed.ts';
+export { buildInvokeRequest, buildTurnRequest, turnInputFromSession, type WalkAway } from './turn-client.ts';
+export { type ClientTurnEvent, createHttpTransport, type HostErrorBody, type HttpOptions, type HttpTransportOptions, isTheoremStreamError, type MalformedEvent, postJson, postNdjson, readNdjsonStream, type TheoremInvokeRequest, type TheoremReplay, type TheoremSteerRequest, TheoremStreamError, type TheoremTransport, type TheoremTurnInput, type TheoremTurnRequest, type TurnEventSink, type UnsupportedEvent, type WireLines, } from './transport.ts';

package/client/index.js

@@ -0,0 +1,18 @@
+export { float32Rms, float32RmsToLevel, INPUT_LEVEL_GAIN, timeDomainBytesToLevel, } from "./audio-level.js";
+export { createDecisionTransport, decisionInterface, readDecisionReply, } from "./decision-transport.js";
+export { filesToPending, pendingAttachmentsToFiles } from "./encode-files.js";
+export { createHostTransport, HOST_TOOL_KINDS, hostInterface, } from "./host-transport.js";
+export { layoutResult } from "./tool-result.js";
+export { sampleFromSchema, schemaControl, schemaFields } from "./schema-fields.js";
+export { composerFieldsFromDraft } from "./decode-composer-draft.js";
+export { encodeComposerDraft } from "./encode-composer-draft.js";
+export { clientFailure } from "./failure.js";
+export { liveState, } from "./live/live-state.js";
+export { LiveSessionClient } from "./live-client.js";
+export { isOAuthComplete, notifyOAuthComplete } from "./oauth-popup.js";
+export { applyTurnResultToTranscript, resumeInterfaceTool, streamInterfaceDraftTurn, streamInterfaceTurn, } from "./run-session.js";
+export { continueGatedToolInvocation, } from "./tool-resume.js";
+export { citationsFromBlock } from "./source-citations.js";
+export { createTraceFeed } from "./trace-feed.js";
+export { buildInvokeRequest, buildTurnRequest, turnInputFromSession } from "./turn-client.js";
+export { createHttpTransport, isTheoremStreamError, postJson, postNdjson, readNdjsonStream, TheoremStreamError, } from "./transport.js";