theorum 0.1.2

package/esm/src/observability/trace-attach.js

@@ -0,0 +1,81 @@
+import { modelEntry } from '../kernel/registry/catalog.js';
+import { tapeGemini } from '../providers/gemini-tape.js';
+import { toInteractionsBody } from '../providers/interactions.js';
+import { httpStatus } from './trace-usage.js';
+function completeRequest(generation, system) {
+    return {
+        model: generation.model,
+        previousInteractionId: generation.previousInteractionId,
+        store: generation.store,
+        thinking: generation.thinking,
+        summaries: generation.summaries,
+        maxOutputTokens: generation.maxOutputTokens,
+        temperature: generation.temperature,
+        builtins: generation.builtins,
+        system,
+        input: generation.input,
+        structured: generation.structured,
+        image: generation.image,
+        geminiBucket: generation.geminiBucket,
+    };
+}
+function attachResolved(record, args) {
+    const { safe, model, bucket, generation } = args;
+    if (safe.projectId) {
+        record.projectId = safe.projectId;
+    }
+    if (safe.select) {
+        record.select = safe.select;
+    }
+    if (safe.thinking !== undefined) {
+        record.thinking = safe.thinking;
+    }
+    if (safe.tools) {
+        record.tools = safe.tools;
+    }
+    if (safe.metadata) {
+        record.metadata = safe.metadata;
+    }
+    if (model) {
+        record.model = { id: model, apiId: modelEntry(model).apiId };
+    }
+    if (bucket) {
+        record.bucket = bucket;
+    }
+    if (generation) {
+        record.generation = {
+            thinking: generation.thinking,
+            summaries: generation.summaries,
+            temperature: generation.temperature,
+            maxOutputTokens: generation.maxOutputTokens,
+            builtins: generation.builtins,
+            custom: generation.custom,
+            structured: generation.structured,
+            image: generation.image,
+        };
+    }
+}
+async function attachTape(record, args) {
+    const { gemini, canary, system, generation } = args;
+    if (gemini !== undefined) {
+        record.gemini = await tapeGemini(gemini, canary ?? '');
+    }
+    if (generation && system !== undefined) {
+        record.wire = await tapeGemini(toInteractionsBody(completeRequest(generation, system)), canary ?? '');
+    }
+}
+function attachUsage(record, gemini, done) {
+    if (done?.usage !== undefined) {
+        record.usage = done.usage;
+    }
+    const upStatus = httpStatus(gemini);
+    if (upStatus !== undefined || done) {
+        record.upstream = {
+            status: upStatus,
+            id: done?.id,
+            finish: done?.status,
+            serviceTier: done?.service_tier ?? done?.serviceTier,
+        };
+    }
+}
+export { attachResolved, attachTape, attachUsage };

package/esm/src/observability/trace-record.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Trace record construction types.
+ *
+ * Trace records preserve useful execution evidence while hashing or omitting
+ * unsafe media bytes and canary-sensitive content.
+ *
+ * @module
+ */
+import type { ResolvedGeneration, TurnEvent, TurnRequest } from '../kernel/types.js';
+/** Hash-only image reference stored in trace records. */
+export interface TraceImage {
+    mimeType: string;
+    sha256: string;
+}
+/** Trace-safe copy of a public turn event. */
+export interface TraceEvent {
+    type: string;
+    text?: string;
+    tool?: {
+        name: string;
+        arguments?: Record<string, unknown>;
+        result?: {
+            status: string;
+            finding?: string;
+            data?: Record<string, unknown>;
+        };
+    };
+    structured?: unknown;
+    media?: TraceImage;
+    grounding?: TurnEvent['grounding'];
+    evidence?: TurnEvent['evidence'];
+    error?: string;
+}
+/** Complete trace-safe record for one attempted turn. */
+interface TraceRecord {
+    v: number;
+    id: string;
+    ts: number;
+    ms: number;
+    streamed: boolean;
+    cancelled: boolean;
+    previousInteractionId: string | null;
+    store: boolean | null;
+    profile: string;
+    title?: string;
+    projectId?: string;
+    select?: string;
+    thinking?: boolean;
+    tools?: TurnRequest['tools'];
+    metadata?: Record<string, unknown>;
+    model?: {
+        id: string;
+        apiId: string;
+    };
+    bucket?: string;
+    generation?: {
+        thinking: string;
+        summaries: string;
+        temperature: number;
+        maxOutputTokens: number;
+        builtins: string[];
+        custom: string[];
+        structured: string | null;
+        image: unknown;
+    };
+    input: {
+        text?: string;
+        role?: string;
+        slots?: Record<string, string>;
+        attachments: TraceImage[];
+        voice: TraceImage[];
+        images?: TraceImage[];
+        audio?: TraceImage[];
+    };
+    wire?: unknown;
+    events: TraceEvent[];
+    gemini?: unknown;
+    usage?: unknown;
+    upstream?: {
+        status?: unknown;
+        id?: unknown;
+        finish?: unknown;
+        serviceTier?: unknown;
+    };
+    ok: boolean;
+    error?: string;
+    errorInternal?: string;
+    app?: Record<string, unknown>;
+    cutout?: {
+        ok: boolean;
+        ms: number;
+        url?: string;
+        inSha256?: string;
+        outSha256?: string;
+        http?: unknown;
+        error?: string;
+    };
+}
+declare function buildRecord(args: {
+    req: TurnRequest;
+    events: TurnEvent[];
+    started: number;
+    model?: string;
+    bucket?: string;
+    thrown?: unknown;
+    gemini?: unknown;
+    canary?: string;
+    system?: string;
+    generation?: ResolvedGeneration;
+}): Promise<TraceRecord>;
+export type { TraceRecord };
+export { buildRecord };

