theorum 1.0.0 → 1.1.3

package/esm/src/interface/blocks.js

@@ -1,180 +0,0 @@
-/**
- * Turn event folding — map kernel `TurnEvent` streams to transcript blocks.
- *
- * @module
- */
-let blockCounter = 0;
-function nextBlockId(prefix) {
-    blockCounter += 1;
-    return `${prefix}-${String(blockCounter)}`;
-}
-function resetBlockIds() {
-    blockCounter = 0;
-}
-function isAppendableTextBlock(block, kind) {
-    return block?.kind === kind;
-}
-function toolKey(event, index) {
-    const tool = event.tool;
-    if (!tool)
-        return `tool-${String(index)}`;
-    return tool.callId ?? tool.id ?? `${tool.name}-${String(index)}`;
-}
-function appendText(blocks, kind, text, idPrefix) {
-    const last = blocks.at(-1);
-    if (isAppendableTextBlock(last, kind)) {
-        last.text += text;
-        return;
-    }
-    blocks.push({
-        id: nextBlockId(idPrefix),
-        kind,
-        text,
-    });
-}
-function upsertToolBlock(blocks, event, key) {
-    const tool = event.tool;
-    if (!tool)
-        return;
-    const existing = blocks.find((block) => block.kind === 'tool' && block.id === `tool-${key}`);
-    const payload = { ...tool, id: tool.id ?? tool.callId };
-    if (existing && existing.kind === 'tool') {
-        existing.tool = { ...existing.tool, ...payload };
-        return;
-    }
-    blocks.push({
-        id: `tool-${key}`,
-        kind: 'tool',
-        tool: payload,
-    });
-}
-/** Build transcript blocks for a user-authored turn. */
-function buildUserTurnBlocks(draft, idPrefix = 'user') {
-    resetBlockIds();
-    const blocks = [];
-    const text = draft.text?.trim();
-    if (text) {
-        blocks.push({
-            id: nextBlockId(idPrefix),
-            kind: 'user-text',
-            text,
-        });
-    }
-    for (const file of draft.attachments ?? []) {
-        blocks.push({
-            id: nextBlockId(idPrefix),
-            kind: 'user-attachment',
-            name: file.name,
-            mimeType: file.mimeType,
-            sizeBytes: file.sizeBytes,
-        });
-    }
-    for (const file of draft.voice ?? []) {
-        blocks.push({
-            id: nextBlockId(idPrefix),
-            kind: 'user-voice',
-            name: file.name,
-            mimeType: file.mimeType,
-            sizeBytes: file.sizeBytes,
-        });
-    }
-    return blocks;
-}
-/**
- * Fold a single assistant turn's `TurnEvent` stream into ordered transcript blocks.
- *
- * Merges consecutive `text` and `thought` deltas, upserts tool calls by id, and
- * skips kernel bookkeeping events (`tokens`, `session`) unless folded into `turn-done`.
- */
-function foldTurnEvents(events, options = {}) {
-    const idPrefix = options.idPrefix ?? 'turn';
-    const showThoughts = options.showThoughts ?? true;
-    resetBlockIds();
-    const blocks = [];
-    let toolIndex = 0;
-    for (const event of events) {
-        switch (event.type) {
-            case 'thought':
-                if (showThoughts && event.text) {
-                    appendText(blocks, 'thought', event.text, idPrefix);
-                }
-                break;
-            case 'text':
-                if (event.text) {
-                    appendText(blocks, 'text', event.text, idPrefix);
-                }
-                break;
-            case 'tool': {
-                const key = toolKey(event, toolIndex);
-                toolIndex += 1;
-                upsertToolBlock(blocks, event, key);
-                break;
-            }
-            case 'structured':
-                blocks.push({
-                    id: nextBlockId(idPrefix),
-                    kind: 'structured',
-                    value: event.structured,
-                });
-                break;
-            case 'media':
-                if (event.media) {
-                    blocks.push({
-                        id: nextBlockId(idPrefix),
-                        kind: 'media',
-                        mimeType: event.media.mimeType,
-                        data: event.media.data,
-                    });
-                }
-                break;
-            case 'grounding':
-                if (event.grounding) {
-                    blocks.push({
-                        id: nextBlockId(idPrefix),
-                        kind: 'grounding',
-                        grounding: event.grounding,
-                    });
-                }
-                break;
-            case 'evidence':
-                if (event.evidence) {
-                    blocks.push({
-                        id: nextBlockId(idPrefix),
-                        kind: 'evidence',
-                        evidence: event.evidence,
-                    });
-                }
-                break;
-            case 'error':
-                if (event.error) {
-                    blocks.push({
-                        id: nextBlockId(idPrefix),
-                        kind: 'error',
-                        message: event.error,
-                    });
-                }
-                break;
-            case 'done':
-                blocks.push({
-                    id: nextBlockId(idPrefix),
-                    kind: 'turn-done',
-                    stop: event.stop,
-                    tokens: event.tokens,
-                    interactionId: event.interactionId,
-                    compaction: event.compaction !== undefined,
-                });
-                break;
-            case 'tokens':
-            case 'session':
-                break;
-            default:
-                break;
-        }
-    }
-    return blocks;
-}
-/** User draft blocks followed by folded assistant turn events. */
-function foldConversationTurn(draft, assistantEvents, options = {}) {
-    return [...buildUserTurnBlocks(draft, 'user'), ...foldTurnEvents(assistantEvents, options)];
-}
-export { buildUserTurnBlocks, foldConversationTurn, foldTurnEvents, resetBlockIds };

