theorum 0.1.15 → 1.1.3

package/esm/src/providers/openrouter/openai/image-payload.js

@@ -0,0 +1,90 @@
+/**
+ * OpenAI-compatible image generation payloads.
+ *
+ * Maps kernel `ImageResponseFormat` pins to the `/images` REST body shared by
+ * OpenRouter and other OpenAI-compat gateways.
+ *
+ * @module
+ */
+import { TheorumError } from '../../../guardrails/error.js';
+import { isMediaRefPart } from '../../../kernel/interaction-parts.js';
+export function extractPromptText(input) {
+    return input
+        .filter((part) => part.type === 'text')
+        .map((part) => (part.type === 'text' ? part.text : ''))
+        .join('\n')
+        .trim();
+}
+export function outputFormatFromMime(mimeType) {
+    const essence = mimeType.toLowerCase().replace(/^image\//, '');
+    if (essence === 'jpg') {
+        return 'jpeg';
+    }
+    if (essence === 'png' || essence === 'jpeg' || essence === 'webp') {
+        return essence;
+    }
+    return 'png';
+}
+export function wireInputReference(part) {
+    return {
+        type: 'image_url',
+        image_url: { url: `data:${part.mimeType};base64,${part.data}` },
+    };
+}
+export function wireInputReferences(input) {
+    const references = [];
+    for (const part of input) {
+        if (part.type !== 'image') {
+            continue;
+        }
+        if (isMediaRefPart(part)) {
+            throw new TheorumError('media references are not supported on openAi');
+        }
+        references.push(wireInputReference(part));
+    }
+    return references;
+}
+export function attachImagePins(payload, image) {
+    if (image.aspectRatio) {
+        payload.aspect_ratio = image.aspectRatio;
+    }
+    if (image.size) {
+        payload.resolution = image.size;
+    }
+    if (image.mimeType) {
+        payload.output_format = outputFormatFromMime(image.mimeType);
+    }
+}
+/** Build a POST `/images` body for native image-generation models. */
+export function buildImagesPayload(req) {
+    if (!req.image) {
+        throw new Error('buildImagesPayload requires req.image');
+    }
+    const payload = {
+        model: req.apiId,
+        prompt: extractPromptText(req.input),
+    };
+    attachImagePins(payload, req.image);
+    const references = wireInputReferences(req.input);
+    if (references.length > 0) {
+        payload.input_references = references;
+    }
+    if (req.stream === false) {
+        payload.stream = false;
+    }
+    return payload;
+}
+/** Tool parameters for gateways that generate images inside chat completions. */
+export function imageToolParameters(image) {
+    const params = {};
+    if (image.mimeType) {
+        params.output_format = outputFormatFromMime(image.mimeType);
+    }
+    if (image.aspectRatio) {
+        params.aspect_ratio = image.aspectRatio;
+    }
+    if (image.size) {
+        params.resolution = image.size;
+    }
+    return params;
+}

package/esm/src/providers/openrouter/openai/sdk-messages.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Convert THEORUM turn input into Vercel AI SDK `ModelMessage[]`.
+ *
+ * Semantic twin of `openai/compat.ts` (REST wire format). OpenRouter's AI SDK
+ * adapter uses this module; local and payload paths use `buildChatMessages`.
+ *
+ * @module
+ */
+import type { ModelMessage } from 'ai';
+import type { InteractionPart, ProviderCompleteRequest, TurnHistoryMessage } from '../../../kernel/types.js';
+export declare function sdkPart(input: InteractionPart): Record<string, unknown>;
+export declare function sdkContentFromParts(parts: InteractionPart[]): string | Array<Record<string, unknown>>;
+export declare function sdkContentFromOptionalParts(parts: InteractionPart[] | undefined, text: string | undefined): string | Array<Record<string, unknown>>;
+export declare function toolResultMessage(msg: TurnHistoryMessage): ModelMessage;
+export declare function assistantToolCallMessage(msg: TurnHistoryMessage): ModelMessage | null;
+export declare function contentHistoryMessage(msg: TurnHistoryMessage): ModelMessage;
+export declare function historyToSdk(msg: TurnHistoryMessage): ModelMessage | null;
+/**
+ * Build AI SDK messages for history + user input.
+ * Caller supplies `req.system` via `streamText({ instructions })`.
+ */
+export declare function buildAiSdkMessages(req: ProviderCompleteRequest): ModelMessage[];

package/esm/src/providers/openrouter/openai/sdk-messages.js

@@ -0,0 +1,122 @@
+/**
+ * Convert THEORUM turn input into Vercel AI SDK `ModelMessage[]`.
+ *
+ * Semantic twin of `openai/compat.ts` (REST wire format). OpenRouter's AI SDK
+ * adapter uses this module; local and payload paths use `buildChatMessages`.
+ *
+ * @module
+ */
+import { TheorumError } from '../../../guardrails/error.js';
+import { isMediaRefPart } from '../../../kernel/interaction-parts.js';
+import { fallbackToolCallId, parseToolInput } from './compat.js';
+function inlineMediaPart(part) {
+    if (isMediaRefPart(part)) {
+        throw new TheorumError('media references are not supported on openAi');
+    }
+    return part;
+}
+function stringDefault(value, fallback) {
+    return value === undefined ? fallback : value;
+}
+export function sdkPart(input) {
+    if (input.type === 'text') {
+        return { type: 'text', text: input.text };
+    }
+    const part = inlineMediaPart(input);
+    if (part.type === 'image') {
+        return {
+            type: 'image',
+            image: `data:${part.mimeType};base64,${part.data}`,
+        };
+    }
+    return { type: 'file', mediaType: part.mimeType, data: part.data };
+}
+export function sdkContentFromParts(parts) {
+    if (parts.every((part) => part.type === 'text')) {
+        return parts
+            .map((part) => (part.type === 'text' ? part.text : ''))
+            .filter(Boolean)
+            .join('\n');
+    }
+    return parts.map(sdkPart);
+}
+export function sdkContentFromOptionalParts(parts, text) {
+    if (!parts || parts.length === 0) {
+        return stringDefault(text, '');
+    }
+    return sdkContentFromParts(parts);
+}
+export function toolResultMessage(msg) {
+    const toolName = stringDefault(msg.name, 'tool');
+    const toolCallId = stringDefault(msg.tool_call_id, fallbackToolCallId(msg.name));
+    const output = msg.parts && msg.parts.length > 0
+        ? {
+            type: 'content',
+            value: msg.parts.map((input) => {
+                if (input.type === 'text') {
+                    return { type: 'text', text: input.text };
+                }
+                // image / audio / video / document — AI SDK tool-result file parts
+                const part = inlineMediaPart(input);
+                return {
+                    type: 'file',
+                    mediaType: part.mimeType,
+                    data: { type: 'data', data: part.data },
+                };
+            }),
+        }
+        : { type: 'text', value: stringDefault(msg.content, '') };
+    // AI SDK ToolModelMessage is a branded union; structural tool-result is correct at runtime.
+    return {
+        role: 'tool',
+        content: [
+            {
+                type: 'tool-result',
+                toolCallId,
+                toolName,
+                output,
+            },
+        ],
+    };
+}
+export function assistantToolCallMessage(msg) {
+    if (!msg.tool_calls || msg.tool_calls.length === 0) {
+        return null;
+    }
+    return {
+        role: 'assistant',
+        content: msg.tool_calls.map((call) => ({
+            type: 'tool-call',
+            toolCallId: call.id,
+            toolName: call.function.name,
+            input: parseToolInput(call.function.arguments),
+        })),
+    };
+}
+export function contentHistoryMessage(msg) {
+    const content = sdkContentFromOptionalParts(msg.parts, msg.content);
+    return { role: msg.role, content };
+}
+export function historyToSdk(msg) {
+    if (msg.role === 'tool') {
+        return toolResultMessage(msg);
+    }
+    return assistantToolCallMessage(msg) || contentHistoryMessage(msg);
+}
+/**
+ * Build AI SDK messages for history + user input.
+ * Caller supplies `req.system` via `streamText({ instructions })`.
+ */
+export function buildAiSdkMessages(req) {
+    const messages = [];
+    for (const msg of req.history ?? []) {
+        const wired = historyToSdk(msg);
+        if (wired) {
+            messages.push(wired);
+        }
+    }
+    if (req.input.length > 0) {
+        messages.push({ role: 'user', content: sdkContentFromParts(req.input) });
+    }
+    return messages;
+}

package/esm/src/providers/openrouter/resolve-api-key.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolve an API key from an OpenAI-gateway config using an optional vault slot.
+ *
+ * @module
+ */
+import type { KeySlot } from '../../kernel/types.js';
+import type { OpenAiGatewayConfig } from '../types.js';
+/** Pick the credential for this turn from vault[keySlot] or flat apiKey. */
+export declare function resolveOpenAiGatewayApiKey(config: OpenAiGatewayConfig, keySlot: KeySlot | undefined): string;

package/esm/src/providers/openrouter/resolve-api-key.js

@@ -0,0 +1,24 @@
+/**
+ * Resolve an API key from an OpenAI-gateway config using an optional vault slot.
+ *
+ * @module
+ */
+import { TheorumError, UPSTREAM_FAILED } from '../../guardrails/error.js';
+/** Pick the credential for this turn from vault[keySlot] or flat apiKey. */
+export function resolveOpenAiGatewayApiKey(config, keySlot) {
+    if (keySlot !== undefined) {
+        if (!config.vault) {
+            throw new TheorumError('openAiGateway.vault is required when keySlot is set');
+        }
+        const fromVault = config.vault[keySlot]?.trim();
+        if (!fromVault) {
+            throw new TheorumError(UPSTREAM_FAILED);
+        }
+        return fromVault;
+    }
+    const flat = config.apiKey?.trim();
+    if (!flat) {
+        throw new TheorumError('openAiGateway.apiKey is required when keySlot is omitted');
+    }
+    return flat;
+}

package/esm/src/providers/openrouter/speech.d.ts

@@ -0,0 +1,23 @@
+/**
+ * OpenAI-compatible `/audio/speech` transport (internal).
+ *
+ * Hosts use `createProvider(profile, { openAiGateway })` — this module is selected
+ * when the profile is an openAi speech role. Not a separate public door.
+ *
+ * @module
+ */
+import type { InteractionPart, ModelProvider, ProfileSpeechSpec, ProviderCompleteRequest, SpeechAudioFormat, TurnEvent } from '../../kernel/types.js';
+import type { OpenAiGatewayConfig } from '../types.js';
+/** Credentials for the openAi speech path — gateway config + optional voice. */
+export type SpeechProviderConfig = OpenAiGatewayConfig & {
+    /** Fallback TTS voice when the profile does not pin `speech.voice`. */
+    voice?: string;
+};
+export declare function extractInputText(input: InteractionPart[]): string;
+export declare function buildSpeechHeaders(apiKey: string, config: SpeechProviderConfig): Record<string, string>;
+export declare function buildPayload(req: ProviderCompleteRequest, text: string, speech: ProfileSpeechSpec | undefined, configVoice?: string): Record<string, unknown>;
+export declare function requestSpeech(apiKey: string, text: string, req: ProviderCompleteRequest, config: SpeechProviderConfig): Promise<Response>;
+export declare function yieldSpeechSuccess(rawBytes: Uint8Array, text: string, format?: SpeechAudioFormat, contentType?: string | null): Generator<TurnEvent>;
+export declare function streamSpeech(req: ProviderCompleteRequest, config?: SpeechProviderConfig): AsyncGenerator<TurnEvent>;
+/** Internal ModelProvider for openAi speech roles. */
+export declare function createSpeechProvider(config?: SpeechProviderConfig): ModelProvider;

package/esm/src/providers/{speech.js → openrouter/speech.js}

@@ -1,84 +1,68 @@
 /**
  * OpenAI-compatible `/audio/speech` transport (internal).
  *
- * Hosts use `createProvider(profile, { openRouter })` — this module is selected
+ * Hosts use `createProvider(profile, { openAiGateway })` — this module is selected
  * when the profile is an openAi speech role. Not a separate public door.
  *
  * @module
  */
-import { toErrorEvent } from '../guardrails/error.js';
-import { exposeForTests } from './expose-for-tests.js';
-import { wrapPcmAsWav } from './pcm.js';
+import { toErrorEvent } from '../../guardrails/error.js';
+import { bytesToBase64, wrapPcmAsWav } from '../shared/pcm.js';
+import { openAiGatewayHeaders } from './openai/compat.js';
+import { resolveOpenAiGatewayApiKey } from './resolve-api-key.js';
 const HTTP_OK = 200;
-function bytesToBase64(bytes) {
-    let bin = '';
-    for (let i = 0; i < bytes.length; i++)
-        bin += String.fromCharCode(bytes[i]);
-    return btoa(bin);
-}
-function extractInputText(input) {
+export function extractInputText(input) {
     return input
         .filter((p) => p.type === 'text')
         .map((p) => (p.type === 'text' ? p.text : ''))
         .join(' ')
         .trim();
 }
-function resolveSpeechWireModel(req) {
-    if (req.openRouterId) {
-        return req.openRouterId;
-    }
-    if (req.apiId.includes('/')) {
-        return req.apiId;
-    }
-    if (req.apiId) {
-        return `google/${req.apiId}`;
-    }
-    return String(req.model);
-}
-function buildHeaders(apiKey, config) {
+export function buildSpeechHeaders(apiKey, config) {
     const headers = {
         Authorization: `Bearer ${apiKey}`,
         'Content-Type': 'application/json',
     };
-    if (config.siteUrl) {
-        headers['HTTP-Referer'] = config.siteUrl;
-    }
-    if (config.siteName) {
-        headers['X-Title'] = config.siteName;
-    }
+    const gateway = openAiGatewayHeaders(config);
+    if (gateway)
+        Object.assign(headers, gateway);
     return headers;
 }
-function buildPayload(req, text, speech, configVoice) {
+export function buildPayload(req, text, speech, configVoice) {
     const voice = speech?.voice ?? configVoice;
-    const format = speech?.format ?? 'pcm';
     const payload = {
-        model: resolveSpeechWireModel(req),
+        model: req.apiId,
         input: text,
-        response_format: format,
     };
+    if (speech?.format) {
+        payload.response_format = speech.format;
+    }
     if (voice) {
         payload.voice = voice;
     }
     return payload;
 }
-async function requestSpeech(apiKey, text, req, config) {
+export async function requestSpeech(apiKey, text, req, config) {
     const fetchFn = config.fetch ?? fetch;
     const baseUrl = config.baseUrl?.replace(/\/+$/, '') ?? 'https://openrouter.ai/api/v1';
     const url = `${baseUrl}/audio/speech`;
     return await fetchFn(url, {
         method: 'POST',
-        headers: buildHeaders(apiKey, config),
+        headers: buildSpeechHeaders(apiKey, config),
         body: JSON.stringify(buildPayload(req, text, req.speech, config.voice)),
         signal: req.signal,
     });
 }
-function* yieldSpeechSuccess(rawBytes, text, format) {
-    let mediaMime = 'audio/mpeg';
+export function* yieldSpeechSuccess(rawBytes, text, format, contentType) {
+    let mediaMime = contentType?.split(';')[0]?.trim() || 'application/octet-stream';
     let mediaBytes = rawBytes;
     if (format === 'pcm') {
         mediaMime = 'audio/wav';
         mediaBytes = wrapPcmAsWav(rawBytes);
     }
+    else if (format === 'mp3') {
+        mediaMime = 'audio/mpeg';
+    }
     yield {
         type: 'media',
         media: { mimeType: mediaMime, data: bytesToBase64(mediaBytes) },
@@ -91,10 +75,13 @@ function* yieldSpeechSuccess(rawBytes, text, format) {
     };
     yield { type: 'done' };
 }
-async function* streamSpeech(req, config = {}) {
-    const apiKey = config.apiKey?.trim() || undefined;
-    if (!apiKey) {
-        yield toErrorEvent('missing API key for speech');
+export async function* streamSpeech(req, config = {}) {
+    let apiKey;
+    try {
+        apiKey = resolveOpenAiGatewayApiKey(config, req.keySlot);
+    }
+    catch (err) {
+        yield toErrorEvent(err);
         return;
     }
     const text = extractInputText(req.input);
@@ -113,24 +100,14 @@ async function* streamSpeech(req, config = {}) {
         yield toErrorEvent('no audio returned from speech');
         return;
     }
-    const format = req.speech?.format ?? 'pcm';
-    for (const ev of yieldSpeechSuccess(rawBytes, text, format)) {
+    const format = req.speech?.format;
+    for (const ev of yieldSpeechSuccess(rawBytes, text, format, res.headers.get('content-type'))) {
         yield ev;
     }
 }
 /** Internal ModelProvider for openAi speech roles. */
-function createSpeechProvider(config = {}) {
+export function createSpeechProvider(config = {}) {
     return {
         complete: (req) => streamSpeech(req, config),
     };
 }
-export { createSpeechProvider, streamSpeech };
-exposeForTests('speech', {
-    bytesToBase64,
-    extractInputText,
-    resolveSpeechWireModel,
-    buildHeaders,
-    buildPayload,
-    requestSpeech,
-    yieldSpeechSuccess,
-});

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

@@ -0,0 +1 @@
+export declare function markModuleLoad(label: string): void;

package/esm/src/providers/probe.js

@@ -0,0 +1,22 @@
+/**
+ * Import-isolation probe for `createProvider`'s lazy adapter loader.
+ *
+ * Only `create-provider.ts` calls this. Adapters must not import it.
+ * When `THEORUM_IMPORT_PROBE=1`, writes `LOADED:<label>` to stdout once per
+ * lazy load so subprocess tests can assert adapters stay unloaded until
+ * `complete` runs. No-op in normal hosts.
+ *
+ * @module
+ */
+import * as dntShim from "../../_dnt.shims.js";
+export function markModuleLoad(label) {
+    try {
+        const d = dntShim.dntGlobalThis.Deno;
+        if (d?.env?.get('THEORUM_IMPORT_PROBE') === '1' && d.stdout?.writeSync) {
+            d.stdout.writeSync(new TextEncoder().encode(`LOADED:${label}\n`));
+        }
+    }
+    catch {
+        // Non-Deno runtime or missing --allow-env.
+    }
+}

package/esm/src/providers/shared/pcm.d.ts

@@ -0,0 +1,12 @@
+/**
+ * PCM → WAV helpers shared by speech transports.
+ *
+ * @module
+ */
+export declare function writeAscii(view: DataView, offset: number, str: string): void;
+/** Decode base64 ASCII string to raw byte array. */
+export declare function base64ToBytes(data: string): Uint8Array;
+/** Encode raw byte array to base64 ASCII string. */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/** Wrap raw PCM bytes in a RIFF/WAVE container. */
+export declare function wrapPcmAsWav(pcm: Uint8Array, sampleRate?: number): Uint8Array;

package/esm/src/providers/{pcm.js → shared/pcm.js}

@@ -3,12 +3,26 @@
  *
  * @module
  */
-import { exposeForTests } from './expose-for-tests.js';
 const SAMPLE_RATE = 24000;
-function writeAscii(view, offset, str) {
+export function writeAscii(view, offset, str) {
     for (let i = 0; i < str.length; i++)
         view.setUint8(offset + i, str.charCodeAt(i));
 }
+/** Decode base64 ASCII string to raw byte array. */
+export function base64ToBytes(data) {
+    const bin = atob(data);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++)
+        out[i] = bin.charCodeAt(i);
+    return out;
+}
+/** Encode raw byte array to base64 ASCII string. */
+export function bytesToBase64(bytes) {
+    let bin = '';
+    for (let i = 0; i < bytes.length; i++)
+        bin += String.fromCharCode(bytes[i]);
+    return btoa(bin);
+}
 /** Wrap raw PCM bytes in a RIFF/WAVE container. */
 export function wrapPcmAsWav(pcm, sampleRate = SAMPLE_RATE) {
     const numChannels = 1;
@@ -34,4 +48,3 @@ export function wrapPcmAsWav(pcm, sampleRate = SAMPLE_RATE) {
     new Uint8Array(buf, 44).set(pcm);
     return new Uint8Array(buf);
 }
-exposeForTests('pcm', { writeAscii, wrapPcmAsWav });

package/esm/src/providers/shared/sse.d.ts

@@ -0,0 +1,18 @@
+export declare function asObject(parsed: unknown): Record<string, unknown> | undefined;
+export declare function dataRecord(raw: string, sseEvent: string): Record<string, unknown>;
+export declare function takeSsePayloads(buffer: string, pendingEvent?: string): {
+    rest: string;
+    payloads: Record<string, unknown>[];
+    pendingEvent: string;
+};
+/**
+ * Async SSE stream chunk reader built on `takeSsePayloads`.
+ * Yields every raw payload record (including `sse_done` and `sse_unparsed`).
+ */
+export declare function readSseChunks(body: ReadableStream<Uint8Array>): AsyncGenerator<Record<string, unknown>>;
+/**
+ * Generic async SSE stream parser built on `readSseChunks`.
+ * Yields parsed JSON objects from `data:` lines; silently skips malformed
+ * payloads and terminates on `[DONE]`.
+ */
+export declare function parseSseStream(body: ReadableStream<Uint8Array>): AsyncGenerator<Record<string, unknown>>;

package/esm/src/providers/shared/sse.js

@@ -0,0 +1,87 @@
+const DATA_PREFIX = 'data: ';
+const EVENT_PREFIX = 'event: ';
+const DONE = '[DONE]';
+export function asObject(parsed) {
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        return parsed;
+    }
+    return undefined;
+}
+export function dataRecord(raw, sseEvent) {
+    const data = raw.slice(DATA_PREFIX.length).trim();
+    const row = {};
+    if (sseEvent) {
+        row.sseEvent = sseEvent;
+    }
+    if (!data || data === DONE) {
+        row.eventType = 'sse_done';
+        return row;
+    }
+    try {
+        const parsed = JSON.parse(data);
+        const obj = asObject(parsed);
+        if (obj) {
+            return { ...obj, ...row };
+        }
+        row.eventType = 'sse_unparsed';
+        row.data = parsed;
+        return row;
+    }
+    catch {
+        row.eventType = 'sse_unparsed';
+        row.data = data;
+        return row;
+    }
+}
+export function takeSsePayloads(buffer, pendingEvent = '') {
+    const payloads = [];
+    const chunks = buffer.split('\n');
+    const rest = chunks.pop() ?? '';
+    let sseEvent = pendingEvent;
+    for (const line of chunks) {
+        if (line.startsWith(EVENT_PREFIX)) {
+            sseEvent = line.slice(EVENT_PREFIX.length).trim();
+        }
+        else if (line.startsWith(DATA_PREFIX)) {
+            payloads.push(dataRecord(line, sseEvent));
+            sseEvent = '';
+        }
+    }
+    return { rest, payloads, pendingEvent: sseEvent };
+}
+/**
+ * Async SSE stream chunk reader built on `takeSsePayloads`.
+ * Yields every raw payload record (including `sse_done` and `sse_unparsed`).
+ */
+export async function* readSseChunks(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let pendingEvent = '';
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const result = takeSsePayloads(buffer, pendingEvent);
+        buffer = result.rest;
+        pendingEvent = result.pendingEvent;
+        for (const payload of result.payloads) {
+            yield payload;
+        }
+    }
+}
+/**
+ * Generic async SSE stream parser built on `readSseChunks`.
+ * Yields parsed JSON objects from `data:` lines; silently skips malformed
+ * payloads and terminates on `[DONE]`.
+ */
+export async function* parseSseStream(body) {
+    for await (const payload of readSseChunks(body)) {
+        if (payload.eventType === 'sse_done')
+            return;
+        if (payload.eventType === 'sse_unparsed')
+            continue;
+        yield payload;
+    }
+}

package/esm/src/providers/shared/tool-args.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared tool-argument JSON parsing for all provider adapters.
+ *
+ * Malformed or non-object JSON is a hard failure — never invent `{}` or `{ _raw }`.
+ *
+ * @module
+ */
+export type ParsedToolArguments = {
+    ok: true;
+    value: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+    raw: string;
+};
+/** Parse provider / history tool-call arguments. */
+export declare function parseToolArgumentsObject(raw: unknown): ParsedToolArguments;