package/esm/src/observability/trace-record.js

@@ -0,0 +1,140 @@
+/**
+ * Trace record construction types.
+ *
+ * Trace records preserve useful execution evidence while hashing or omitting
+ * unsafe media bytes and canary-sensitive content.
+ *
+ * @module
+ */
+import { publicError } from '../guardrails/error.js';
+import { sanitizeText, sanitizeTurnRequest } from '../guardrails/sanitize.js';
+import { OMIT_CANARY } from '../kernel/engine/boundary.js';
+import { sha256 } from '../kernel/engine/hash.js';
+import { attachResolved, attachTape, attachUsage } from './trace-attach.js';
+import { completedInteraction } from './trace-usage.js';
+const TRACE_VERSION = 2;
+const TITLE_MAX = 80;
+function hashBlobs(blobs) {
+    if (!blobs) {
+        return Promise.resolve([]);
+    }
+    return Promise.all(blobs.map(async (blob) => ({
+        mimeType: blob.mimeType,
+        sha256: await sha256(blob.data),
+    })));
+}
+async function snapshotEvent(event) {
+    const row = { type: event.type };
+    if (event.text) {
+        row.text = sanitizeText(event.text);
+    }
+    if (event.error) {
+        row.error = event.error;
+    }
+    if (event.structured !== undefined) {
+        row.structured = event.structured;
+    }
+    if (event.tool) {
+        const { name, arguments: args, result } = event.tool;
+        row.tool = { name, arguments: args };
+        if (result) {
+            row.tool.result = {
+                status: result.status,
+                ...(result.finding ? { finding: result.finding } : {}),
+                ...(result.data ? { data: result.data } : {}),
+            };
+        }
+    }
+    if (event.media) {
+        row.media = {
+            mimeType: event.media.mimeType,
+            sha256: await sha256(event.media.data),
+        };
+    }
+    if (event.grounding) {
+        row.grounding = event.grounding;
+    }
+    if (event.evidence) {
+        row.evidence = event.evidence;
+    }
+    return row;
+}
+function requestForTrace(req) {
+    try {
+        return sanitizeTurnRequest(req);
+    }
+    catch {
+        return { profile: req.profile, input: {} };
+    }
+}
+function internalError(err) {
+    if (typeof err === 'string') {
+        return sanitizeText(err);
+    }
+    if (err instanceof Error && err.message) {
+        return sanitizeText(err.message);
+    }
+    return undefined;
+}
+function titleFrom(text) {
+    if (!text) {
+        return undefined;
+    }
+    const trimmed = text.trim().replaceAll(/\s+/g, ' ');
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.slice(0, TITLE_MAX);
+}
+function attachFailure(record, thrown, lastErr, canary) {
+    if (!record.ok) {
+        record.error = publicError(thrown ?? lastErr?.error);
+        const inside = internalError(thrown) ?? lastErr?.error;
+        if (inside) {
+            record.errorInternal = inside;
+        }
+    }
+    if (canary && JSON.stringify(record).includes(canary)) {
+        record.errorInternal = OMIT_CANARY;
+    }
+}
+async function buildRecord(args) {
+    const { req, events, started, model, bucket, thrown, gemini, canary, system, generation } = args;
+    const safe = requestForTrace(req);
+    const input = safe.input ?? {};
+    const snapped = await Promise.all(events.map((event) => snapshotEvent(event)));
+    const lastErr = [...snapped].reverse().find((row) => row.type === 'error');
+    const done = completedInteraction(gemini);
+    const status = done?.status;
+    const ok = !(thrown || lastErr) && status !== 'cancelled';
+    const record = {
+        v: TRACE_VERSION,
+        id: crypto.randomUUID(),
+        ts: started,
+        ms: Date.now() - started,
+        streamed: true,
+        cancelled: status === 'cancelled',
+        previousInteractionId: safe.previousInteractionId ?? null,
+        store: safe.store ?? null,
+        profile: safe.profile,
+        input: {
+            text: input.text,
+            role: input.role,
+            slots: input.slots,
+            attachments: await hashBlobs(input.attachments),
+            voice: await hashBlobs(input.voice),
+        },
+        events: snapped,
+        ok,
+    };
+    const title = titleFrom(input.text);
+    if (title) {
+        record.title = title;
+    }
+    await attachTape(record, { gemini, canary, system, generation });
+    attachUsage(record, gemini, done);
+    attachResolved(record, { safe, model, bucket, generation });
+    attachFailure(record, thrown, lastErr, canary);
+    return record;
+}
+export { buildRecord };

