@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/computer-access/computer/windows-native-script.js

@@ -0,0 +1,157 @@
+/** Shared native declarations and strict mechanical decoding for the one-shot helper. */
+export const WINDOWS_NATIVE_SCRIPT = String.raw `
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Web.Script.Serialization;
+using System.Windows.Automation;
+
+public static partial class AbotComputer {
+  static readonly JavaScriptSerializer Json = new JavaScriptSerializer { MaxJsonLength=15000000, RecursionLimit=64 };
+  const int ImageMaxBytes=10485760;
+  [StructLayout(LayoutKind.Sequential)] struct Rect { public int Left,Top,Right,Bottom; }
+  [StructLayout(LayoutKind.Sequential)] struct Point { public int X,Y; }
+  [StructLayout(LayoutKind.Sequential)] struct Luid { public uint Low; public int High; }
+  [StructLayout(LayoutKind.Sequential)] struct TokenStatistics {
+    public Luid TokenId,AuthenticationId; public long ExpirationTime;
+    public int TokenType,ImpersonationLevel; public uint DynamicCharged,DynamicAvailable,GroupCount,PrivilegeCount;
+    public Luid ModifiedId;
+  }
+  delegate bool EnumWindowCallback(IntPtr window,IntPtr parameter);
+  [DllImport("user32.dll")] static extern IntPtr GetForegroundWindow();
+  [DllImport("user32.dll")] static extern bool IsWindow(IntPtr window);
+  [DllImport("user32.dll")] static extern bool IsWindowVisible(IntPtr window);
+  [DllImport("user32.dll")] static extern bool IsIconic(IntPtr window);
+  [DllImport("user32.dll")] static extern bool GetWindowRect(IntPtr window,out Rect rectangle);
+  [DllImport("user32.dll")] static extern bool EnumWindows(EnumWindowCallback callback,IntPtr parameter);
+  [DllImport("user32.dll",CharSet=CharSet.Unicode)] static extern int GetWindowText(IntPtr window,StringBuilder text,int count);
+  [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr window,out uint processId);
+  [DllImport("user32.dll")] static extern int GetSystemMetrics(int index);
+  [DllImport("user32.dll")] static extern IntPtr OpenInputDesktop(uint flags,bool inherit,uint access);
+  [DllImport("user32.dll")] static extern bool CloseDesktop(IntPtr desktop);
+  [DllImport("user32.dll",CharSet=CharSet.Unicode)] static extern bool GetUserObjectInformation(IntPtr obj,int index,StringBuilder text,int size,out int required);
+  [DllImport("user32.dll")] static extern IntPtr SetThreadDpiAwarenessContext(IntPtr context);
+  [DllImport("user32.dll")] static extern bool SetProcessDPIAware();
+  [DllImport("user32.dll")] static extern bool SetForegroundWindow(IntPtr window);
+  [DllImport("user32.dll")] static extern bool ShowWindow(IntPtr window,int command);
+  [DllImport("user32.dll")] static extern short GetAsyncKeyState(int key);
+  [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
+  [DllImport("advapi32.dll",SetLastError=true)] static extern bool OpenProcessToken(IntPtr process,uint access,out IntPtr token);
+  [DllImport("advapi32.dll",SetLastError=true)] static extern bool GetTokenInformation(IntPtr token,int type,out TokenStatistics information,int length,out int needed);
+  [DllImport("dwmapi.dll")] static extern int DwmFlush();
+
+  sealed class ComputerFault : Exception {
+    public readonly string Code;
+    public ComputerFault(string code,string message):base(message) { Code=code; }
+  }
+  static Dictionary<string,object> Obj(params object[] pairs) {
+    var result=new Dictionary<string,object>();
+    for(int i=0;i<pairs.Length;i+=2) result.Add((string)pairs[i],pairs[i+1]);
+    return result;
+  }
+  static Dictionary<string,object> Record(object value) {
+    var result=value as Dictionary<string,object>;
+    if(result==null) throw new ComputerFault("computer_request_invalid","Expected a structured object.");
+    return result;
+  }
+  static object Field(Dictionary<string,object> value,string key) {
+    object result; return value.TryGetValue(key,out result)?result:null;
+  }
+  static string Text(Dictionary<string,object> value,string key,int limit) {
+    var result=Field(value,key) as string;
+    if(result==null || result.Length>limit) throw new ComputerFault("computer_request_invalid","Invalid text field: "+key);
+    return result;
+  }
+  static double Number(Dictionary<string,object> value,string key) {
+    object raw=Field(value,key);
+    if(!(raw is int) && !(raw is long) && !(raw is decimal) && !(raw is double))
+      throw new ComputerFault("computer_request_invalid","Invalid numeric field: "+key);
+    double result=Convert.ToDouble(raw);
+    if(Double.IsInfinity(result) || Double.IsNaN(result)) throw new ComputerFault("computer_request_invalid","Non-finite number.");
+    return result;
+  }
+  static int Integer(Dictionary<string,object> value,string key,int min,int max) {
+    double number=Number(value,key);
+    if(number!=Math.Truncate(number) || number<min || number>max)
+      throw new ComputerFault("computer_request_invalid","Out-of-range integer: "+key);
+    return (int)number;
+  }
+  static Dictionary<string,object> Rectangle(int x,int y,int width,int height) {
+    return Obj("x",x,"y",y,"width",width,"height",height);
+  }
+  static Rect ParseRectangle(object value) {
+    var data=Record(value);
+    int x=PhysicalPixel(data,"x",-131072,131072),y=PhysicalPixel(data,"y",-131072,131072);
+    int width=PhysicalPixel(data,"width",1,65536),height=PhysicalPixel(data,"height",1,65536);
+    return new Rect { Left=x,Top=y,Right=x+width,Bottom=y+height };
+  }
+  static int PhysicalPixel(Dictionary<string,object> data,string key,int min,int max) {
+    double number=Number(data,key);
+    if(number<min || number>max) throw new ComputerFault("computer_request_invalid","Invalid physical pixel field: "+key);
+    return (int)Math.Round(number);
+  }
+  static bool SameRectangle(Rect left,Rect right) {
+    if(left.Left!=right.Left) return false;
+    if(left.Top!=right.Top) return false;
+    if(left.Right!=right.Right) return false;
+    return left.Bottom==right.Bottom;
+  }
+  static bool ContainsRectangle(Rect outer,Rect inner) {
+    if(inner.Left<outer.Left || inner.Top<outer.Top) return false;
+    if(inner.Right>outer.Right || inner.Bottom>outer.Bottom) return false;
+    return inner.Right>inner.Left && inner.Bottom>inner.Top;
+  }
+  static bool HasExpiredAction(Dictionary<string,object> request) {
+    return DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()>Number(request,"deadlineEpochMs");
+  }
+  static void PreparePhysicalCoordinates() {
+    try { if(SetThreadDpiAwarenessContext(new IntPtr(-4))!=IntPtr.Zero) return; }
+    catch(EntryPointNotFoundException) {}
+    SetProcessDPIAware();
+  }
+  static void SetError(Dictionary<string,object> result,Exception error) {
+    if(result.ContainsKey("error")) return;
+    var fault=error as ComputerFault;
+    result["error"]=Obj("code",fault==null?"computer_native_failed":fault.Code,
+      "message",fault==null?"The native observation or input operation failed.":fault.Message);
+  }
+  public static string Run(string requestJson) {
+    Dictionary<string,object> result=UnavailableResult("computer_native_failed");
+    Dictionary<string,object> request=null;
+    DispatchState dispatch=null;
+    try {
+      request=Record(Json.DeserializeObject(requestJson));
+      string operation=Text(request,"operation",32);
+      if(operation!="inspect" && operation!="observe" && operation!="act")
+        throw new ComputerFault("computer_request_invalid","Unknown native operation.");
+      if(operation=="act") dispatch=new DispatchState();
+      PreparePhysicalCoordinates();
+      result=DesktopSnapshot();
+      if(operation=="inspect") return Json.Serialize(result);
+      if(operation=="observe") RequireObservationSource(request,result);
+      if(operation=="act") {
+        try {
+          Act(request,result,dispatch);
+          if(dispatch.Failure!=null) throw new ComputerFault(dispatch.Failure,"Input cleanup was not fully accepted by Windows.");
+        } catch(Exception error) { dispatch.Fail(error); SetError(result,error); }
+        object actionError=Field(result,"error");
+        result=DesktopSnapshot();
+        RequireObservationSource(request,result);
+        if(actionError!=null) result["error"]=actionError;
+        if(dispatch.Started) { try { DwmFlush(); } catch(DllNotFoundException) {} }
+      }
+      try { CaptureObservation(result,operation=="observe"?Field(request,"region"):null); }
+      catch(Exception error) { SetError(result,error); }
+    } catch(Exception error) { SetError(result,error); }
+    if(dispatch!=null) result["dispatch"]=dispatch.Result();
+    return Json.Serialize(result);
+  }
+}
+`;