package/esm/src/interface/from-profile.d.ts

@@ -1,14 +0,0 @@
-/**
- * Profile → `ProfileInterface` projection.
- *
- * Kernel `projectProfileObject` is the single inspection projection; this module
- * only enriches `inputs` (acceptAttr) and attaches serializable guardrails.
- *
- * @module
- */
-import type { Profile, ProjectedProfile } from '../kernel/types.js';
-import type { ProfileInterface, ProfileInterfaceSource } from './types.js';
-declare function interfaceFrom(source: ProfileInterfaceSource): ProfileInterface;
-declare function interfaceFromProfile(profile: Profile): ProfileInterface;
-declare function interfaceFromProjected(projected: ProjectedProfile): ProfileInterface;
-export { interfaceFrom, interfaceFromProfile, interfaceFromProjected };

package/esm/src/interface/from-profile.js

@@ -1,104 +0,0 @@
-/**
- * Profile → `ProfileInterface` projection.
- *
- * Kernel `projectProfileObject` is the single inspection projection; this module
- * only enriches `inputs` (acceptAttr) and attaches serializable guardrails.
- *
- * @module
- */
-import { projectProfileObject } from '../kernel/registry/resolve.js';
-import { inputsFromSpec } from './inputs.js';
-function guardrailsView(guardrails) {
-    if (!guardrails)
-        return undefined;
-    return {
-        quota: guardrails.quota,
-        canary: guardrails.canary,
-        sanitizeInput: guardrails.sanitizeInput,
-        redactSensitive: guardrails.redactSensitive,
-        hasEgress: Boolean(guardrails.egress),
-    };
-}
-function normalizeModel(model) {
-    return {
-        ...model,
-        select: model.select ?? null,
-        controls: model.controls ?? [],
-    };
-}
-function toolsResolved(projected, profile) {
-    if (projected.type === 'speech') {
-        return { allow: [], resolved: [] };
-    }
-    if (profile && profile.type !== 'speech') {
-        return {
-            allow: profile.tools.allow,
-            t2Loader: profile.tools.t2Loader,
-            resolved: projected.tools,
-        };
-    }
-    const allow = projected.tools
-        .filter((tool) => !('type' in tool && tool.type === 'builtin'))
-        .map((tool) => tool.name);
-    return { allow, resolved: projected.tools };
-}
-function enrich(projected, profile) {
-    const inputs = inputsFromSpec(projected.type, projected.inputs);
-    const identity = profile?.identity ?? { handle: projected.handle };
-    const model = normalizeModel(projected.model);
-    const guardrails = profile ? guardrailsView(profile.guardrails) : undefined;
-    const outputs = projected.outputs ?? undefined;
-    const shared = { id: projected.id, identity, model, outputs, guardrails };
-    switch (projected.type) {
-        case 'text':
-            return {
-                ...shared,
-                type: 'text',
-                inputs,
-                tools: toolsResolved(projected, profile),
-                turnResumption: profile?.type === 'text' ? profile.turnResumption : undefined,
-            };
-        case 'image':
-            return {
-                ...shared,
-                type: 'image',
-                image: projected.image ?? {},
-                inputs,
-                tools: toolsResolved(projected, profile),
-                turnResumption: profile?.type === 'image' ? profile.turnResumption : undefined,
-            };
-        case 'speech':
-            return {
-                ...shared,
-                type: 'speech',
-                speech: projected.speech ?? {},
-                inputs,
-                turnResumption: profile?.type === 'speech' ? profile.turnResumption : undefined,
-            };
-        case 'live':
-            return {
-                ...shared,
-                type: 'live',
-                live: projected.live ?? {},
-                inputs,
-                tools: toolsResolved(projected, profile),
-            };
-        default: {
-            const exhaustive = projected.type;
-            return exhaustive;
-        }
-    }
-}
-function interfaceFrom(source) {
-    if ('identity' in source) {
-        return enrich(projectProfileObject(source), source);
-    }
-    return enrich(source);
-}
-function interfaceFromProfile(profile) {
-    return interfaceFrom(profile);
-}
-function interfaceFromProjected(projected) {
-    return interfaceFrom(projected);
-}
-export { interfaceFrom, interfaceFromProfile, interfaceFromProjected };

