@theoremjs/web 0.0.0-stage → 0.3.4-next.375.ga2d1878

package/client/embedding-transport.d.ts

@@ -0,0 +1,40 @@
+import { type EmbeddingInput, type EmbeddingProfile, type EmbeddingResult, type EmbeddingRules, type EmbeddingTask, type Protocol, type TraceRecord } from '@theoremjs/agents';
+import type { TraceFeed } from './trace-feed.ts';
+import { type HttpOptions } from './transport.ts';
+export type EmbeddingInterface = {
+    type: 'embedding';
+    identity: {
+        handle: string;
+    };
+    /** The profile's inputs held to what its default model takes. */
+    inputs: EmbeddingRules;
+    observability?: {
+        record: boolean;
+    };
+};
+/**
+ * The interface a client reads: the profile's inputs held to its default model's limits. Pass
+ * `protocols` when a model speaks a protocol of your own.
+ */
+export declare function embeddingInterface(profile: Pick<EmbeddingProfile, 'identity' | 'inputs' | 'observability' | 'models' | 'defaultModel'>, protocols?: readonly Protocol[]): EmbeddingInterface;
+export type EmbeddingReply = {
+    result: EmbeddingResult;
+    traces?: TraceRecord[];
+};
+/** What an embedding asks beyond its inputs: a named model, and what the inputs are for. */
+export type EmbedOptions = {
+    model?: string;
+    task?: EmbeddingTask;
+};
+export interface EmbeddingTransport {
+    describe(signal?: AbortSignal): Promise<EmbeddingInterface>;
+    embed(input: EmbeddingInput | readonly EmbeddingInput[], options?: EmbedOptions, signal?: AbortSignal): Promise<EmbeddingReply>;
+    traces?: TraceFeed;
+}
+export declare function readEmbeddingReply(raw: unknown): EmbeddingReply;
+/** POSTs an embedding and reads its reply; a failure keeps the trace records its body carried. */
+export declare function postEmbedding(url: string, body: unknown, signal: AbortSignal | undefined, options?: HttpOptions): Promise<EmbeddingReply>;
+/** Transport for a host mounted with `createTheoremEmbeddingHandler`. Default endpoint `/api/embedding`. */
+export declare function createEmbeddingTransport(options?: HttpOptions & {
+    endpoint?: string;
+}): EmbeddingTransport;

package/client/embedding-transport.js