package/dist/src/computer-access/computer/windows-result.d.ts

@@ -0,0 +1,4 @@
+import type { NativeComputerRequest, NativeComputerResult } from "./native-protocol.js";
+import { type WindowsHelperProcessResult } from "./windows-helper-process.js";
+export declare function windowsHelperUnavailable(request: NativeComputerRequest, reason: string, spawned: boolean): NativeComputerResult;
+export declare function decodeWindowsComputerResult(process: WindowsHelperProcessResult, request: NativeComputerRequest): NativeComputerResult;

package/dist/src/computer-access/computer/windows-result.js

@@ -0,0 +1,105 @@
+import { readNativeComputerResult } from "./native-validation.js";
+import { WINDOWS_IMAGE_MAX_BYTES } from "./windows-helper-process.js";
+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+export function windowsHelperUnavailable(request, reason, spawned) {
+    const capability = { supported: true, available: false, reason };
+    return {
+        desktop: {
+            platform: "windows", binding: "windows:unavailable", name: "Windows desktop",
+            available: false, reason, bounds: { x: 0, y: 0, width: 1, height: 1 },
+            capabilities: { capture: capability, accessibility: capability, input: capability, windows: capability },
+            targetingGuarantee: "observed_surface",
+        },
+        windows: [],
+        ...(request.operation === "act" ? {
+            dispatch: {
+                status: spawned ? "unknown" : "not_dispatched",
+                requestedInputCount: 0,
+                ...(spawned ? {} : { acceptedInputCount: 0 }),
+                reason: spawned ? "native_receipt_unavailable" : reason,
+            },
+        } : {}),
+        error: {
+            code: reason,
+            message: spawned && request.operation === "act"
+                ? "The Windows action receipt is unavailable. Input may have occurred; observe the desktop before another action. No action was replayed."
+                : "The Windows desktop helper is unavailable for this operation.",
+        },
+    };
+}
+export function decodeWindowsComputerResult(process, request) {
+    if (process.status !== "completed")
+        return windowsHelperUnavailable(request, `computer_helper_${process.status}`, process.spawned);
+    let result;
+    let image;
+    try {
+        const wire = JSON.parse(process.stdout.trim());
+        if (wire === null || typeof wire !== "object" || Array.isArray(wire))
+            throw new Error("invalid result");
+        const { image: nativeImage, ...metadata } = wire;
+        result = readNativeComputerResult(metadata);
+        image = nativeImage;
+        if (result.desktop.platform !== "windows")
+            throw new Error("wrong platform");
+        if (request.operation === "act" && !result.dispatch)
+            throw new Error("missing dispatch");
+    }
+    catch {
+        return windowsHelperUnavailable(request, "computer_helper_protocol_invalid", process.spawned);
+    }
+    try {
+        if (image === undefined) {
+            if (request.operation !== "inspect" && !result.error)
+                throw new Error("missing observation");
+            return result;
+        }
+        const bytes = decodeWindowsImage(image, result);
+        return { ...result, image: { mimeType: "image/png", bytes } };
+    }
+    catch {
+        if (result.dispatch)
+            return {
+                ...result,
+                error: {
+                    code: "computer_image_decode_failed",
+                    message: "The native input receipt is preserved, but the captured image is invalid or unavailable. Observe again before another action.",
+                },
+            };
+        return windowsHelperUnavailable(request, "computer_helper_protocol_invalid", process.spawned);
+    }
+}
+function decodeWindowsImage(value, result) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid image");
+    const image = value;
+    if (Object.keys(image).some((key) => key !== "mimeType" && key !== "base64"))
+        throw new Error("invalid image fields");
+    if (image.mimeType !== "image/png" || typeof image.base64 !== "string")
+        throw new Error("invalid image encoding");
+    if (image.base64.length > Math.ceil(WINDOWS_IMAGE_MAX_BYTES / 3) * 4)
+        throw new Error("image too large");
+    const bytes = Buffer.from(image.base64, "base64");
+    try {
+        validateWindowsImageBytes(bytes, image.base64, result);
+        return bytes;
+    }
+    catch (error) {
+        bytes.fill(0);
+        throw error;
+    }
+}
+function validateWindowsImageBytes(bytes, encoded, result) {
+    if (bytes.length > WINDOWS_IMAGE_MAX_BYTES || bytes.length < 33)
+        throw new Error("image size");
+    if (bytes.toString("base64") !== encoded)
+        throw new Error("noncanonical image encoding");
+    if (!bytes.subarray(0, 8).equals(PNG_SIGNATURE))
+        throw new Error("image signature");
+    if (bytes.readUInt32BE(8) !== 13 || bytes.toString("ascii", 12, 16) !== "IHDR")
+        throw new Error("image header");
+    const observation = result.observation;
+    if (!observation)
+        throw new Error("missing observation metadata");
+    if (bytes.readUInt32BE(16) !== observation.imageWidth || bytes.readUInt32BE(20) !== observation.imageHeight)
+        throw new Error("image dimensions disagree");
+}