package/esm/src/interface/inputs.d.ts

@@ -1,8 +0,0 @@
-import type { ProfileInputsSpec, ProfileType } from '../kernel/types.js';
-import type { AttachmentValidationResult, ProfileInputsInterface, UserTurnDraft } from './types.js';
-declare function attachmentAcceptAttr(accept: string[]): string;
-declare function inputsFromSpec(type: ProfileType, inputs: ProfileInputsSpec | null | undefined): ProfileInputsInterface;
-/** Validate staged files against resolved profile `inputs`. */
-declare function validateProfileInputs(inputs: ProfileInputsInterface, draft: Pick<UserTurnDraft, 'attachments' | 'voice'>): AttachmentValidationResult;
-declare function pickMediaRecorderMime(accept?: string[]): string | undefined;
-export { attachmentAcceptAttr, inputsFromSpec, pickMediaRecorderMime, validateProfileInputs };

package/esm/src/interface/inputs.js

@@ -1,127 +0,0 @@
-/**
- * Profile `inputs` → UI affordances and validation.
- *
- * @module
- */
-import * as dntShim from "../../_dnt.shims.js";
-import { fileTooLargeMessage, maxBytesForMime, resolveMediaLimits, tooManyFilesMessage, turnTooLargeMessage, } from '../kernel/registry/attachments.js';
-import { mimeAllowed } from '../kernel/registry/catalog.js';
-const RECORDER_CANDIDATES = [
-    'audio/webm;codecs=opus',
-    'audio/webm',
-    'audio/mp4',
-    'audio/wav',
-    'audio/mpeg',
-];
-function attachmentAcceptAttr(accept) {
-    return accept.join(',');
-}
-function inputsFromSpec(type, inputs) {
-    if (type === 'speech') {
-        return { text: true, attachments: null, voice: null };
-    }
-    const accept = inputs?.attachments?.accept;
-    const voiceAccept = inputs?.voice?.accept;
-    return {
-        text: inputs?.text !== false,
-        attachments: accept?.length ? { accept, acceptAttr: attachmentAcceptAttr(accept) } : null,
-        voice: voiceAccept?.length ? { accept: voiceAccept } : null,
-        maxFiles: inputs?.maxFiles,
-        maxBytes: inputs?.maxBytes,
-        maxTurnBytes: inputs?.maxTurnBytes,
-        limitsByMime: inputs?.limitsByMime,
-        slots: inputs?.slots,
-    };
-}
-function toProfileInputsSpec(inputs) {
-    return {
-        text: inputs.text,
-        attachments: inputs.attachments ? { accept: inputs.attachments.accept } : undefined,
-        voice: inputs.voice ? { accept: inputs.voice.accept } : undefined,
-        maxFiles: inputs.maxFiles,
-        maxBytes: inputs.maxBytes,
-        maxTurnBytes: inputs.maxTurnBytes,
-        limitsByMime: inputs.limitsByMime,
-        slots: inputs.slots,
-    };
-}
-function issue(code, message, fileName) {
-    return { code, message, fileName };
-}
-function validateMime(accept, files, channelLabel) {
-    const issues = [];
-    for (const file of files) {
-        if (!mimeAllowed(accept, file.mimeType)) {
-            issues.push(issue('mime_not_allowed', `${file.name}: MIME '${file.mimeType}' is not accepted for ${channelLabel} input.`, file.name));
-        }
-    }
-    return issues;
-}
-function validateLimits(files, limits) {
-    const issues = [];
-    if (files.length > limits.maxFiles) {
-        issues.push(issue('too_many_files', tooManyFilesMessage(limits.maxFiles)));
-        return issues;
-    }
-    let total = 0;
-    for (const file of files) {
-        const maxAllowed = maxBytesForMime(file.mimeType, limits);
-        if (file.sizeBytes > maxAllowed) {
-            issues.push(issue('file_too_large', fileTooLargeMessage(maxAllowed), file.name));
-        }
-        total += file.sizeBytes;
-    }
-    if (total > limits.maxTurnBytes) {
-        issues.push(issue('turn_too_large', turnTooLargeMessage(limits.maxTurnBytes)));
-    }
-    return issues;
-}
-/** Validate staged files against resolved profile `inputs`. */
-function validateProfileInputs(inputs, draft) {
-    const attachments = draft.attachments ?? [];
-    const voice = draft.voice ?? [];
-    if (attachments.length === 0 && voice.length === 0) {
-        return { ok: true, issues: [] };
-    }
-    if (attachments.length > 0 && !inputs.attachments) {
-        return {
-            ok: false,
-            issues: [issue('mime_not_allowed', 'This profile does not accept file attachments.')],
-        };
-    }
-    if (voice.length > 0 && !inputs.voice) {
-        return {
-            ok: false,
-            issues: [issue('mime_not_allowed', 'This profile does not accept voice input.')],
-        };
-    }
-    const spec = toProfileInputsSpec(inputs);
-    const issues = [];
-    if (attachments.length > 0 && inputs.attachments) {
-        issues.push(...validateMime(inputs.attachments.accept, attachments, 'attachment'));
-    }
-    if (voice.length > 0 && inputs.voice) {
-        issues.push(...validateMime(inputs.voice.accept, voice, 'voice'));
-    }
-    const limits = resolveMediaLimits(spec);
-    if (!limits) {
-        issues.push(issue('limits_unconfigured', 'This profile accepts media but does not define maxFiles, maxBytes, and maxTurnBytes.'));
-        return { ok: false, issues };
-    }
-    issues.push(...validateLimits([...attachments, ...voice], limits));
-    return { ok: issues.length === 0, issues };
-}
-function pickMediaRecorderMime(accept) {
-    const supported = (mime) => {
-        const recorder = dntShim.dntGlobalThis
-            .MediaRecorder;
-        return recorder === undefined || recorder.isTypeSupported(mime);
-    };
-    const fromCandidates = (pool) => pool.find(supported);
-    if (accept?.length) {
-        return (fromCandidates(RECORDER_CANDIDATES.filter((mime) => mimeAllowed(accept, mime))) ??
-            accept.find(supported));
-    }
-    return fromCandidates(RECORDER_CANDIDATES);
-}
-export { attachmentAcceptAttr, inputsFromSpec, pickMediaRecorderMime, validateProfileInputs };

