@abot-ai/runtime 1.3.1 → 1.5.0

package/dist/src/computer-access/target-observation.js

@@ -0,0 +1,29 @@
+import { observeSystemHost } from "./host-observation.js";
+import { runSystemProcess } from "./process-runner.js";
+import { resolveSystemTarget } from "./targets.js";
+export async function observeSystemTargets(run = runSystemProcess) {
+    const observations = [];
+    for (const id of ["linux", "macos", "windows"]) {
+        try {
+            const target = await resolveSystemTarget(id, run);
+            observations.push({
+                ...target,
+                available: true,
+                commandExecutionAvailable: true,
+                guiSessionStatus: "not_checked",
+            });
+        }
+        catch (error) {
+            observations.push({
+                id,
+                available: false,
+                reason: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return {
+        host: observeSystemHost(),
+        availabilityScope: "command_execution_only",
+        targets: observations,
+    };
+}

package/dist/src/computer-access/targets.d.ts

@@ -0,0 +1,8 @@
+import { type SystemProcessRunner, type SystemTarget, type SystemTargetId } from "./contracts.js";
+export declare function powershellArguments(script: string): string[];
+export declare function powershellLiteral(value: string): string;
+export declare function shellLiteral(value: string): string;
+export declare function windowsSystemCommandScript(command: string, cwd: string): string;
+export declare function findExecutable(name: string, additional?: readonly string[]): Promise<string | undefined>;
+export declare function resolveSystemTarget(id: SystemTargetId, run?: SystemProcessRunner): Promise<SystemTarget>;
+export declare function readSystemTargetId(value: unknown): SystemTargetId;

package/dist/src/computer-access/targets.js

@@ -0,0 +1,101 @@
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { delimiter, join } from "node:path";
+import { SystemOperationError, } from "./contracts.js";
+import { runSystemProcess } from "./process-runner.js";
+import { isWslHostRuntime, readSystemHostFacts } from "./host-observation.js";
+export function powershellArguments(script) {
+    const preamble = "$ErrorActionPreference='Stop';[Console]::OutputEncoding=[Text.UTF8Encoding]::new();$global:LASTEXITCODE=0;";
+    return [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-EncodedCommand",
+        Buffer.from(preamble + script, "utf16le").toString("base64"),
+    ];
+}
+export function powershellLiteral(value) {
+    return "'" + value.replaceAll("'", "''") + "'";
+}
+export function shellLiteral(value) {
+    return "'" + value.replaceAll("'", "'\"'\"'") + "'";
+}
+export function windowsSystemCommandScript(command, cwd) {
+    return `Set-Location -LiteralPath ${powershellLiteral(cwd)};${command}\nif ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }`;
+}
+export async function findExecutable(name, additional = []) {
+    const candidates = [
+        ...additional,
+        ...(process.env.PATH ?? "")
+            .split(delimiter)
+            .filter(Boolean)
+            .map((directory) => join(directory, name)),
+    ];
+    for (const candidate of candidates) {
+        try {
+            await access(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            /* next observed candidate */
+        }
+    }
+    return undefined;
+}
+export async function resolveSystemTarget(id, run = runSystemProcess) {
+    if (isNativeUnixTarget(id))
+        return resolveNativeUnixTarget(id);
+    if (id !== "windows")
+        throw new SystemOperationError("system_target_unavailable", `The runtime is not executing on ${id}.`);
+    const nativeWindows = process.platform === "win32";
+    const wslWindows = isWslHostRuntime(readSystemHostFacts());
+    if (!hasWindowsExecutionTransport(nativeWindows, wslWindows))
+        throw new SystemOperationError("system_target_unavailable", "No Windows execution transport is available on this host.");
+    const canonicalShell = nativeWindows
+        ? join(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+        : "/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe";
+    const shell = await findExecutable("powershell.exe", [canonicalShell]);
+    if (!shell)
+        throw new SystemOperationError("system_target_unavailable", "A native Windows PowerShell executable was not found; Windows interop is unavailable.");
+    const probe = await run({
+        executable: shell,
+        args: powershellArguments("[Environment]::OSVersion.Platform.ToString()"),
+        timeoutMs: 5_000,
+    });
+    if (!hasObservedWindowsPlatform(probe))
+        throw new SystemOperationError("system_target_unavailable", "Windows PowerShell could not execute. WSL executable interop may be disabled; enable a real Windows execution transport on the host.");
+    return { id, transport: nativeWindows ? "native" : "wsl_interop", shell };
+}
+export function readSystemTargetId(value) {
+    if (value === "linux" || value === "macos" || value === "windows")
+        return value;
+    throw new SystemOperationError("system_target_required", "Select an explicit target returned by system_targets: linux, macos, or windows.");
+}
+function isNativeUnixTarget(id) {
+    if (id === "linux")
+        return process.platform === "linux";
+    if (id === "macos")
+        return process.platform === "darwin";
+    return false;
+}
+async function resolveNativeUnixTarget(id) {
+    try {
+        await access("/bin/bash", constants.X_OK);
+    }
+    catch {
+        throw new SystemOperationError("system_target_unavailable", "The native target has no executable /bin/bash.");
+    }
+    return { id, transport: "native", shell: "/bin/bash" };
+}
+function hasWindowsExecutionTransport(nativeWindows, wslWindows) {
+    if (nativeWindows)
+        return true;
+    return wslWindows;
+}
+function hasObservedWindowsPlatform(probe) {
+    if (probe.status !== "completed")
+        return false;
+    if (probe.exitCode !== 0)
+        return false;
+    return probe.stdout.trim() === "Win32NT";
+}

package/dist/src/model-gateway/client/chat.js

@@ -1,4 +1,5 @@
 import { traceDebug } from "../../runtime/observability/debug-logger.js";
+import { permitsModelContentTrace } from "../observability/content-trace-policy.js";
 import { buildModelInvocationMetrics } from "./invocation-metrics.js";
 import { buildChatGatewayRequestBody, resolveMetricMessages, resolveRequestMessages, } from "./message-projection.js";
 import { resolveClientOptions } from "./options.js";
@@ -42,9 +43,11 @@ export async function invokeModelGatewayWithOptions(params, options = {}) {
             requestId,
             status: response.status,
             bodyLength: errorText.length,
-            bodyPreview: errorText.slice(0, 400),
+            ...(permitsModelContentTrace(params.modelStep, params.messages)
+                ? { bodyPreview: errorText.slice(0, 400) }
+                : { contentOmitted: true }),
         });
-        throw new Error(`bridge_request_failed:${response.status}:${errorText || "empty error body"}`);
+        throw new Error(`bridge_request_failed:${response.status}:${permitsModelContentTrace(params.modelStep, params.messages) ? errorText || "empty error body" : "content omitted"}`);
     }
     if (!response.body) {
         traceDebug("model-gateway.client", "chat.response.no_body", {

package/dist/src/model-gateway/client/input-token-count.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { traceDebug } from "../../runtime/observability/debug-logger.js";
+import { toolMediaSafeMessage } from "../observability/tool-media-privacy.js";
 import { buildChatGatewayRequestBody, resolveRequestMessages, } from "./message-projection.js";
 import { resolveClientOptions } from "./options.js";
 const INPUT_TOKEN_COUNT_CACHE_MAX_ENTRIES = 64;
@@ -93,7 +94,7 @@ export async function countModelGatewayInputTokensWithOptions(params, options =
     });
     if (!response.ok) {
         const errorText = await response.text().catch(() => "");
-        throw new Error(`bridge_input_token_count_failed:${response.status}:${errorText || "empty error body"}`);
+        throw new Error(`bridge_input_token_count_failed:${response.status}:${toolMediaSafeMessage(errorText || "empty error body", requestMessages)}`);
     }
     const result = parseInputTokenCountResult(await response.json().catch(() => undefined));
     if (result.provider !== provider) {

package/dist/src/model-gateway/client/message-projection.js

@@ -88,6 +88,7 @@ function toRequestMessage(message) {
             content: message.content,
             toolCallId: message.toolCallId,
             toolName: message.toolName,
+            ...(message.attachments?.length ? { attachments: message.attachments } : {}),
         };
     }
     const attachments = normalizeMessageAttachments(message.attachments);

package/dist/src/model-gateway/client/raw.js

@@ -3,6 +3,8 @@ import { traceDebug } from "../../runtime/observability/debug-logger.js";
 import { normalizeModelTokenUsage } from "../protocol/usage.js";
 import { buildModelInvocationMetrics } from "./invocation-metrics.js";
 import { resolveClientOptions } from "./options.js";
+import { permitsModelContentTrace } from "../observability/content-trace-policy.js";
+import { toolMediaSafeMessage } from "../observability/tool-media-privacy.js";
 export async function invokeRawModelGatewayWithOptions(params, options = {}) {
     const clientOptions = resolveClientOptions(options);
     const url = clientOptions.baseUrl;
@@ -59,9 +61,9 @@ export async function invokeRawModelGatewayWithOptions(params, options = {}) {
             requestId,
             status: response.status,
             bodyLength: errorText.length,
-            bodyPreview: errorText.slice(0, 400),
+            ...(permitsModelContentTrace(modelStep, params.prompt) ? { bodyPreview: errorText.slice(0, 400) } : { contentOmitted: true }),
         });
-        throw new Error(`bridge_raw_failed:${response.status}:${errorText || "empty error body"}`);
+        throw new Error(`bridge_raw_failed:${response.status}:${toolMediaSafeMessage(errorText || "empty error body", params.prompt)}`);
     }
     const parsed = await response.json().catch(() => ({}));
     const text = typeof parsed?.text === "string" ? parsed.text : "";
@@ -77,7 +79,7 @@ export async function invokeRawModelGatewayWithOptions(params, options = {}) {
         ...(providerCompletionReason !== undefined
             ? { providerCompletionReason }
             : {}),
-        outputPreview: text.slice(0, 300),
+        ...(permitsModelContentTrace(modelStep, params.prompt) ? { outputPreview: text.slice(0, 300) } : { contentOmitted: true }),
         ...(providerUsage ? { usage: providerUsage } : {}),
     });
     traceDebug("runtime.model", "model.invocation.metrics", buildModelInvocationMetrics({

package/dist/src/model-gateway/observability/content-trace-policy.d.ts

@@ -0,0 +1,2 @@
+/** Short-lived observations never enter raw model input/output logs. */
+export declare function permitsModelContentTrace(modelStep: unknown, input?: unknown): boolean;

package/dist/src/model-gateway/observability/content-trace-policy.js

@@ -0,0 +1,7 @@
+import { containsRequestToolMedia } from "./tool-media-privacy.js";
+/** Short-lived observations never enter raw model input/output logs. */
+export function permitsModelContentTrace(modelStep, input) {
+    if (modelStep === "learning.batch")
+        return false;
+    return !containsRequestToolMedia(input);
+}

package/dist/src/model-gateway/observability/provider-trace.js

@@ -1,5 +1,7 @@
 import { createProviderTraceContext, serializeProviderError, } from "./provider-trace-context.js";
 import { isModelIoTraceEnabled, traceModelIo } from "./trace-store.js";
+import { permitsModelContentTrace } from "./content-trace-policy.js";
+import { toolMediaSafeError } from "./tool-media-privacy.js";
 function sanitizeProviderHeaders(headers) {
     const credentialHeaders = new Set([
         "authorization",
@@ -49,6 +51,7 @@ async function captureProviderResponse(context, response, decodeResponse) {
 }
 export async function fetchProviderWithTrace(params) {
     const traceEnabled = isModelIoTraceEnabled();
+    const contentTraceEnabled = permitsModelContentTrace(params.requestBody.modelStep, params.requestBody);
     const context = createProviderTraceContext(params);
     const serializedBody = JSON.stringify(params.payload);
     if (traceEnabled) {
@@ -59,7 +62,12 @@ export async function fetchProviderWithTrace(params) {
                 url: params.url,
                 method: "POST",
                 headers: sanitizeProviderHeaders(params.headers),
-                body: params.payload,
+                body: contentTraceEnabled
+                    ? params.payload
+                    : {
+                        contentOmitted: true,
+                        byteLength: Buffer.byteLength(serializedBody),
+                    },
             },
         });
     }
@@ -71,7 +79,7 @@ export async function fetchProviderWithTrace(params) {
         });
         return {
             response,
-            responseTrace: traceEnabled
+            responseTrace: traceEnabled && contentTraceEnabled
                 ? captureProviderResponse(context, response, params.decodeResponse)
                 : Promise.resolve(),
         };
@@ -82,9 +90,14 @@ export async function fetchProviderWithTrace(params) {
                 event: "provider.failure",
                 ...context,
                 stage: "request.fetch",
-                error: serializeProviderError(error),
+                error: contentTraceEnabled
+                    ? serializeProviderError(error)
+                    : {
+                        name: "Error",
+                        message: "Ephemeral evidence provider request failed; content omitted.",
+                    },
             });
         }
-        throw error;
+        throw toolMediaSafeError(error, params.requestBody);
     }
 }

package/dist/src/model-gateway/observability/tool-media-privacy.d.ts

@@ -0,0 +1,6 @@
+import type { ModelGatewayEvent } from "../types.js";
+/** Detect typed request-only evidence before any model-content diagnostic sink. */
+export declare function containsRequestToolMedia(value: unknown, depth?: number): boolean;
+export declare function toolMediaSafeError(error: unknown, input: unknown): unknown;
+export declare function toolMediaSafeMessage(message: string, input: unknown): string;
+export declare function toolMediaSafeEvent(event: ModelGatewayEvent, input: unknown): ModelGatewayEvent;

package/dist/src/model-gateway/observability/tool-media-privacy.js

@@ -0,0 +1,50 @@
+import { ModelProviderContextWindowExceededError, ModelProviderEnvelopeInspectionError, } from "./context-window-guard.js";
+/** Detect typed request-only evidence before any model-content diagnostic sink. */
+export function containsRequestToolMedia(value, depth = 0) {
+    if (depth > 40)
+        return false;
+    if (typeof value === "string") {
+        const text = value.trim();
+        // Serialized evidence may be embedded in a larger, human-readable prompt.
+        // Fail closed for diagnostics; this marker never drives model actions.
+        if (text.includes('"tool_image_v1"') || text.includes('\\"tool_image_v1\\"'))
+            return true;
+        if (!text.startsWith("{") && !text.startsWith("["))
+            return false;
+        try {
+            return containsRequestToolMedia(JSON.parse(text), depth + 1);
+        }
+        catch {
+            return false;
+        }
+    }
+    if (!value || typeof value !== "object")
+        return false;
+    if (Array.isArray(value))
+        return value.some((item) => containsRequestToolMedia(item, depth + 1));
+    const item = value;
+    if (item.kind === "tool_image_v1" || item.toolEvidence !== undefined)
+        return true;
+    return Object.values(item).some((entry) => containsRequestToolMedia(entry, depth + 1));
+}
+export function toolMediaSafeError(error, input) {
+    if (!containsRequestToolMedia(input))
+        return error;
+    // Preserve trusted admission contracts without retaining mutable error data.
+    if (error instanceof ModelProviderContextWindowExceededError) {
+        return new ModelProviderContextWindowExceededError();
+    }
+    if (error instanceof ModelProviderEnvelopeInspectionError) {
+        return new ModelProviderEnvelopeInspectionError();
+    }
+    const safe = new Error("tool_media_provider_error: content omitted");
+    if (error instanceof Error && error.name === "AbortError")
+        safe.name = "AbortError";
+    return safe;
+}
+export function toolMediaSafeMessage(message, input) {
+    return containsRequestToolMedia(input) ? "tool_media_provider_error: content omitted" : message;
+}
+export function toolMediaSafeEvent(event, input) {
+    return event.type === "error" ? { ...event, error: toolMediaSafeMessage(event.error, input) } : event;
+}

package/dist/src/model-gateway/protocol/message-contract.js

@@ -7,6 +7,7 @@ const TOOL_RESULT_MESSAGE_KEYS = new Set([
     "content",
     "toolCallId",
     "toolName",
+    "attachments",
 ]);
 const ATTACHMENT_KEYS = new Set([
     "id",
@@ -16,6 +17,7 @@ const ATTACHMENT_KEYS = new Set([
     "name",
     "size",
     "data",
+    "toolEvidence",
 ]);
 export class ModelGatewayMessageValidationError extends Error {
     constructor(code) {
@@ -57,7 +59,17 @@ function isStrictAttachment(value) {
             (typeof value.size === "number" &&
                 Number.isFinite(value.size) &&
                 value.size >= 0)) &&
-        (value.data === undefined || typeof value.data === "string"));
+        (value.data === undefined || typeof value.data === "string") &&
+        isToolEvidenceBinding(value.toolEvidence));
+}
+function isToolEvidenceBinding(value) {
+    if (value === undefined)
+        return true;
+    if (!isRecord(value))
+        return false;
+    if (Object.keys(value).some((key) => key !== "executionId"))
+        return false;
+    return typeof value.executionId === "string" && value.executionId.length > 0;
 }
 export function isModelGatewayToolCall(value) {
     if (!isRecord(value) || !hasOnlyKeys(value, TOOL_CALL_KEYS)) {
@@ -89,7 +101,9 @@ export function isToolResultMessage(value) {
         typeof value.toolCallId === "string" &&
         value.toolCallId.trim().length > 0 &&
         typeof value.toolName === "string" &&
-        MODEL_GATEWAY_TOOL_NAME_PATTERN.test(value.toolName));
+        MODEL_GATEWAY_TOOL_NAME_PATTERN.test(value.toolName) &&
+        (value.attachments === undefined ||
+            (Array.isArray(value.attachments) && value.attachments.every((attachment) => isStrictAttachment(attachment) && attachment.toolEvidence?.executionId === value.toolCallId))));
 }
 export function isTextChatMessage(value) {
     if (!isRecord(value)) {

package/dist/src/model-gateway/providers/ollama/adapter.js

@@ -1,4 +1,5 @@
 import { fetchProviderWithTrace } from "../../model-io-trace.js";
+import { toolMediaSafeError, toolMediaSafeMessage } from "../../observability/tool-media-privacy.js";
 import { buildOllamaPayload, buildOllamaRawPayload, } from "./payload.js";
 import { emitOllamaRequestProjection, emitOllamaSchemaDiagnostics, emitOllamaTiming, resolveOllamaBaseUrl, } from "./request-diagnostics.js";
 import { createOllamaStreamDiagnostics, isAbortFailure, } from "./stream-diagnostics.js";
@@ -56,7 +57,7 @@ export function createOllamaProviderAdapter(options) {
                 return {
                     kind: "error",
                     statusCode: response.status || 502,
-                    message: message || "ollama error",
+                    message: toolMediaSafeMessage(message || "ollama error", params.requestBody),
                 };
             }
             const streamDiagnostics = createOllamaStreamDiagnostics({
@@ -79,8 +80,8 @@ export function createOllamaProviderAdapter(options) {
                         }
                         catch (error) {
                             outcome = resolveFailureOutcome(error);
-                            failure = error;
-                            throw error;
+                            failure = toolMediaSafeError(error, params.requestBody);
+                            throw failure;
                         }
                         finally {
                             streamDiagnostics.terminate(outcome, failure);
@@ -107,8 +108,8 @@ export function createOllamaProviderAdapter(options) {
             }
             catch (error) {
                 outcome = resolveFailureOutcome(error);
-                failure = error;
-                throw error;
+                failure = toolMediaSafeError(error, params.requestBody);
+                throw failure;
             }
             finally {
                 streamDiagnostics.terminate(outcome, failure);

package/dist/src/model-gateway/providers/ollama/message-projection.js

@@ -53,10 +53,12 @@ export function toOllamaMessage(message) {
         };
     }
     if (isToolResultMessage(message)) {
+        const images = message.attachments?.map(readImageData).filter((data) => Boolean(data));
         return {
             role: "tool",
             tool_name: message.toolName,
             content: message.content,
+            ...(images?.length ? { images } : {}),
         };
     }
     const textMessage = readTextMessageWithAttachments(message);

package/dist/src/model-gateway/providers/openai/adapter.js

@@ -1,4 +1,5 @@
 import { fetchProviderWithTrace } from "../../model-io-trace.js";
+import { toolMediaSafeError, toolMediaSafeEvent, toolMediaSafeMessage } from "../../observability/tool-media-privacy.js";
 import { emitOpenAIMessageOutputDiagnostic, emitOpenAISchemaDiagnostics, emitOpenAIStreamTermination, hasStructuredTextFormat, resolveOpenAIStreamFailureOutcome, } from "./diagnostics.js";
 import { countOpenAIInputTokens } from "./input-token-count.js";
 import { buildOpenAIResponsesPayload, collectOpenAIResponsesStream, forwardOpenAIResponsesStream, resolveOpenAIProviderSettings, } from "./protocol.js";
@@ -6,7 +7,7 @@ import { embedWithOpenAI } from "./embeddings.js";
 export function createOpenAIProviderAdapter() {
     return Object.freeze({
         type: "openai",
-        supportsImageInput: false,
+        supportsImageInput: true,
         embed: embedWithOpenAI,
         countInputTokens: countOpenAIInputTokens,
         async invoke(params) {
@@ -50,7 +51,7 @@ export function createOpenAIProviderAdapter() {
                 return {
                     kind: "error",
                     statusCode: response.status || 502,
-                    message: message || "openai error",
+                    message: toolMediaSafeMessage(message || "openai error", params.requestBody),
                 };
             }
             const streamStartedAt = Date.now();
@@ -62,12 +63,14 @@ export function createOpenAIProviderAdapter() {
                         let outcome = "completed";
                         let failure;
                         try {
-                            await forwardOpenAIResponsesStream(body, writer, streamOptions);
+                            await forwardOpenAIResponsesStream(body, {
+                                emit: (event) => writer.emit(toolMediaSafeEvent(event, params.requestBody)),
+                            }, streamOptions);
                         }
                         catch (error) {
                             outcome = resolveOpenAIStreamFailureOutcome(error);
-                            failure = error;
-                            throw error;
+                            failure = toolMediaSafeError(error, params.requestBody);
+                            throw failure;
                         }
                         finally {
                             emitOpenAIStreamTermination({
@@ -99,8 +102,8 @@ export function createOpenAIProviderAdapter() {
             }
             catch (error) {
                 outcome = resolveOpenAIStreamFailureOutcome(error);
-                failure = error;
-                throw error;
+                failure = toolMediaSafeError(error, params.requestBody);
+                throw failure;
             }
             finally {
                 emitOpenAIStreamTermination({

package/dist/src/model-gateway/providers/openai/image-content.d.ts

@@ -0,0 +1,8 @@
+import type { ModelGatewayAttachment } from "../../types.js";
+/** Responses supports text/image content in messages and function outputs. */
+export declare function openAIImageContents(attachments: readonly ModelGatewayAttachment[] | undefined): {
+    type: "input_image";
+    image_url: string;
+    detail: "auto";
+}[];
+export declare function projectOpenAIImageMessage(value: unknown): unknown;

package/dist/src/model-gateway/providers/openai/image-content.js

@@ -0,0 +1,28 @@
+/** Responses supports text/image content in messages and function outputs. */
+export function openAIImageContents(attachments) {
+    return (attachments ?? []).map((attachment) => {
+        if (attachment.kind !== "image" || !attachment.data)
+            throw new Error("model_gateway_image_data_unavailable");
+        return {
+            type: "input_image",
+            image_url: `data:${attachment.mimeType};base64,${attachment.data}`,
+            detail: "auto",
+        };
+    });
+}
+export function projectOpenAIImageMessage(value) {
+    if (!value || typeof value !== "object")
+        return value;
+    const message = value;
+    if (!message.attachments?.length)
+        return value;
+    if (typeof message.role !== "string" || typeof message.content !== "string")
+        throw new Error("model_gateway_image_message_invalid");
+    return {
+        role: message.role,
+        content: [
+            { type: "input_text", text: message.content },
+            ...openAIImageContents(message.attachments),
+        ],
+    };
+}

package/dist/src/model-gateway/providers/openai/input-token-count.js

@@ -1,6 +1,7 @@
 import { createProviderEnvelopeFingerprint } from "../envelope-budget.js";
 import { buildOpenAIInputTokenCountPayload } from "./payload.js";
 import { resolveOpenAIProviderSettings } from "./settings.js";
+import { toolMediaSafeError, toolMediaSafeMessage } from "../../observability/tool-media-privacy.js";
 function readInputTokenCount(body) {
     const isRecord = body !== null && typeof body === "object" && !Array.isArray(body);
     if (!isRecord) {
@@ -29,13 +30,13 @@ export async function countOpenAIInputTokens(params) {
             Authorization: `Bearer ${settings.apiKey}`,
         },
         body: JSON.stringify(payload),
-    });
+    }).catch((error) => { throw toolMediaSafeError(error, params.requestBody); });
     if (!response.ok) {
         const message = await response.text().catch(() => "");
         return {
             kind: "error",
             statusCode: response.status || 502,
-            message: message || "openai input token count error",
+            message: toolMediaSafeMessage(message || "openai input token count error", params.requestBody),
         };
     }
     const body = await response.json().catch(() => undefined);

package/dist/src/model-gateway/providers/openai/payload.js

@@ -1,4 +1,5 @@
 import { resolveModelStepOutputTokenLimit } from "../../../shared/model-step-registry.js";
+import { openAIImageContents, projectOpenAIImageMessage } from "./image-content.js";
 import { isAssistantToolCallMessage, isToolResultMessage, validateModelGatewayMessages, } from "../../protocol/message-contract.js";
 import { resolveModelInvocation } from "../../policy/invocation-policy.js";
 import { projectOpenAIResponsesFormat, resolveModelGatewayFormat, } from "../../structured-output/projection.js";
@@ -48,11 +49,13 @@ function projectOpenAIInputItems(input) {
                 {
                     type: "function_call_output",
                     call_id: item.toolCallId,
-                    output: item.content,
+                    output: item.attachments?.length
+                        ? [{ type: "input_text", text: item.content }, ...openAIImageContents(item.attachments)]
+                        : item.content,
                 },
             ];
         }
-        return [item];
+        return [projectOpenAIImageMessage(item)];
     });
 }
 function resolveInputWithProviderInstructions(requestBody, providerInstructions) {

package/dist/src/model-gateway/server/configuration.js

@@ -27,7 +27,10 @@ export function resolveModelGatewayPort(environment = process.env) {
     return Number(parsedUrl.port || "80");
 }
 export function configureModelGateway(options) {
-    const runtimeConfig = loadRuntimeConfig({ rootDir: process.cwd() });
+    const runtimeConfig = loadRuntimeConfig({
+        rootDir: options.rootDir ?? process.cwd(),
+        configPath: options.configPath,
+    });
     const modelPolicy = options.modelPolicy ??
         createRequestModelPolicy({
             platformPolicy: runtimeConfig.models,

package/dist/src/model-gateway/server/contracts.d.ts

@@ -11,6 +11,8 @@ export type ModelGatewayInvocationContext = Readonly<{
     abortSignal?: AbortSignal;
 }>;
 export type ModelGatewayHandlerOptions = {
+    rootDir?: string;
+    configPath?: string;
     fetchImpl?: GatewayFetch;
     modelPolicy?: ModelGatewayPolicyConfig;
     ollamaUrl?: string;

package/dist/src/model-gateway/types.d.ts

@@ -29,12 +29,16 @@ export type ChatToolResultMessage = Readonly<{
     content: string;
     toolCallId: string;
     toolName: string;
-    attachments?: never;
+    attachments?: ModelGatewayAttachment[];
     toolCalls?: never;
 }>;
 export type ChatMessage = ChatTextMessage | ChatAssistantToolCallMessage | ChatToolResultMessage;
 export type ModelGatewayAttachment = RuntimeAttachmentReference & {
     data?: string;
+    /** Request-local tool evidence; never persist or trace this attachment. */
+    toolEvidence?: Readonly<{
+        executionId: string;
+    }>;
 };
 export type ModelGatewayJsonSchemaFormat = {
     type: "json_schema";

package/dist/src/plugin-contract/entrypoint.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedRuntimeToolPath, RuntimeToolPathError, RuntimeToolPathErrorCode, RuntimeToolPathLocation, RuntimeToolPathResolver, ToolAvailabilityEntry, ToolCall, ToolCallAdapter, ToolCallAdapterInput, ToolCatalogGroup, ToolDefinition, ToolExecutionContext, ToolImplementation, ToolImplementationOutput } from "../capabilities/tool-types.js";
+import type { ResolvedRuntimeToolPath, RuntimeToolPathError, RuntimeToolPathErrorCode, RuntimeToolPathLocation, RuntimeToolPathResolver, ToolAvailabilityEntry, ToolCall, ToolCallAdapter, ToolCallAdapterInput, ToolCatalogGroup, ToolDefinition, ToolExecutionContext, ToolImplementation, ToolImplementationOutput, ToolModuleDeclaration, ToolModuleRequestPreparation } from "../capabilities/tool-types.js";
 import type { ToolNormalInvocationContract } from "../capabilities/normal-invocation/contracts.js";
 export type RuntimePluginLoadContext = {
     id: string;
@@ -27,8 +27,10 @@ export type RuntimePluginLoadContext = {
 export type RuntimePluginEntrypoint = Readonly<{
     handlers: Readonly<Record<string, ToolImplementation>>;
     adapters?: Readonly<Record<string, ToolCallAdapter>>;
+    /** Observe availability once before any model sees this request's catalog. */
+    prepareRequest?: ToolModuleRequestPreparation;
 }>;
 export type RuntimePluginEntrypointFactory = (context: RuntimePluginLoadContext & Readonly<{
     pluginRoot: string;
 }>) => RuntimePluginEntrypoint;
-export type { ResolvedRuntimeToolPath, RuntimeToolPathError, RuntimeToolPathErrorCode, RuntimeToolPathLocation, RuntimeToolPathResolver, ToolAvailabilityEntry, ToolCall, ToolCallAdapter, ToolCallAdapterInput, ToolCatalogGroup, ToolDefinition, ToolExecutionContext, ToolImplementation, ToolImplementationOutput, ToolNormalInvocationContract, };
+export type { ResolvedRuntimeToolPath, RuntimeToolPathError, RuntimeToolPathErrorCode, RuntimeToolPathLocation, RuntimeToolPathResolver, ToolAvailabilityEntry, ToolCall, ToolCallAdapter, ToolCallAdapterInput, ToolCatalogGroup, ToolDefinition, ToolExecutionContext, ToolImplementation, ToolImplementationOutput, ToolModuleDeclaration, ToolModuleRequestPreparation, ToolNormalInvocationContract, };