package/dist/src/computer-access/computer/windows-topology-script.d.ts

@@ -0,0 +1,2 @@
+/** Monitor source arrangement is part of opaque desktop identity, not a new tool field. */
+export declare const WINDOWS_TOPOLOGY_SCRIPT: string;

package/dist/src/computer-access/computer/windows-topology-script.js

@@ -0,0 +1,80 @@
+/** Monitor source arrangement is part of opaque desktop identity, not a new tool field. */
+export const WINDOWS_TOPOLOGY_SCRIPT = String.raw `
+public static partial class AbotComputer {
+  [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Unicode)] struct CaptureMonitorInfo {
+    public int Size; public Rect Monitor,Work; public uint Flags;
+    [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] public string Device;
+  }
+  [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Unicode)] struct CaptureDisplayMode {
+    [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] public string DeviceName;
+    public ushort SpecVersion,DriverVersion,Size,DriverExtra; public uint Fields;
+    public int PositionX,PositionY; public uint Orientation,FixedOutput;
+    public short Color,Duplex,YResolution,TTOption,Collate;
+    [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] public string FormName;
+    public ushort LogPixels; public uint BitsPerPixel,PixelWidth,PixelHeight,DisplayFlags,Frequency;
+    public uint IcmMethod,IcmIntent,MediaType,DitherType,Reserved1,Reserved2,PanningWidth,PanningHeight;
+  }
+  delegate bool CaptureMonitorCallback(IntPtr monitor,IntPtr dc,ref Rect bounds,IntPtr data);
+  [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Unicode)] struct CaptureDisplayDevice {
+    public int Size;
+    [MarshalAs(UnmanagedType.ByValTStr,SizeConst=32)] public string Name;
+    [MarshalAs(UnmanagedType.ByValTStr,SizeConst=128)] public string Description;
+    public uint Flags;
+    [MarshalAs(UnmanagedType.ByValTStr,SizeConst=128)] public string InterfaceId;
+    [MarshalAs(UnmanagedType.ByValTStr,SizeConst=128)] public string RegistryKey;
+  }
+  [DllImport("user32.dll")] static extern bool EnumDisplayMonitors(IntPtr dc,IntPtr clip,CaptureMonitorCallback callback,IntPtr data);
+  [DllImport("user32.dll",CharSet=CharSet.Unicode)] static extern bool GetMonitorInfo(IntPtr monitor,ref CaptureMonitorInfo info);
+  [DllImport("user32.dll",CharSet=CharSet.Unicode)] static extern bool EnumDisplaySettingsEx(string device,int mode,ref CaptureDisplayMode settings,uint flags);
+  [DllImport("shcore.dll")] static extern int GetScaleFactorForMonitor(IntPtr monitor,out int scale);
+  [DllImport("user32.dll",CharSet=CharSet.Unicode)] static extern bool EnumDisplayDevices(string device,uint index,ref CaptureDisplayDevice info,uint flags);
+
+  static bool TryMonitorScale(IntPtr monitor,out int scale) {
+    scale=0;
+    try { return GetScaleFactorForMonitor(monitor,out scale)==0; }
+    catch(DllNotFoundException) { return false; }
+    catch(EntryPointNotFoundException) { return false; }
+  }
+
+  static string SourceFingerprint(List<string> records) {
+    records.Sort(StringComparer.Ordinal);
+    using(var hash=System.Security.Cryptography.SHA256.Create()) {
+      return BitConverter.ToString(hash.ComputeHash(Encoding.UTF8.GetBytes(Json.Serialize(records)))).Replace("-","").ToLowerInvariant();
+    }
+  }
+  static string MonitorSourceIds(string device) {
+    var sources=new List<string>();
+    for(uint index=0;index<128;index++) {
+      var info=new CaptureDisplayDevice { Size=Marshal.SizeOf(typeof(CaptureDisplayDevice)) };
+      if(!EnumDisplayDevices(device,index,ref info,1)) break;
+      if((info.Flags&1)==0) continue;
+      if(String.IsNullOrEmpty(info.InterfaceId)) return null;
+      sources.Add(info.InterfaceId);
+    }
+    if(sources.Count==0) return null;
+    return SourceFingerprint(sources);
+  }
+  static string ReadCaptureTopology() {
+    var records=new List<string>(); bool queryFailed=false;
+    CaptureMonitorCallback callback=delegate(IntPtr monitor,IntPtr dc,ref Rect bounds,IntPtr data) {
+      if(records.Count>=128) { queryFailed=true; return false; }
+      var info=new CaptureMonitorInfo { Size=Marshal.SizeOf(typeof(CaptureMonitorInfo)) };
+      if(!GetMonitorInfo(monitor,ref info)) { queryFailed=true; return false; }
+      var mode=new CaptureDisplayMode { Size=(ushort)Marshal.SizeOf(typeof(CaptureDisplayMode)) };
+      if(!EnumDisplaySettingsEx(info.Device,-1,ref mode,0)) { queryFailed=true; return false; }
+      int scale;
+      if(!TryMonitorScale(monitor,out scale)) { queryFailed=true; return false; }
+      string sources=MonitorSourceIds(info.Device);
+      if(sources==null) { queryFailed=true; return false; }
+      records.Add(Json.Serialize(new object[] {info.Device,monitor.ToInt64(),info.Monitor.Left,info.Monitor.Top,
+        info.Monitor.Right,info.Monitor.Bottom,info.Flags,mode.Orientation,mode.FixedOutput,
+        mode.PixelWidth,mode.PixelHeight,mode.PositionX,mode.PositionY,scale,sources}));
+      return true;
+    };
+    bool complete=EnumDisplayMonitors(IntPtr.Zero,IntPtr.Zero,callback,IntPtr.Zero);
+    if(!complete || queryFailed || records.Count==0)
+      throw new ComputerFault("computer_topology_unavailable","The monitor source arrangement could not be verified.");
+    return SourceFingerprint(records);
+  }
+}
+`;