package/esm/src/observability/trace-usage.d.ts

@@ -0,0 +1,3 @@
+declare function completedInteraction(gemini: unknown): Record<string, unknown> | undefined;
+declare function httpStatus(gemini: unknown): unknown;
+export { completedInteraction, httpStatus };

package/esm/src/observability/trace-usage.js

@@ -0,0 +1,32 @@
+import { asRecord } from '../kernel/engine/record.js';
+function eventName(row) {
+    return String(row.event_type ?? row.eventType ?? '');
+}
+function completedInteraction(gemini) {
+    if (!Array.isArray(gemini)) {
+        return undefined;
+    }
+    for (let i = gemini.length - 1; i >= 0; i -= 1) {
+        const row = asRecord(gemini[i]);
+        if (row) {
+            const name = eventName(row);
+            if (name === 'interaction.completed' || name === 'interaction.complete') {
+                return asRecord(row.interaction) ?? row;
+            }
+        }
+    }
+    return undefined;
+}
+function httpStatus(gemini) {
+    if (!Array.isArray(gemini)) {
+        return undefined;
+    }
+    for (const item of gemini) {
+        const row = asRecord(item);
+        if (row && eventName(row) === 'http_response') {
+            return row.status;
+        }
+    }
+    return undefined;
+}
+export { completedInteraction, httpStatus };

package/esm/src/observability/trace.d.ts

@@ -0,0 +1,23 @@
+import type { TraceRecord } from './trace-record.js';
+/** Minimal async destination for completed turn trace records. */
+interface TraceSink {
+    write: (record: TraceRecord) => Promise<void>;
+}
+/** Write a trace record without allowing trace failures to fail the turn. */
+declare function writeTrace(sink: TraceSink, record: Promise<TraceRecord>): Promise<void>;
+/** Trace sink that drops records. */
+declare function noopSink(): TraceSink;
+/** Trace sink that appends records to a caller-owned array. */
+declare function memorySink(into: TraceRecord[]): TraceSink;
+/** Trace sink that writes daily rotating JSONL files under a host-selected directory. */
+declare function jsonlSink(dir: string, now?: () => number): TraceSink;
+/** Resolve a trace directory while refusing relative paths or paths inside the clone. */
+declare function resolveTraceDir(args: {
+    dir?: string;
+    fallbackDir?: string;
+    cwd?: string;
+}): string | undefined;
+/** Build a JSONL sink from a host-supplied directory or return a noop sink. */
+declare function sinkFromDir(dir?: string, fallbackDir?: string): TraceSink;
+export type { TraceSink };
+export { jsonlSink, memorySink, noopSink, resolveTraceDir, sinkFromDir, writeTrace };