package/esm/src/interface/mod.d.ts

@@ -1,10 +0,0 @@
-/**
- * Headless profile-driven interface — spec, inputs, transcript folding.
- *
- * @module
- */
-export { buildUserTurnBlocks, foldConversationTurn, foldTurnEvents, resetBlockIds, } from './blocks.js';
-export { interfaceFrom, interfaceFromProfile, interfaceFromProjected } from './from-profile.js';
-export { attachmentAcceptAttr, inputsFromSpec, pickMediaRecorderMime, validateProfileInputs, } from './inputs.js';
-export type { AttachmentValidationCode, AttachmentValidationIssue, AttachmentValidationResult, FoldTurnEventsOptions, ImageProfileInterface, LiveProfileInterface, NormalizedModel, NormalizeModel, PendingAttachment, ProfileGuardrailsView, ProfileInputsInterface, ProfileInterface, ProfileInterfaceSource, ResolvedTools, SpeechProfileInterface, TextProfileInterface, TranscriptBlock, TranscriptBlockKind, UserTurnDraft, } from './types.js';
-export { streamThoughtsEnabled } from './types.js';

package/esm/src/interface/mod.js

@@ -1,9 +0,0 @@
-/**
- * Headless profile-driven interface — spec, inputs, transcript folding.
- *
- * @module
- */
-export { buildUserTurnBlocks, foldConversationTurn, foldTurnEvents, resetBlockIds, } from './blocks.js';
-export { interfaceFrom, interfaceFromProfile, interfaceFromProjected } from './from-profile.js';
-export { attachmentAcceptAttr, inputsFromSpec, pickMediaRecorderMime, validateProfileInputs, } from './inputs.js';
-export { streamThoughtsEnabled } from './types.js';