@@ -0,0 +1,71 @@
+import { embeddingModelLimits, embeddingRules, resolveObservabilityPolicy, traceRecordSchema, z, } from '@theoremjs/agents';
+import { postWithTraces } from "./decision-transport.js";
+import { fetchJson } from "./transport.js";
+import { checkWire } from "./wire-line.js";
+/**
+ * The interface a client reads: the profile's inputs held to its default model's limits. Pass
+ * `protocols` when a model speaks a protocol of your own.
+ */
+export function embeddingInterface(profile, protocols = []) {
+    const binding = profile.models[profile.defaultModel];
+    return {
+        type: 'embedding',
+        identity: { handle: profile.identity.handle },
+        inputs: embeddingRules(profile.inputs, binding ? embeddingModelLimits(binding, protocols) : undefined),
+        ...(profile.observability
+            ? { observability: { record: resolveObservabilityPolicy(profile.observability).record } }
+            : {}),
+    };
+}
+const embeddingReplySchema = z.object({
+    result: z.object({
+        model: z.string().min(1),
+        embeddings: z.array(z
+            .object({
+            index: z.number().int().nonnegative(),
+            values: z.array(z.number()),
+            dimensions: z.number().int().positive(),
+        })
+            .refine((embedding) => embedding.values.length === embedding.dimensions, 'vector length must match dimensions')),
+        usage: z
+            .object({
+            inputTokens: z.number().int().nonnegative().optional(),
+            costUsd: z.number().nonnegative().optional(),
+            estimated: z.literal(true).optional(),
+        })
+            .optional(),
+    }),
+    traces: z.array(traceRecordSchema).optional(),
+});
+const describedSchema = z.object({
+    interface: z.object({
+        type: z.literal('embedding'),
+        identity: z.object({ handle: z.string() }),
+        inputs: z.object({
+            text: z.boolean(),
+            attachments: z.object({ accept: z.array(z.string()) }).optional(),
+            maxFiles: z.number().optional(),
+            maxBytes: z.number().optional(),
+            maxTurnBytes: z.number().optional(),
+            limitsByMime: z.record(z.string(), z.number()).optional(),
+        }),
+        observability: z.object({ record: z.boolean() }).optional(),
+    }),
+});
+export function readEmbeddingReply(raw) {
+    return checkWire(embeddingReplySchema, raw, 'the embedding');
+}
+/** POSTs an embedding and reads its reply; a failure keeps the trace records its body carried. */
+export function postEmbedding(url, body, signal, options = {}) {
+    return postWithTraces(url, body, signal, options, readEmbeddingReply);
+}
+/** Transport for a host mounted with `createTheoremEmbeddingHandler`. Default endpoint `/api/embedding`. */
+export function createEmbeddingTransport(options = {}) {
+    const base = (options.endpoint ?? '/api/embedding').replace(/\/$/, '');
+    return {
+        async describe(signal) {
+            return checkWire(describedSchema, await fetchJson(base, { signal }, options), 'the embedding description').interface;
+        },
+        embed: (input, embed, signal) => postEmbedding(`${base}/embed`, { input, ...embed }, signal, options),
+    };
+}

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,29 @@
+/**
+ * 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 LabelOverrides } from '@theoremjs/agents';
+import type { AttachmentValidationIssue } from '@theoremjs/agents/interface';
+export type ClientFailure = {
+    /** What the user reads: the host's wording, else the profile labels' 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 `labels` (the interface's
+ * `labels`). A host-reported failure keeps the host's wording.
+ */
+export declare function clientFailure(err: unknown, labels?: LabelOverrides): ClientFailure;
+/** A turn that did not run or did not finish. */
+export type TurnFailure = ClientFailure & {
+    /** The files the profile refused, one entry per reason (the kernel's check). */
+    issues?: AttachmentValidationIssue[];
+    /** The user stopped it; nothing to show. */
+    aborted?: boolean;
+};
+/** A caught value as a turn failure; an aborted `signal` marks it the user's stop. */
+export declare function turnFailure(err: unknown, labels?: LabelOverrides, 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, labelText, publicError, } from '@theoremjs/agents';
+import { isTheoremStreamError } from "./transport.js";
+/**
+ * Word a caught value for the user with the profile's `labels` (the interface's
+ * `labels`). A host-reported failure keeps the host's wording.
+ */
+export function clientFailure(err, labels) {
+    if (isTheoremStreamError(err)) {
+        return {
+            error: err.publicMessage ?? labelText(`error.${err.kind}`, {}, labels),
+            errorKind: err.kind,
+            ...(err.internalMessage ? { errorInternal: err.internalMessage } : {}),
+        };
+    }
+    const error = publicError(err, labels);
+    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, labels, signal) {
+    const failure = clientFailure(err, labels);
+    const aborted = failure.errorKind === 'cancelled' || signal?.aborted === true;
+    return { ...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-transport.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 { PageDispatchResult } from './page-dispatch.ts';
+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 {
+    pageResult?(result: PageDispatchResult, signal?: AbortSignal): Promise<void>;
+    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,75 @@
+/**
+ * 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, postJson, 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 {
+        pageResult: (body, signal) => postJson(`${base}/page-result`, body, { ...options, signal }),
+        async describe(signal) {
+            // labels-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/index.d.ts

@@ -0,0 +1,37 @@
+export { float32Rms, float32RmsToLevel, INPUT_LEVEL_GAIN, timeDomainBytesToLevel, } from './audio-level.ts';
+export { type ChatController, type ChatOptions, type ChatSlots, type ChatState, type ChatUpdate, createChatController, type MessageDelivery, type SentTurn, } from './chat.ts';
+export { type ComposerDrawerKind, type ComposerDrawerSummary, composerDrawerSummary, } from './composer-drawer.ts';
+export { type ComposerHint, isStashShortcut, resolveComposerHint, STASH_SHORTCUT, } from './composer-hints.ts';
+export { type ComposerActionState, composerActionState, composerHasPayload, } from './composer-primary.ts';
+export { createDecisionTransport, type DecisionInterface, type DecisionQuestionView, type DecisionReply, type DecisionTransport, decisionAssets, decisionInterface, failedDecisionTraces, failedTraces, postDecision, readDecisionReply, withFailedTraces, } from './decision-transport.ts';
+export { type ComposerDraftFields, composerFieldsFromDraft } from './decode-composer-draft.ts';
+export { addUsage, checkEmbeddingInputs, checkInputs, cosineSimilarity, type EmbeddingFields, type EmbeddingInputCheck, type EmbeddingMatch, type EmbeddingMediaPart, type EmbeddingSplit, embeddingBatches, fieldsInput, inputFields, MAX_BATCH_INPUTS, rankMatches, readEmbeddingInput, readEmbeddingInputs, readsAsText, splitText, } from './embedding-input.ts';
+export { type EmbeddingSpace, layoutSpace, layoutSpaceSoon, outlierThreshold, placeQuery, type SpaceCluster, type SpaceDocument, type SpaceLink, type SpacePoint, } from './embedding-space.ts';
+export { createEmbeddingTransport, type EmbeddingInterface, type EmbeddingReply, type EmbeddingTransport, type EmbedOptions, embeddingInterface, postEmbedding, readEmbeddingReply, } from './embedding-transport.ts';
+export { encodeComposerDraft } from './encode-composer-draft.ts';
+export { encodeFiles, filesToPending, pendingAttachmentsToFiles } from './encode-files.ts';
+export { type ClientFailure, clientFailure, type TurnFailure, turnFailure } from './failure.ts';
+export { followGenerationDefaults } from './generation-selection.ts';
+export { createHostTransport, HOST_TOOL_KINDS, type HostInterface, type HostToolKind, type HostToolSource, type HostToolView, type HostTransport, hostInterface, type TheoremHostCallRequest, } from './host-transport.ts';
+export type { LiveCallOptions, PageTool, PageToolAnswer, PageTools, } from './live/live-page-tool.ts';
+export { pageToolMismatch, warnPageToolMismatch } from './live/live-page-tool.ts';
+export { type LiveConnectPhase, type LiveSessionStatus, type LiveState, liveState, } from './live/live-state.ts';
+export type { LiveGateAnswer, LiveToolGatePrompt } from './live/live-tool.ts';
+export type { LiveConnection } from './live-client.ts';
+export { LiveSessionClient } from './live-client.ts';
+export type { ExecuteToolOnRelay, LiveSocket } from './live-messages.ts';
+export { isOAuthComplete, notifyOAuthComplete } from './oauth-popup.ts';
+export { type PageDispatchResult, withPageToolDispatch } from './page-dispatch.ts';
+export { sessionAfter, stampWorked } from './run-commit.ts';
+export { keepsConversation, type RunOutcome, resumeInterfaceTool, type StreamView, streamInterfaceDraftTurn, streamInterfaceTurn, } from './run-session.ts';
+export { blankRow, type JsonSchema, missingFields, type SchemaControl, type SchemaField, sampleFromSchema, schemaControl, schemaFields, withField, } from './schema-fields.ts';
+export { fieldLabel, fieldReading, humanize, isPlain, isProse, isRow, json, type ListRow, MAX_ROWS, type PlainReading, plainReading, type Row, rowHeading, type Section, type Shape, shapeOf, splitFields, unpacked, withUnit, } from './shaped-data.ts';
+export { citationsFromBlock, type SourceCitation, type SourceCitationBlock, } from './source-citations.ts';
+export type { QueryMatch } from './space-geometry.ts';
+export { DOT_FLOATS, FRAME_SLOT, queryGeometry, SEGMENT_FLOATS, type SpaceGeometry, spaceGeometry, } from './space-geometry.ts';
+export { hasLead, layoutResult, type ResultChart, type ResultFigure, type ResultImage, type ResultLayout, type ResultMedia, returnedMedia, timeFormats, } from './tool-result.ts';
+export type { AnsweringGate, ToolDecisionAction, ToolGateResolution, } from './tool-resume.ts';
+export { continueGatedToolInvocation, type PersonGateResolution } from './tool-resume.ts';
+export { createTraceFeed, type TraceFeed } from './trace-feed.ts';
+export { CHAT_LINES, type ChatLine, type ChatLineSink, type ClientTurnEvent, type ConversationLine, type ConversationView, createHttpTransport, fetchConversation, fetchRewound, type HostErrorBody, type HttpOptions, type HttpTransportOptions, hostError, isTheoremStreamError, type MalformedEvent, postJson, postNdjson, readNdjsonStream, type TheoremConversationRequest, type TheoremInvokeRequest, type TheoremReplay, type TheoremRewindRequest, type TheoremRewound, type TheoremSteerRequest, TheoremStreamError, type TheoremTransport, type TheoremTurnInput, type TheoremTurnRequest, type TurnEventSink, type UnsupportedEvent, type WireLines, } from './transport.ts';
+export { buildInvokeRequest, buildTurnRequest, foldAssistantTurn, issuedOperationId, type RunScope, type WalkAway, } from './turn-client.ts';

package/client/index.js

@@ -0,0 +1,31 @@
+export { float32Rms, float32RmsToLevel, INPUT_LEVEL_GAIN, timeDomainBytesToLevel, } from "./audio-level.js";
+export { createChatController, } from "./chat.js";
+export { composerDrawerSummary, } from "./composer-drawer.js";
+export { isStashShortcut, resolveComposerHint, STASH_SHORTCUT, } from "./composer-hints.js";
+export { composerActionState, composerHasPayload, } from "./composer-primary.js";
+export { createDecisionTransport, decisionAssets, decisionInterface, failedDecisionTraces, failedTraces, postDecision, readDecisionReply, withFailedTraces, } from "./decision-transport.js";
+export { composerFieldsFromDraft } from "./decode-composer-draft.js";
+export { addUsage, checkEmbeddingInputs, checkInputs, cosineSimilarity, embeddingBatches, fieldsInput, inputFields, MAX_BATCH_INPUTS, rankMatches, readEmbeddingInput, readEmbeddingInputs, readsAsText, splitText, } from "./embedding-input.js";
+export { layoutSpace, layoutSpaceSoon, outlierThreshold, placeQuery, } from "./embedding-space.js";
+export { createEmbeddingTransport, embeddingInterface, postEmbedding, readEmbeddingReply, } from "./embedding-transport.js";
+export { encodeComposerDraft } from "./encode-composer-draft.js";
+export { encodeFiles, filesToPending, pendingAttachmentsToFiles } from "./encode-files.js";
+export { clientFailure, turnFailure } from "./failure.js";
+export { followGenerationDefaults } from "./generation-selection.js";
+export { createHostTransport, HOST_TOOL_KINDS, hostInterface, } from "./host-transport.js";
+export { pageToolMismatch, warnPageToolMismatch } from "./live/live-page-tool.js";
+export { liveState, } from "./live/live-state.js";
+export { LiveSessionClient } from "./live-client.js";
+export { isOAuthComplete, notifyOAuthComplete } from "./oauth-popup.js";
+export { withPageToolDispatch } from "./page-dispatch.js";
+export { sessionAfter, stampWorked } from "./run-commit.js";
+export { keepsConversation, resumeInterfaceTool, streamInterfaceDraftTurn, streamInterfaceTurn, } from "./run-session.js";
+export { blankRow, missingFields, sampleFromSchema, schemaControl, schemaFields, withField, } from "./schema-fields.js";
+export { fieldLabel, fieldReading, humanize, isPlain, isProse, isRow, json, MAX_ROWS, plainReading, rowHeading, shapeOf, splitFields, unpacked, withUnit, } from "./shaped-data.js";
+export { citationsFromBlock, } from "./source-citations.js";
+export { DOT_FLOATS, FRAME_SLOT, queryGeometry, SEGMENT_FLOATS, spaceGeometry, } from "./space-geometry.js";
+export { hasLead, layoutResult, returnedMedia, timeFormats, } from "./tool-result.js";
+export { continueGatedToolInvocation } from "./tool-resume.js";
+export { createTraceFeed } from "./trace-feed.js";
+export { CHAT_LINES, createHttpTransport, fetchConversation, fetchRewound, hostError, isTheoremStreamError, postJson, postNdjson, readNdjsonStream, TheoremStreamError, } from "./transport.js";
+export { buildInvokeRequest, buildTurnRequest, foldAssistantTurn, issuedOperationId, } from "./turn-client.js";

package/client/live/live-mic-forward.d.ts

@@ -0,0 +1,30 @@
+import type { ToolCallEvent, TurnEventOf } from '@theoremjs/agents';
+/** Whether a mic frame should be sent upstream given mute / socket / barge-in gates. */
+export declare function shouldForwardMicFrame(args: {
+    isMuted: boolean;
+    socketOpen: boolean;
+    modelPlaying: boolean;
+    rms: number;
+    bargeInRmsWhileSpeaking: number;
+}): boolean;
+/** Classify live evidence transcription into a UI transcript callback payload. */
+export declare function liveTranscriptFromEvidence(event: TurnEventOf<'evidence'>): {
+    text: string;
+    isUser: boolean;
+    interim: boolean;
+} | null;
+export type LiveToolCallDraft = {
+    operationId?: string;
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+};
+/**
+ * Fold a tool turn event into cancelled-id / runnable-call lists. The model's
+ * call is runnable; a failure in the same batch (a name or arguments the
+ * provider could not use) is not: the session answered the model with it.
+ */
+export declare function applyLiveToolTurnEvent(tool: ToolCallEvent, accum: {
+    cancelledToolIds: Set<string>;
+    toolCalls: LiveToolCallDraft[];
+}): void;

package/client/live/live-mic-forward.js

@@ -0,0 +1,46 @@
+/** Whether a mic frame should be sent upstream given mute / socket / barge-in gates. */
+export function shouldForwardMicFrame(args) {
+    if (args.isMuted || !args.socketOpen)
+        return false;
+    if (args.modelPlaying && args.rms < args.bargeInRmsWhileSpeaking)
+        return false;
+    return true;
+}
+/** Classify live evidence transcription into a UI transcript callback payload. */
+export function liveTranscriptFromEvidence(event) {
+    const { evidence, text } = event;
+    if (!text)
+        return null;
+    if (evidence.kind !== 'input_transcription' && evidence.kind !== 'output_transcription')
+        return null;
+    return {
+        text,
+        isUser: evidence.kind === 'input_transcription',
+        interim: evidence.interim === true,
+    };
+}
+/**
+ * Fold a tool turn event into cancelled-id / runnable-call lists. The model's
+ * call is runnable; a failure in the same batch (a name or arguments the
+ * provider could not use) is not: the session answered the model with it.
+ */
+export function applyLiveToolTurnEvent(tool, accum) {
+    if (tool.phase === undefined) {
+        accum.toolCalls.push({
+            id: tool.callId,
+            name: tool.name,
+            arguments: tool.arguments,
+            ...(tool.operationId ? { operationId: tool.operationId } : {}),
+        });
+        return;
+    }
+    if (tool.phase === 'cancel') {
+        accum.cancelledToolIds.add(tool.callId);
+        return;
+    }
+    if (tool.phase !== 'error')
+        return;
+    const failed = accum.toolCalls.findIndex((draft) => draft.id === tool.callId);
+    if (failed !== -1)
+        accum.toolCalls.splice(failed, 1);
+}