package/esm/src/observability/trace.js

@@ -0,0 +1,121 @@
+/**
+ * Trace sink primitives for THEORUM.
+ *
+ * Tracing is host-injected: the kernel can write to a provided sink, a memory
+ * sink, a JSONL directory, or a noop sink. It does not read environment
+ * variables or own a database destination.
+ *
+ * @module
+ */
+import * as dntShim from "../../_dnt.shims.js";
+const RETAIN_DAYS = 14;
+const HOURS_PER_DAY = 24;
+const MIN_PER_HOUR = 60;
+const SEC_PER_MIN = 60;
+const MS_PER_SEC = 1000;
+const RETAIN_MS = RETAIN_DAYS * HOURS_PER_DAY * MIN_PER_HOUR * SEC_PER_MIN * MS_PER_SEC;
+const KIB = 1024;
+const MIB = KIB * KIB;
+const ROTATE_MIB = 32;
+const ROTATE_BYTES = ROTATE_MIB * MIB;
+const FILE_DAY = /^turns-(\d{4}-\d{2}-\d{2})(?:-\d+)?\.jsonl$/;
+/** Write a trace record without allowing trace failures to fail the turn. */
+async function writeTrace(sink, record) {
+    try {
+        await sink.write(await record);
+    }
+    catch {
+        // Tracing must not fail the turn.
+    }
+}
+/** Trace sink that drops records. */
+function noopSink() {
+    return { write: () => Promise.resolve() };
+}
+/** Trace sink that appends records to a caller-owned array. */
+function memorySink(into) {
+    return {
+        write: (record) => {
+            into.push(record);
+            return Promise.resolve();
+        },
+    };
+}
+function dayStamp(ms) {
+    return new Date(ms).toISOString().slice(0, 10);
+}
+function fileDay(name) {
+    return FILE_DAY.exec(name)?.[1];
+}
+async function pruneTraces(dir, now) {
+    const cutoff = now - RETAIN_MS;
+    for await (const entry of dntShim.Deno.readDir(dir)) {
+        const day = fileDay(entry.name);
+        if (day && Date.parse(`${day}T00:00:00.000Z`) < cutoff) {
+            await dntShim.Deno.remove(`${dir}/${entry.name}`);
+        }
+    }
+}
+async function pickFile(dir, now) {
+    const day = dayStamp(now);
+    const base = `${dir}/turns-${day}.jsonl`;
+    try {
+        const info = await dntShim.Deno.stat(base);
+        if ((info.size ?? 0) < ROTATE_BYTES) {
+            return base;
+        }
+    }
+    catch {
+        return base;
+    }
+    return `${dir}/turns-${day}-${now}.jsonl`;
+}
+/** Trace sink that writes daily rotating JSONL files under a host-selected directory. */
+function jsonlSink(dir, now = Date.now) {
+    return {
+        write: async (record) => {
+            const at = now();
+            await dntShim.Deno.mkdir(dir, { recursive: true });
+            await pruneTraces(dir, at);
+            const path = await pickFile(dir, at);
+            await dntShim.Deno.writeTextFile(path, `${JSON.stringify(record)}\n`, { append: true });
+        },
+    };
+}
+function insideDir(path, root) {
+    let base = root;
+    if (root.endsWith('/')) {
+        base = root.slice(0, -1);
+    }
+    if (path === base) {
+        return true;
+    }
+    return path.startsWith(`${base}/`);
+}
+/** Resolve a trace directory while refusing relative paths or paths inside the clone. */
+function resolveTraceDir(args) {
+    const cwd = args.cwd ?? dntShim.Deno.cwd();
+    if (args.dir === '') {
+        return undefined;
+    }
+    let dir = args.dir?.trim() || args.fallbackDir;
+    if (!dir) {
+        return undefined;
+    }
+    if (!dir.startsWith('/') || insideDir(dir, cwd)) {
+        dir = args.fallbackDir;
+    }
+    if (!dir || insideDir(dir, cwd)) {
+        return undefined;
+    }
+    return dir;
+}
+/** Build a JSONL sink from a host-supplied directory or return a noop sink. */
+function sinkFromDir(dir, fallbackDir) {
+    const resolved = resolveTraceDir({ dir, fallbackDir });
+    if (!resolved) {
+        return noopSink();
+    }
+    return jsonlSink(resolved);
+}
+export { jsonlSink, memorySink, noopSink, resolveTraceDir, sinkFromDir, writeTrace };