package/dist/{plugins/system/source → src/computer-access}/handlers.d.ts

@@ -1,3 +1,3 @@
-import { type ToolImplementation } from "../../../src/plugin-sdk/index.js";
+import { type ToolImplementation } from "../plugin-sdk/index.js";
 import { type SystemProcessRunner, type SystemTarget, type SystemTargetId } from "./contracts.js";
 export declare function createSystemHandlers(run?: SystemProcessRunner, resolveTarget?: (id: SystemTargetId) => Promise<SystemTarget>): Record<string, ToolImplementation>;

package/dist/{plugins/system/source → src/computer-access}/handlers.js

@@ -1,4 +1,4 @@
-import { failureFromError, failureResult, readBoundedInteger, readOptionalString, successResult, } from "../../../src/plugin-sdk/index.js";
+import { failureFromError, failureResult, readBoundedInteger, readOptionalString, successResult, } from "../plugin-sdk/index.js";
 import { readSystemApplications } from "./application-catalog.js";
 import { systemApplicationObservation } from "./application-observation.js";
 import { observeSystemTargets } from "./target-observation.js";

package/dist/{plugins/system/source → src/computer-access}/host-evidence.d.ts

@@ -1,4 +1,4 @@
-import { type ToolImplementationOutput } from "../../../src/plugin-sdk/index.js";
+import { type ToolImplementationOutput } from "../plugin-sdk/index.js";
 import { type HostIdentity } from "./companion/protocol.js";
 /** Preserve execution provenance without publishing private connection identity. */
 export declare function attachHostEvidence(result: ToolImplementationOutput, _hostId: string, identity: HostIdentity): ToolImplementationOutput;

