theorum 0.1.11 → 0.1.13

package/esm/src/providers/local.js

@@ -0,0 +1,259 @@
+/**
+ * Local provider adapter for OpenAI-compatible endpoints (Ollama, llama.cpp,
+ * vLLM, LM Studio, etc.).
+ *
+ * Streams SSE from `/v1/chat/completions`, accumulates tool calls, and yields
+ * normalized `TurnEvent` objects. No external SDK dependency — raw fetch + SSE.
+ *
+ * Hosts pass `baseUrl` explicitly. THEORUM does not read `OLLAMA_HOST` or other
+ * environment variables (see docs/SECRETS.md).
+ *
+ * @module
+ */
+import { isAbortError, toErrorEvent } from '../guardrails/error.js';
+import { turnStopFromOpenRouter } from '../kernel/stop.js';
+import { exposeForTests } from './expose-for-tests.js';
+/** Default OpenAI-compat base when the host omits `baseUrl` (Ollama's default port). */
+export const DEFAULT_LOCAL_BASE_URL = 'http://127.0.0.1:11434';
+// ── request mapping ─────────────────────────────────
+function normalizeBaseUrl(baseUrl) {
+    let end = baseUrl.length;
+    while (end > 0 && baseUrl.charCodeAt(end - 1) === 47)
+        end -= 1;
+    return baseUrl.slice(0, end);
+}
+function resolveBaseUrl(config) {
+    return normalizeBaseUrl(config?.baseUrl?.trim() || DEFAULT_LOCAL_BASE_URL);
+}
+function inputToContent(parts) {
+    if (parts.every((p) => p.type === 'text')) {
+        return parts.map((p) => ('text' in p ? p.text : '')).join('\n');
+    }
+    return parts.map((p) => {
+        if (p.type === 'text')
+            return { type: 'text', text: p.text };
+        return {
+            type: 'image_url',
+            image_url: { url: `data:${p.mimeType};base64,${p.data}` },
+        };
+    });
+}
+function historyMessageContent(msg) {
+    if (msg.parts && msg.parts.length > 0) {
+        return inputToContent(msg.parts);
+    }
+    if (msg.content != null)
+        return msg.content;
+    return undefined;
+}
+function historyToWire(req) {
+    const msgs = [];
+    if (req.system)
+        msgs.push({ role: 'system', content: req.system });
+    for (const msg of req.history ?? []) {
+        msgs.push(historyMessageToWire(msg));
+    }
+    if (req.input.length > 0) {
+        msgs.push({ role: 'user', content: inputToContent(req.input) });
+    }
+    return msgs;
+}
+function historyMessageToWire(msg) {
+    if (msg.role === 'tool') {
+        return {
+            role: 'tool',
+            tool_call_id: msg.tool_call_id ?? `call_${msg.name ?? 'tool'}`,
+            name: msg.name,
+            content: msg.content ?? '',
+        };
+    }
+    if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
+        return {
+            role: 'assistant',
+            content: historyMessageContent(msg) ?? undefined,
+            tool_calls: msg.tool_calls.map((tc) => ({
+                id: tc.id,
+                type: 'function',
+                function: { name: tc.function.name, arguments: tc.function.arguments },
+            })),
+        };
+    }
+    return { role: msg.role, content: historyMessageContent(msg) ?? '' };
+}
+function toolsToWire(dynamicTools) {
+    if (!dynamicTools || dynamicTools.length === 0)
+        return undefined;
+    return dynamicTools.map((t) => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description ?? '',
+            parameters: t.parameters ?? { type: 'object', properties: {} },
+        },
+    }));
+}
+function buildBody(req) {
+    const body = {
+        model: req.apiId,
+        messages: historyToWire(req),
+        stream: true,
+        stream_options: { include_usage: true },
+        temperature: req.temperature,
+        max_tokens: req.maxOutputTokens,
+    };
+    const tools = toolsToWire(req.dynamicTools);
+    if (tools)
+        body.tools = tools;
+    return body;
+}
+// ── SSE parsing ─────────────────────────────────────
+async function* parseSse(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('data: '))
+                continue;
+            const data = trimmed.slice(6);
+            if (data === '[DONE]')
+                return;
+            try {
+                yield JSON.parse(data);
+            }
+            catch {
+                // skip malformed
+            }
+        }
+    }
+}
+// ── stream → TurnEvent ──────────────────────────────
+function flushPending(pending) {
+    const events = [];
+    for (const [, tc] of pending) {
+        let parsed = {};
+        try {
+            parsed = JSON.parse(tc.args);
+        }
+        catch {
+            // empty
+        }
+        events.push({
+            type: 'tool',
+            tool: { name: tc.name, arguments: parsed, id: tc.id },
+        });
+    }
+    pending.clear();
+    return events;
+}
+async function* streamComplete(baseUrl, req, fetchFn) {
+    const res = await fetchFn(`${baseUrl}/v1/chat/completions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(buildBody(req)),
+        signal: req.signal,
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        yield toErrorEvent(`LLM HTTP ${res.status}: ${text.slice(0, 300)}`);
+        return;
+    }
+    if (!res.body) {
+        yield toErrorEvent('empty response body');
+        return;
+    }
+    yield* streamOpenAiBody(res.body);
+}
+async function* streamOpenAiBody(body) {
+    const pending = new Map();
+    let finishReason;
+    for await (const chunk of parseSse(body)) {
+        const usageEvent = tokensFromUsage(chunk.usage);
+        if (usageEvent)
+            yield usageEvent;
+        const choice = chunk.choices?.[0];
+        if (!choice)
+            continue;
+        yield* eventsFromChoiceDelta(choice.delta, pending);
+        if (choice.finish_reason != null) {
+            finishReason = choice.finish_reason;
+            for (const event of flushPending(pending))
+                yield event;
+        }
+    }
+    for (const event of flushPending(pending))
+        yield event;
+    yield { type: 'done', stop: turnStopFromOpenRouter(finishReason) };
+}
+function tokensFromUsage(usage) {
+    if (!usage)
+        return undefined;
+    return {
+        type: 'tokens',
+        tokens: {
+            input: usage.prompt_tokens ?? 0,
+            output: usage.completion_tokens ?? 0,
+            total: usage.total_tokens ?? 0,
+        },
+    };
+}
+function* eventsFromChoiceDelta(delta, pending) {
+    if (!delta)
+        return;
+    if (delta.content)
+        yield { type: 'text', text: delta.content };
+    accumulateToolCalls(delta.tool_calls, pending);
+}
+function accumulateToolCalls(toolCalls, pending) {
+    if (!toolCalls)
+        return;
+    for (const tc of toolCalls) {
+        const existing = pending.get(tc.index);
+        if (existing) {
+            existing.args += tc.function?.arguments ?? '';
+            continue;
+        }
+        pending.set(tc.index, {
+            id: tc.id ?? `call_${tc.index}`,
+            name: tc.function?.name ?? '',
+            args: tc.function?.arguments ?? '',
+        });
+    }
+}
+// ── public factory ──────────────────────────────────
+/** Create a `ModelProvider` for a local OpenAI-compatible server (Ollama, llama.cpp, vLLM, LM Studio). */
+function createLocalProvider(config) {
+    const baseUrl = resolveBaseUrl(config);
+    const fetchFn = config?.fetch ?? globalThis.fetch;
+    return {
+        async *complete(req) {
+            try {
+                yield* streamComplete(baseUrl, req, fetchFn);
+            }
+            catch (err) {
+                if (isAbortError(err))
+                    throw err;
+                yield toErrorEvent(err);
+            }
+        },
+    };
+}
+export { createLocalProvider };
+exposeForTests('local', {
+    inputToContent,
+    historyMessageContent,
+    historyToWire,
+    toolsToWire,
+    buildBody,
+    parseSse,
+    flushPending,
+    resolveBaseUrl,
+    DEFAULT_LOCAL_BASE_URL,
+});

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

@@ -10,3 +10,5 @@ import "../../_dnt.polyfills.js";
 export type { CreateProviderOptions } from './create-provider.js';
 export { createProvider } from './create-provider.js';
 export type { GeminiTransport, GeminiVault } from './keys.js';
+export type { LocalProviderConfig } from './local.js';
+export { createLocalProvider, DEFAULT_LOCAL_BASE_URL } from './local.js';

package/esm/src/providers/mod.js

@@ -8,3 +8,4 @@
  */
 import "../../_dnt.polyfills.js";
 export { createProvider } from './create-provider.js';
+export { createLocalProvider, DEFAULT_LOCAL_BASE_URL } from './local.js';

package/esm/src/providers/openrouter.js

@@ -12,8 +12,9 @@ import { jsonSchema, streamText, tool, } from 'ai';
 import { isAbortError, toErrorEvent } from '../guardrails/error.js';
 import { tryStructured } from '../kernel/engine/delta.js';
 import { getStructured } from '../kernel/registry/schemas.js';
-import { resolveOpenRouterModel, resolveOpenRouterPlugins, toOpenRouterPayload, } from './openrouter-payload.js';
+import { turnStopFromOpenRouter } from '../kernel/stop.js';
 import { exposeForTests } from './expose-for-tests.js';
+import { resolveOpenRouterModel, resolveOpenRouterPlugins, toOpenRouterPayload, } from './openrouter-payload.js';
 function trimApiKey(explicitKey) {
     if (explicitKey?.trim()) {
         return explicitKey.trim();
@@ -301,6 +302,18 @@ function rawEvents(raw, acc) {
     if (messageEvidence) {
         events.push(messageEvidence);
     }
+    const choices = Array.isArray(record.choices) ? record.choices : [];
+    for (const choice of choices) {
+        const row = rawRecord(choice);
+        if (!row)
+            continue;
+        if (typeof row.finish_reason === 'string' || row.finish_reason === null) {
+            acc.finishReason = row.finish_reason;
+        }
+        if (typeof row.native_finish_reason === 'string' || row.native_finish_reason === null) {
+            acc.nativeFinishReason = row.native_finish_reason;
+        }
+    }
     return events;
 }
 function toolCallEvent(part) {
@@ -373,6 +386,9 @@ function primaryEventFromPart(part, acc) {
     }
 }
 function finishEvent(part, acc) {
+    if ('finishReason' in part && part.finishReason != null) {
+        acc.finishReason = String(part.finishReason);
+    }
     if (acc.emittedTokens) {
         return undefined;
     }
@@ -382,6 +398,21 @@ function finishEvent(part, acc) {
     }
     return event;
 }
+function* finalEvents(req, acc) {
+    if (acc.errored) {
+        return;
+    }
+    if (req.structured && acc.text) {
+        const structured = tryStructured(acc.text);
+        if (structured) {
+            yield structured;
+        }
+    }
+    yield {
+        type: 'done',
+        stop: turnStopFromOpenRouter(acc.finishReason, acc.nativeFinishReason),
+    };
+}
 function createStreamContext(req, config, apiKey) {
     const openrouter = createOpenRouter({
         apiKey,
@@ -450,18 +481,6 @@ async function* streamOpenRouter(req, config) {
         yield toErrorEvent(err);
     }
 }
-function* finalEvents(req, acc) {
-    if (acc.errored) {
-        return;
-    }
-    if (req.structured && acc.text) {
-        const structured = tryStructured(acc.text);
-        if (structured) {
-            yield structured;
-        }
-    }
-    yield { type: 'done' };
-}
 function responseFormatFor(req) {
     if (!req.structured)
         return undefined;

package/esm/src/providers/provider.js

@@ -10,12 +10,12 @@
  */
 import { isAbortError, TheorumError, toErrorEvent } from '../guardrails/error.js';
 import { eventsFromComplete, eventsFromDelta, extractTokenEvent, groundingFromEvent, tryStructured, } from '../kernel/engine/delta.js';
+import { exposeForTests } from './expose-for-tests.js';
 import { tapFetch } from './google-tap.js';
 import { toInteractionsBody } from './interactions.js';
 import { fetchGemini } from './keys.js';
 import { wrapPcmAsWav } from './pcm.js';
 import { INTERACTIONS_URL, takeSsePayloads } from './sse.js';
-import { exposeForTests } from './expose-for-tests.js';
 const HTTP_OK = 200;
 function base64ToBytes(data) {
     const bin = atob(data);

package/esm/src/providers/speech.js

@@ -7,8 +7,8 @@
  * @module
  */
 import { toErrorEvent } from '../guardrails/error.js';
-import { wrapPcmAsWav } from './pcm.js';
 import { exposeForTests } from './expose-for-tests.js';
+import { wrapPcmAsWav } from './pcm.js';
 const HTTP_OK = 200;
 function bytesToBase64(bytes) {
     let bin = '';

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

@@ -1,7 +1,9 @@
 /**
- * Structured-output streaming helpers (incomplete JSON text buffers).
+ * Structured-output streaming helpers and turn-stop classification.
  *
  * @module
  */
 import "../../_dnt.polyfills.js";
+export type { ProfileResumeSpec, TurnContinueFrom, TurnStop, TurnStopKind, } from '../kernel/stop.js';
+export { AUTO_CONTINUE_DELAY_MS, CONTINUE_INSTRUCTION, DEFAULT_AUTO_CONTINUE, GenerationStopError, isGenerationStopError, isResumeableStop, isUserCancelledStop, shouldAutoContinue, turnStopFromClientStreamEnd, turnStopFromInteractionStatus, turnStopFromOpenRouter, } from '../kernel/stop.js';
 export { readStreamingJsonStringField } from './readStreamingJsonStringField.js';

package/esm/src/streaming/mod.js

@@ -1,7 +1,8 @@
 /**
- * Structured-output streaming helpers (incomplete JSON text buffers).
+ * Structured-output streaming helpers and turn-stop classification.
  *
  * @module
  */
 import "../../_dnt.polyfills.js";
+export { AUTO_CONTINUE_DELAY_MS, CONTINUE_INSTRUCTION, DEFAULT_AUTO_CONTINUE, GenerationStopError, isGenerationStopError, isResumeableStop, isUserCancelledStop, shouldAutoContinue, turnStopFromClientStreamEnd, turnStopFromInteractionStatus, turnStopFromOpenRouter, } from '../kernel/stop.js';
 export { readStreamingJsonStringField } from './readStreamingJsonStringField.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theorum",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "A flat TypeScript agent kernel for typed profiles, deterministic turn execution, dynamic tools, provider adapters, guardrails, and host-injected traces.",
   "keywords": [
     "agent",
@@ -13,6 +13,10 @@
     "openrouter",
     "gemini"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/masudl-hub/theorum"
+  },
   "license": "MIT",
   "module": "./esm/mod.js",
   "exports": {
@@ -59,6 +63,7 @@
   "dependencies": {
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.0",
+    "gpt-tokenizer": "^4.0.0",
     "@deno/shim-deno": "~0.18.0"
   },
   "devDependencies": {

package/docs/AGENT_PROFILE_CONTRACT.md

@@ -1,189 +0,0 @@
-# Theorum Profile Specification
-
-A **Profile** is the deterministic, typed security and behavioral contract for an agent role in Theorum.
-
-Every profile strictly namespaces its capabilities across 6 functional domains:
-1. `identity` — Persona, display handle, and static base system prompts.
-2. `model` — Protocol, provider backend, model whitelist, thinking level, and controls.
-3. `tools` — Tool access ceiling.
-4. `inputs` — Strict ingress constraints (text, attachments, voice), file limits, and routing slots.
-5. `outputs` — Structured schemas, image, speech, streaming, and validation/auto-repair.
-6. `guardrails` — Rate limits, canary leak detection, content safety, and outbound disclosure policies.
-
-**Vocabulary:** Ingress audio is `inputs.voice`. Generated audio is `outputs.speech` (TTS voice id is `outputs.speech.voice`). Wire container formats for speech (`pcm` / `mp3`) may live in the kernel; vendor voice catalogs and image aspect/size vocabularies live in presets/apps.
-
----
-
-## 1. Authoring Shape
-
-Host apps should author profile definitions, not hand-build normalized runtime
-profiles. The minimum useful profile is:
-
-```typescript
-defineProfile({
-  id: 'host.agent',
-  model: {
-    allow: ['your-model-id'],
-    config: {
-      'your-model-id': {
-        apiId: 'provider-native-model-id',
-        thinking: { on: 'high', off: 'minimal' },
-        thinkingLevels: ['minimal', 'low', 'medium', 'high'],
-        summaries: { on: 'auto', off: 'none' },
-        maxOutputTokens: 8192,
-        temperature: 1,
-        keyBuiltins: [],
-      },
-    },
-  },
-});
-```
-
-Everything except `id`, `model.allow`, and `model.config` is optional at authoring time:
-
-```typescript
-export type ProfileDefinition = {
-  id: ProfileId;
-  identity?: Partial<Profile['identity']>;
-  model: Partial<Profile['model']> & Pick<Profile['model'], 'allow' | 'config'>;
-  tools?: Partial<Profile['tools']>;
-  inputs?: Partial<Profile['inputs']>;
-  outputs?: Partial<Profile['outputs']>;
-  guardrails?: Partial<Profile['guardrails']>;
-};
-```
-
-`defineProfile()` and `registerProfile()` normalize this shape into a complete
-runtime `Profile`.
-
-## 2. Runtime Type Definition
-
-```typescript
-export interface Profile {
-  /** Unique host-defined profile identifier. */
-  id: ProfileId;
-
-  /** 1. Identity & Persona */
-  identity: {
-    handle: string;
-    chat?: boolean;
-    system?: string;
-    systemByRole?: Record<string, string>;
-  };
-
-  /** 2. Model & Execution Bounds */
-  model: {
-    protocol: 'geminiInteractions' | 'openAi';
-    provider: 'google' | 'openrouter';
-    allow: ModelId[];
-    /** Host-owned wire config for every id in `allow`. */
-    config: Record<ModelId, ModelSpec>;
-    select?: Record<string, ModelId>;
-    thinking?: ThinkingLevel | Record<string, ThinkingLevel>;
-    controls?: ControlId[];
-    maxSteps?: number;
-    key?: GeminiFreeBucket;
-  };
-
-  /** 3. Tools Envelope */
-  tools: {
-    allow: ToolId[];
-  };
-
-  /** 4. Ingress (Input constraints & slots) */
-  inputs: {
-    text?: boolean;
-    attachments?: { accept: string[] };
-    voice?: { accept: string[] };
-    maxFiles?: number;
-    maxBytes?: number;
-    maxTurnBytes?: number;
-    limitsByMime?: Record<string, number>;
-    slots?: Record<string, string[]>;
-  };
-
-  /** 5. Outputs (Structured output, image, speech, validation, streaming) */
-  outputs: {
-    structured?: StructuredSchemaId | StructuredBySlot | null;
-    /** Pins for an image-role profile. Model id lives on `model`. */
-    image?: ProfileImageSpec;
-    /** Pins for a speech-role profile. Model id lives on `model`. */
-    speech?: ProfileSpeechSpec;
-    validation?: ProfileValidationSpec;
-    streaming?: ProfileStreamingSpec;
-  };
-
-  /** 6. Guardrails (Policies & safety boundaries) */
-  guardrails: {
-    quota?: { perDay: number };
-    canary?: boolean;
-    sanitizeInput?: boolean;
-    redactSensitive?: boolean;
-    egress?: ProfileEgressSpec;
-  };
-}
-```
-
----
-
-## 3. Field Reference
-
-### `identity`
-- `identity.handle`: Public-facing display handle for the persona.
-- `identity.chat`: Flag marking whether this profile participates in interactive chat.
-- `identity.system`: Base system prompt block. Fenced and bound by Theorum guardrails.
-- `identity.systemByRole`: Role-specialized system prompts (e.g., `{ reviewer: '...', drafter: '...' }`).
-
-### `model`
-- `model.protocol`: Wire framing protocol (`'geminiInteractions'` for Google Interactions API, `'openAi'` for OpenAI/OpenRouter compatible chat completions API).
-- `model.provider`: Provider execution backend (`'google'` or `'openrouter'`).
-- `model.allow`: Whitelist of host-defined `ModelId`s for this profile. THEORUM does not ship model names.
-- `model.config`: Host-owned `ModelSpec` map keyed by the same ids as `allow` / `select` (`apiId`, thinking levels, tokens, `keyBuiltins`, optional per-model `key`, etc.).
-- `model.select`: Named model mappings (e.g. `{ fast: 'flash', deep: 'pro' }` — ids are host-defined).
-- `model.thinking`: Pinned thinking level (`'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'`) when not user-controllable. Each model’s accepted subset is declared on `ModelSpec.thinkingLevels`.
-- `model.controls`: User-togglable controls on this profile (e.g. `['thinking']`).
-- `model.maxSteps`: Step limit on autonomous tool loops (1 = one-shot; >1 = autonomous tool loop).
-- `model.key`: Default Gemini vault slot for this profile (`'freeA' | 'freeB' | 'freeC'`). Overflow uses `'paid'`.
-
-### `ModelSpec` (host-owned, per id in `config`)
-- `apiId` / optional `openRouterId`: Provider-native wire ids.
-- `keyBuiltins`: Builtins that may use `profile.model.key`. Any other enabled builtin selects the overflow vault slot. Host policy — THEORUM does not infer tool pricing.
-- `key`: Optional vault slot override for this model (e.g. pin an image model to `'paid'`). When set, wins over profile key and builtin routing.
-
-### `tools`
-- `tools.allow`: Whitelist of tool IDs permitted to run under this profile. Calls to unlisted tools are blocked at the kernel boundary.
-- Harness tools (`askUser`) ship with THEORUM and are always in the catalog.
-- Provider builtins (e.g. Google search/maps/urlContext) are registered by optional presets such as `theorum/presets/google` via `registerGooglePreset()`.
-
-### `inputs`
-- `inputs.text`: Boolean flag accepting user text input.
-- `inputs.attachments`: Allowed mime types for uploaded file attachments.
-- `inputs.voice`: Allowed mime types for recorded audio clips (ingress only).
-- `inputs.maxFiles`: Maximum number of files permitted per message.
-- `inputs.maxBytes`: Maximum byte size permitted per single file.
-- `inputs.maxTurnBytes`: Maximum total byte size permitted across all files in one turn.
-- `inputs.limitsByMime`: Granular per-MIME byte limits (e.g. `{ 'application/pdf': 50 * 1024 * 1024, 'video/*': 100 * 1024 * 1024 }`).
-- `inputs.slots`: Allowed values for dynamic routing slots. Image-role overrides use `slots.aspectRatio` / `slots.size`.
-
-### `outputs`
-- `outputs.structured`: Structured JSON schema specification (or slot-based schema routing).
-- `outputs.image`: Pins for an image-role profile (`aspectRatio`, `size`, `mimeType`, optional `allowsGrounding`, `maxInputImages`). The image model itself is selected via `model.allow` / `model.config`. Slot overrides use `slots.aspectRatio` / `slots.size` when the profile lists allowlists under `inputs.slots`. Adapters map `size` to provider wire keys (e.g. Google Interactions `imageSize`).
-- `outputs.speech`: Pins for a speech-role profile (`voice`, optional `format: 'pcm' | 'mp3'`). The speech model itself is selected via `model.allow` / `model.config`. Bind with `createProvider(profile, …)` — same door as chat/image. `geminiInteractions` uses Interactions (`response_format: audio` + `speech_config`); `openAi`/`openrouter` speech roles use `/audio/speech` with the same `openRouter` credentials. `format: 'pcm'` (default) yields WAV media on both. `format: 'mp3'` is only valid on `openAi` speech — Interactions rejects it at resolve.
-- `outputs.validation`: Schema-driven in-harness auto-correction. Required vs optional comes only from the structured JSON Schema. Host `fields` validators (dotted paths such as `diagram.mermaid`) run for required paths and for optional paths that are present. Omitted optional paths are skipped. Setting `validation` without a structured `jsonSchema` is an error.
-- `outputs.streaming`: SSE streaming behaviors (`streamThoughts`, `gateMedia`). `gateMedia` holds stream `media` events until validation/egress. With validation only, thought and text still stream live (structured is held until accepted). With egress enforcement, user-visible thought/text stay buffered until the egress gate passes.
-
-### `guardrails`
-- `guardrails.quota.perDay`: Optional daily turn quota enforced per client IP. If omitted, quota enforcement is explicitly `not_configured`.
-- `guardrails.canary`: Enable unique token canary leak interception (default `true`).
-- `guardrails.sanitizeInput`: Run prompt injection / jailbreak redaction on ingress text (default `true`).
-- `guardrails.redactSensitive`: Redact SSN, credit cards, IP addresses, API keys from inputs (default `true`).
-- `guardrails.egress`: Generic outbound disclosure control engine (`enforce`, `onBlock: 'reject_to_agent' | 'refuse_to_user'`, `maxRetries`, `repairGuidance`). Runs deterministic auto-repair loops for chat or immediate in-character refusal when blocking egress on voice-input turns.
-
-### Per-turn Interactions state
-- `TurnRequest.input`: Optional turn input object. If omitted, Theorum normalizes it to an empty input and still runs the profile/provider turn.
-- `TurnRequest.signal`: Optional `AbortSignal`. When aborted, THEORUM stops the turn and cancels in-flight provider HTTP (Gemini fetch, OpenRouter `abortSignal`, speech fetch). Traces mark `cancelled: true`.
-- `TurnRequest.previousInteractionId`: Optional Google Interactions server-side conversation pointer. Theorum passes it through as `previous_interaction_id` for profiles using `geminiInteractions`.
-- `TurnRequest.store`: Optional Google Interactions storage override. If omitted, Theorum does not send `store`; provider/project policy remains the authority. If supplied, Theorum serializes the explicit boolean.
-
-### Grounding events
-- `TurnEvent.type: 'grounding'`: Provider evidence passthrough for Google Search / Maps grounding. The event carries raw `groundingMetadata`, raw `groundingChunks`, optional search widget HTML, and lightweight `sources` for maps/web URIs. Host apps own domain-specific interpretation, such as store cards or citation display.