package/esm/src/providers/attachments.d.ts

@@ -0,0 +1,17 @@
+import type { MediaLimits, MimeInputs, Profile, TurnBlob } from '../kernel/types.js';
+declare function tooManyFilesMessage(maxFiles: number): string;
+declare function fileTooLargeMessage(maxBytes: number): string;
+declare function turnTooLargeMessage(maxTurnBytes: number): string;
+declare function mediaLimits(inputs: MimeInputs): MediaLimits | undefined;
+declare function requireMediaLimits(profile: Profile): MediaLimits;
+declare function sanitizeCsvText(text: string): string;
+declare function assertAttachmentLimits(blobs: TurnBlob[], limits: MediaLimits): void;
+declare function sanitizeTurnBlobs(attachments: TurnBlob[] | undefined, voice: TurnBlob[] | undefined, limits: MediaLimits | undefined): {
+    attachments?: TurnBlob[];
+    voice?: TurnBlob[];
+};
+declare function sanitizeTurnBlobsForProfile(profileId: string, attachments: TurnBlob[] | undefined, voice: TurnBlob[] | undefined): {
+    attachments?: TurnBlob[];
+    voice?: TurnBlob[];
+};
+export { assertAttachmentLimits, fileTooLargeMessage, mediaLimits, requireMediaLimits, sanitizeCsvText, sanitizeTurnBlobs, sanitizeTurnBlobsForProfile, tooManyFilesMessage, turnTooLargeMessage, };

package/esm/src/providers/attachments.js