package/esm/src/interface/types.d.ts

@@ -1,153 +0,0 @@
-/**
- * Headless interface contracts — profile-driven UI spec and transcript blocks.
- *
- * `ProfileInterface` is `Profile` with resolved `inputs`/`tools` and a serializable
- * `guardrails` view. No parallel schema.
- *
- * @module
- */
-import type { ProfileToolsSpec } from '../kernel/tools/types.js';
-import type { ControlId, GroundingEvent, ImageProfile, LiveProfile, ModelId, Profile, ProfileGuardrailsSpec, ProfileModelSpec, ProfileOutputsSpec, ProjectedProfile, ProviderEvidenceEvent, RegisteredTool, SpeechProfile, TextProfile, ToolCallEvent, ToolId, TurnStop, TurnTokens } from '../kernel/types.js';
-/** Guardrails visible to UI — egress enforcer functions are omitted. */
-export type ProfileGuardrailsView = Pick<ProfileGuardrailsSpec, 'quota' | 'canary' | 'sanitizeInput' | 'redactSensitive'> & {
-    hasEgress: boolean;
-};
-/** `profile.model` with normalized `select` / `controls`. */
-export type NormalizeModel<M extends ProfileModelSpec = ProfileModelSpec> = M & {
-    select: Record<string, ModelId> | null;
-    controls: ControlId[];
-};
-/** Resolved `inputs` — `ProfileInputsSpec` plus `acceptAttr` for file pickers. */
-export interface ProfileInputsInterface {
-    text: boolean;
-    attachments: {
-        accept: string[];
-        acceptAttr: string;
-    } | null;
-    voice: {
-        accept: string[];
-    } | null;
-    maxFiles?: number;
-    maxBytes?: number;
-    maxTurnBytes?: number;
-    limitsByMime?: Record<string, number>;
-    slots?: Record<string, string[]>;
-}
-/** `profile.tools` plus resolved registry entries. */
-export type ResolvedTools = ProfileToolsSpec & {
-    resolved: Array<RegisteredTool | {
-        name: ToolId;
-        missing: true;
-    }>;
-};
-export type NormalizedModel = NormalizeModel;
-export type TextProfileInterface = Omit<TextProfile, 'inputs' | 'tools' | 'guardrails' | 'model'> & {
-    model: NormalizeModel<TextProfile['model']>;
-    inputs: ProfileInputsInterface;
-    tools: ResolvedTools;
-    guardrails?: ProfileGuardrailsView;
-};
-export type ImageProfileInterface = Omit<ImageProfile, 'inputs' | 'tools' | 'guardrails' | 'model'> & {
-    model: NormalizeModel<ImageProfile['model']>;
-    inputs: ProfileInputsInterface;
-    tools: ResolvedTools;
-    guardrails?: ProfileGuardrailsView;
-};
-export type SpeechProfileInterface = Omit<SpeechProfile, 'guardrails' | 'model'> & {
-    model: NormalizeModel<SpeechProfile['model']>;
-    inputs: ProfileInputsInterface;
-    guardrails?: ProfileGuardrailsView;
-};
-export type LiveProfileInterface = Omit<LiveProfile, 'inputs' | 'tools' | 'model' | 'guardrails'> & {
-    model: NormalizeModel<LiveProfile['model']>;
-    inputs: ProfileInputsInterface;
-    tools: ResolvedTools;
-    guardrails?: ProfileGuardrailsView;
-};
-export type ProfileInterface = TextProfileInterface | ImageProfileInterface | SpeechProfileInterface | LiveProfileInterface;
-export type ProfileInterfaceSource = Profile | ProjectedProfile;
-export type TranscriptBlockKind = 'user-text' | 'user-attachment' | 'user-voice' | 'thought' | 'text' | 'tool' | 'structured' | 'media' | 'grounding' | 'evidence' | 'error' | 'turn-done';
-export interface TranscriptBlockBase {
-    id: string;
-    kind: TranscriptBlockKind;
-}
-export interface UserTextBlock extends TranscriptBlockBase {
-    kind: 'user-text';
-    text: string;
-}
-export interface UserAttachmentBlock extends TranscriptBlockBase {
-    kind: 'user-attachment' | 'user-voice';
-    name: string;
-    mimeType: string;
-    sizeBytes: number;
-}
-export interface ThoughtBlock extends TranscriptBlockBase {
-    kind: 'thought';
-    text: string;
-}
-export interface TextBlock extends TranscriptBlockBase {
-    kind: 'text';
-    text: string;
-}
-export interface ToolBlock extends TranscriptBlockBase {
-    kind: 'tool';
-    tool: ToolCallEvent & {
-        id?: string;
-    };
-}
-export interface StructuredBlock extends TranscriptBlockBase {
-    kind: 'structured';
-    value: unknown;
-}
-export interface MediaBlock extends TranscriptBlockBase {
-    kind: 'media';
-    mimeType: string;
-    data: string;
-}
-export interface GroundingBlock extends TranscriptBlockBase {
-    kind: 'grounding';
-    grounding: GroundingEvent;
-}
-export interface EvidenceBlock extends TranscriptBlockBase {
-    kind: 'evidence';
-    evidence: ProviderEvidenceEvent;
-}
-export interface ErrorBlock extends TranscriptBlockBase {
-    kind: 'error';
-    message: string;
-}
-export interface TurnDoneBlock extends TranscriptBlockBase {
-    kind: 'turn-done';
-    stop?: TurnStop;
-    tokens?: TurnTokens;
-    interactionId?: string;
-    compaction?: boolean;
-}
-export type TranscriptBlock = UserTextBlock | UserAttachmentBlock | ThoughtBlock | TextBlock | ToolBlock | StructuredBlock | MediaBlock | GroundingBlock | EvidenceBlock | ErrorBlock | TurnDoneBlock;
-export interface PendingAttachment {
-    name: string;
-    mimeType: string;
-    sizeBytes: number;
-}
-export type AttachmentValidationCode = 'mime_not_allowed' | 'too_many_files' | 'file_too_large' | 'turn_too_large' | 'limits_unconfigured';
-export interface AttachmentValidationIssue {
-    code: AttachmentValidationCode;
-    message: string;
-    fileName?: string;
-}
-export interface AttachmentValidationResult {
-    ok: boolean;
-    issues: AttachmentValidationIssue[];
-}
-export interface UserTurnDraft {
-    text?: string;
-    attachments?: PendingAttachment[];
-    voice?: PendingAttachment[];
-}
-export interface FoldTurnEventsOptions {
-    showThoughts?: boolean;
-    idPrefix?: string;
-}
-/** Whether `foldTurnEvents` should emit thought blocks for this profile. */
-declare function streamThoughtsEnabled(outputs?: ProfileOutputsSpec): boolean;
-export { streamThoughtsEnabled };

package/esm/src/interface/types.js

@@ -1,13 +0,0 @@
-/**
- * Headless interface contracts — profile-driven UI spec and transcript blocks.
- *
- * `ProfileInterface` is `Profile` with resolved `inputs`/`tools` and a serializable
- * `guardrails` view. No parallel schema.
- *
- * @module
- */
-/** Whether `foldTurnEvents` should emit thought blocks for this profile. */
-function streamThoughtsEnabled(outputs) {
-    return outputs?.streaming?.streamThoughts !== false;
-}
-export { streamThoughtsEnabled };