package/dist/{plugins/system/source → src/computer-access}/host-evidence.js

@@ -1,4 +1,4 @@
-import { enforcePluginResultByteBudget, } from "../../../src/plugin-sdk/index.js";
+import { enforcePluginResultByteBudget, } from "../plugin-sdk/index.js";
 import { isHostRecord } from "./companion/protocol.js";
 /** Preserve execution provenance without publishing private connection identity. */
 export function attachHostEvidence(result, _hostId, identity) {

package/dist/{plugins/system/source → src/computer-access}/process-result.d.ts

@@ -1,4 +1,4 @@
-import { type ToolImplementationOutput } from "../../../src/plugin-sdk/index.js";
+import { type ToolImplementationOutput } from "../plugin-sdk/index.js";
 import type { SystemApplication, SystemProcessResult, SystemTarget } from "./contracts.js";
 export type SystemEvidenceScope = "command_process_completion" | "launch_request_dispatch";
 export declare function systemProcessResult(target: SystemTarget, result: SystemProcessResult, evidenceScope: SystemEvidenceScope, application?: SystemApplication): ToolImplementationOutput;

package/dist/{plugins/system/source → src/computer-access}/process-result.js

@@ -1,4 +1,4 @@
-import { failureResult, successResult, } from "../../../src/plugin-sdk/index.js";
+import { failureResult, successResult, } from "../plugin-sdk/index.js";
 const STREAM_EXCERPT_CHARS = 2_000;
 const IDENTITY_EXCERPT_CHARS = 512;
 const LEGACY_EVIDENCE_LABELS = {

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)) {