@@ -0,0 +1,156 @@
+import { TheorumError } from '../guardrails/error.js';
+import { injectionSpans } from '../guardrails/injection.js';
+import { sensitiveSpans } from '../guardrails/sensitive.js';
+import { getProfile } from '../kernel/registry/profiles.js';
+import { applySpans } from '../observability/spans.js';
+const B64_PAD = 2;
+const B64_WORD = 4;
+const B64_TRIPLET = 3;
+const CSV_FORMULA = /(^|,)(\s*)("?)(?:([=@])|([+-])(?![0-9."]))/gm;
+const B64_BODY = /^[A-Za-z0-9+/]*={0,2}$/;
+const TEXT_MIMES = new Set(['text/csv', 'text/plain', 'text/markdown']);
+const BYTES_PER_KIB = 1024;
+function formatMb(bytes) {
+    const mb = bytes / (BYTES_PER_KIB * BYTES_PER_KIB);
+    return Number.isInteger(mb) ? `${String(mb)} MB` : `${mb.toFixed(1)} MB`;
+}
+function tooManyFilesMessage(maxFiles) {
+    return maxFiles === 1
+        ? 'Only 1 file per message.'
+        : `Only ${String(maxFiles)} files per message.`;
+}
+function fileTooLargeMessage(maxBytes) {
+    return `Each file must be ${formatMb(maxBytes)} or smaller.`;
+}
+function turnTooLargeMessage(maxTurnBytes) {
+    return `Those files together are too large for one message (${formatMb(maxTurnBytes)} max).`;
+}
+function mediaLimits(inputs) {
+    const { maxFiles, maxBytes, maxTurnBytes, limitsByMime } = inputs;
+    if (maxFiles && maxBytes && maxTurnBytes) {
+        return { maxFiles, maxBytes, maxTurnBytes, limitsByMime };
+    }
+    return undefined;
+}
+function maxBytesForMime(mimeType, limits) {
+    if (limits.limitsByMime) {
+        const cleanMime = mimeType.split(';')[0]?.trim().toLowerCase() ?? '';
+        if (limits.limitsByMime[cleanMime]) {
+            return limits.limitsByMime[cleanMime];
+        }
+        const [category] = cleanMime.split('/');
+        const wildCard = `${category}/*`;
+        if (limits.limitsByMime[wildCard]) {
+            return limits.limitsByMime[wildCard];
+        }
+    }
+    return limits.maxBytes;
+}
+function requireMediaLimits(profile) {
+    const limits = mediaLimits(profile.inputs);
+    if (!limits) {
+        throw new TheorumError(`Profile ${profile.id} must set maxFiles, maxBytes, and maxTurnBytes`);
+    }
+    return limits;
+}
+function b64DecodedLen(data) {
+    let pad = 0;
+    if (data.endsWith('==')) {
+        pad = B64_PAD;
+    }
+    else if (data.endsWith('=')) {
+        pad = 1;
+    }
+    return Math.floor((data.length * B64_TRIPLET) / B64_WORD) - pad;
+}
+function decodeB64(data) {
+    const binary = atob(data);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+function encodeB64(bytes) {
+    let binary = '';
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}
+function decodeText(bytes) {
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    catch {
+        return new TextDecoder('latin1').decode(bytes);
+    }
+}
+function sanitizeCsvText(text) {
+    return text.replace(CSV_FORMULA, (_full, ...groups) => {
+        const [a, b, c, d, e] = groups;
+        return `${a}${b}${c}'${d ?? ''}${e ?? ''}`;
+    });
+}
+function sanitizeTextBytes(mime, bytes) {
+    let text = decodeText(bytes);
+    if (mime === 'text/csv') {
+        text = sanitizeCsvText(text);
+    }
+    return new TextEncoder().encode(applySpans(text, [...injectionSpans(text), ...sensitiveSpans(text)]));
+}
+function assertAttachmentLimits(blobs, limits) {
+    if (blobs.length > limits.maxFiles) {
+        throw new TheorumError(tooManyFilesMessage(limits.maxFiles));
+    }
+    let total = 0;
+    for (const blob of blobs) {
+        const { data, mimeType } = blob;
+        if (!B64_BODY.test(data)) {
+            throw new TheorumError('attachment data must be base64');
+        }
+        const size = b64DecodedLen(data);
+        const maxAllowed = maxBytesForMime(mimeType, limits);
+        if (size > maxAllowed) {
+            throw new TheorumError(fileTooLargeMessage(maxAllowed));
+        }
+        total += size;
+    }
+    if (total > limits.maxTurnBytes) {
+        throw new TheorumError(turnTooLargeMessage(limits.maxTurnBytes));
+    }
+}
+function sanitizeAttachment(blob) {
+    const { mimeType, data } = blob;
+    if (!TEXT_MIMES.has(mimeType.split(';')[0]?.trim().toLowerCase() ?? '')) {
+        return blob;
+    }
+    const bytes = sanitizeTextBytes(mimeType, decodeB64(data));
+    return { mimeType, data: encodeB64(bytes) };
+}
+function hasTurnBlobs(attachments, voice) {
+    return (attachments?.length ?? 0) > 0 || (voice?.length ?? 0) > 0;
+}
+function sanitizeTurnBlobs(attachments, voice, limits) {
+    if (!hasTurnBlobs(attachments, voice)) {
+        return { attachments, voice };
+    }
+    const files = attachments ?? [];
+    const clips = voice ?? [];
+    if (!limits) {
+        throw new TheorumError('This profile does not accept files.');
+    }
+    assertAttachmentLimits([...files, ...clips], limits);
+    return {
+        attachments: files.length > 0 ? files.map(sanitizeAttachment) : attachments,
+        voice: clips.length > 0 ? clips.map(sanitizeAttachment) : voice,
+    };
+}
+function sanitizeTurnBlobsForProfile(profileId, attachments, voice) {
+    if (!hasTurnBlobs(attachments, voice)) {
+        return { attachments, voice };
+    }
+    const limits = requireMediaLimits(getProfile(profileId));
+    return sanitizeTurnBlobs(attachments, voice, limits);
+}
+export { assertAttachmentLimits, fileTooLargeMessage, mediaLimits, requireMediaLimits, sanitizeCsvText, sanitizeTurnBlobs, sanitizeTurnBlobsForProfile, tooManyFilesMessage, turnTooLargeMessage, };

package/esm/src/providers/gemini-tape.d.ts

@@ -0,0 +1,3 @@
+import { sha256 } from '../kernel/engine/hash.js';
+declare function tapeGemini(value: unknown, canary: string): Promise<unknown>;
+export { sha256, tapeGemini };