dsh-zen-remote 2.2.1 → 2.2.3

package/src/intercept.ts

@@ -84,6 +84,7 @@ import type { RelayClient, RelayClock, RelayState } from './relay-client.js'
 import { checkGatewayShape } from './intercept-shape.js'
 import type { GatewayShapeCheck } from './intercept-shape.js'
 import { fromVirtual, isVirtual, toVirtual } from './virtual-id.js'
+import { INVOKE_BINARY_RESULT_METHODS, extractResultAttachments, restoreInvokeBinary, type ResultAttachment } from './invoke-binary.js'
 import {
   createControlMerger,
   createWorkspaceMerger,
@@ -240,7 +241,7 @@ export const CLIENT_METHOD_FIELDS: Readonly<Record<string, readonly SessionField
  * envelope WE construct carries `details: {}` (the host rpcFailure's
  * fallback). */
 export type DispatchEnvelope =
-  | { ok: true; value: unknown }
+  | { ok: true; value: unknown; attachments?: ResultAttachment[] }
   | { ok: false; error: { code: string; message?: string; details: Record<string, unknown> } }
 
 /**
@@ -2699,7 +2700,26 @@ export function installIntercept(options: InstallInterceptOptions): InterceptHan
       // The session answered: any closed-session entry for it is stale
       // (re-shared and served again) — the banner may go.
       clearClosed(virtuals)
-      return { ok: true, value: rewriteResult(endpoint, value, serverId) }
+      // 2026-10-14: a binary-result method's answer arrives marker-encoded
+      // (invoke-binary.ts) — the relay's JSON channel cannot carry a typed
+      // array, so the server marked it and the caller's own zod validation
+      // needs the real Uint8Array back.
+      const restored = INVOKE_BINARY_RESULT_METHODS.has(endpoint) ? restoreInvokeBinary(value) : value
+      // 2026-10-14 (root cause, live-probed): dispatchRpc's envelope contract
+      // carries Uint8Arrays in the ATTACHMENTS side channel (dsh-api-gateway
+      // encodeRpcResult) — value positions become null and the renderer
+      // re-attaches by path. A raw typed array in the value dies on the
+      // background→browser bridge (JSON), which is exactly the remote image
+      // preview's "expected Uint8Array" zod failure. Restore, then re-extract.
+      if (INVOKE_BINARY_RESULT_METHODS.has(endpoint)) {
+        const extracted = extractResultAttachments(restored)
+        return {
+          ok: true,
+          value: rewriteResult(endpoint, extracted.value, serverId),
+          ...(extracted.attachments.length > 0 ? { attachments: extracted.attachments } : {}),
+        }
+      }
+      return { ok: true, value: rewriteResult(endpoint, restored, serverId) }
     } catch (error) {
       const code = error instanceof RelayError ? error.code : 'internal'
       recordFailure(endpoint, code)
@@ -3192,6 +3212,9 @@ export function installIntercept(options: InstallInterceptOptions): InterceptHan
     peer: unknown,
     signal: AbortSignal | undefined,
     control: unknown,
+    // DSH 0.2.1-alpha.3: the mux's uplink window, passed through verbatim
+    // (undefined on older hosts and on the 5-argument wireStream.open path).
+    uplinkWindow?: unknown,
   ): unknown {
     if (!installed) {
       return (chainTarget.openWireStream as (...callArgs: unknown[]) => unknown).call(
@@ -3202,6 +3225,7 @@ export function installIntercept(options: InstallInterceptOptions): InterceptHan
         peer,
         signal,
         control,
+        uplinkWindow,
       )
     }
     counters.openWireStream += 1
@@ -3215,7 +3239,7 @@ export function installIntercept(options: InstallInterceptOptions): InterceptHan
     if (endpoint === '$events') {
       const open = chainTarget.openWireStream as (this: unknown, ...callArgs: unknown[]) => unknown
       return (async (): Promise<unknown> => {
-        const local = await open.call(raw, endpoint, payload, uplink, peer, signal, control)
+        const local = await open.call(raw, endpoint, payload, uplink, peer, signal, control, uplinkWindow)
         if (!isAsyncIterable(local)) return local
         return mergedEventsStream({ local, relay, signal, recordFailure, log, clock, summarySync })
       })()
@@ -3236,6 +3260,7 @@ export function installIntercept(options: InstallInterceptOptions): InterceptHan
             peer,
             signal,
             control,
+            uplinkWindow,
           )
         }
         // The T23b-2 global merge. The 0.2.0 openWireStream is an ASYNC
@@ -3249,7 +3274,7 @@ export function installIntercept(options: InstallInterceptOptions): InterceptHan
         return (async (): Promise<unknown> => {
           // The uplink rides to the LOCAL method verbatim (it may consume
           // it); the remote leg carries no uplink.
-          const local = await open.call(raw, endpoint, payload, uplink, peer, signal, control)
+          const local = await open.call(raw, endpoint, payload, uplink, peer, signal, control, uplinkWindow)
           if (!isAsyncIterable(local)) return local
           return mergedGlobalStream({
             endpoint,
@@ -3275,6 +3300,7 @@ export function installIntercept(options: InstallInterceptOptions): InterceptHan
         peer,
         signal,
         control,
+        uplinkWindow,
       )
     }
     const verdict = validate(endpoint, virtuals)
@@ -3379,6 +3405,11 @@ export function installIntercept(options: InstallInterceptOptions): InterceptHan
 export interface SelfCheckOptions {
   /** How long the probe may wait for its first frame; default 5000 ms. */
   timeoutMs?: number
+  /** The owner Peer the probe opens as. DSH 0.2.1-alpha.3 removed
+   * `gateway.operatorPeer()` and requires a live Peer on every stream; see
+   * owner-peer.ts. Undefined falls back to `operatorPeer()` where it still
+   * exists (≤ alpha.2), else to no Peer. */
+  getPeer?: () => unknown
 }
 
 /**
@@ -3410,7 +3441,15 @@ export async function behaviorSelfCheck(raw: object, options?: SelfCheckOptions)
   const wireStream = gateway.wireStream
   const open = isPlainObject(wireStream) ? wireStream.open : undefined
   if (typeof open !== 'function') return { ok: false, reason: 'wireStream.open disappeared before the self-check' }
-  const operatorPeer = typeof gateway.operatorPeer === 'function' ? gateway.operatorPeer : undefined
+  // ≤ 0.2.1-alpha.2 only: alpha.3 deleted operatorPeer (and connection.operator).
+  const legacyOperatorPeer = typeof gateway.operatorPeer === 'function' ? gateway.operatorPeer : undefined
+  let peer: unknown
+  try {
+    peer = options?.getPeer?.()
+  } catch (error) {
+    return { ok: false, reason: `the self-check could not obtain an owner Peer: ${messageOf(error)}` }
+  }
+  if (peer === undefined && legacyOperatorPeer !== undefined) peer = legacyOperatorPeer.call(raw)
   const controller = new AbortController()
   // NOT unref'd: an unref'd timer lets the process exit (or a test runner
   // judge the loop empty) before the timeout ever fires when this probe is
@@ -3438,7 +3477,7 @@ export async function behaviorSelfCheck(raw: object, options?: SelfCheckOptions)
           'workspace/follow',
           payload,
           undefined,
-          typeof operatorPeer === 'function' ? operatorPeer.call(raw) : undefined,
+          peer,
           controller.signal,
         ),
       ),
@@ -3482,6 +3521,10 @@ export interface RunSelfCheckOptions {
   retryDelayMs?: number
   /** Failure logging, wired to the context logger by index.ts. */
   log?: (format: string, ...args: unknown[]) => void
+  /** Success logging (one line once the probe passes). */
+  info?: (format: string, ...args: unknown[]) => void
+  /** Forwarded to {@link behaviorSelfCheck}. */
+  getPeer?: () => unknown
 }
 
 /**
@@ -3501,7 +3544,7 @@ export async function runSelfCheck(raw: object, options: RunSelfCheckOptions): P
   const { handle, log } = options
   const retryDelayMs = options.retryDelayMs ?? 3_000
   const stillInstalled = (): boolean => handle.diagnostics().installed
-  let result = await behaviorSelfCheck(raw)
+  let result = await behaviorSelfCheck(raw, { getPeer: options.getPeer })
   if (!result.ok && stillInstalled()) {
     await new Promise<void>((resolve) => {
       const timer = setTimeout(resolve, retryDelayMs)
@@ -3509,11 +3552,14 @@ export async function runSelfCheck(raw: object, options: RunSelfCheckOptions): P
       // loop-empty judgement) open for the retry delay.
       if (typeof timer.unref === 'function') timer.unref()
     })
-    if (stillInstalled()) result = await behaviorSelfCheck(raw)
+    if (stillInstalled()) result = await behaviorSelfCheck(raw, { getPeer: options.getPeer })
   }
   if (!stillInstalled()) return result
   handle.noteSelfCheck(result)
-  if (result.ok) return result
+  if (result.ok) {
+    options.info?.('client intercept self-check passed; interception active')
+    return result
+  }
   handle.uninstall()
   log?.('client intercept self-check failed (%s), interception removed', result.reason)
   return result

package/src/invoke-binary.ts

@@ -0,0 +1,134 @@
+/**
+ * invoke 二进制载荷的线上标记（2026-10-14 修复）：`v1/invoke` 是纯 JSON
+ * 通道，而 `workspaceFiles/readBytes` 的结果带 `data: Uint8Array`——直接
+ * `JSON.stringify` 会把 typed array 打成普通对象，子客户端侧的 zod 校验
+ * （expected "Uint8Array"）当场拒绝，远程会话的图片预览报「读取失败」。
+ *
+ * 两端共用同一份规则：服务端在应答前对已知二进制方法的结果做深度标记
+ * （typed array → `{ $zr-u8: <base64> }`），子客户端在 forwardInvoke 拿回
+ * 值后还原成真 `Uint8Array`。两端都按同一个 `INVOKE_BINARY_RESULT_METHODS`
+ * 常量开关——单一来源，不可能漂移（这是登记表同步硬约束之外的第三张
+ * 「小表」，但它只此一处定义）。
+ *
+ * 纯逻辑：不 import DSH、不碰 I/O。
+ */
+
+/** 标记键。线上只会出现服务端写入的标记；客户端只认这个键。 */
+export const BINARY_MARKER = '$zr-u8'
+
+/** 结果里带二进制的方法（`namespace/method`）。请求侧参数不带二进制
+ * （readBytes 的参数是 scope/paths），故只有结果方向需要标记。 */
+export const INVOKE_BINARY_RESULT_METHODS: ReadonlySet<string> = new Set(['workspaceFiles/readBytes'])
+
+/** 深度上限：与其余 walker（share-store 祖先链、会话引用扫描）一致。 */
+const MAX_DEPTH = 16
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value) && !isTypedArray(value)
+
+const isTypedArray = (value: unknown): value is ArrayBufferView =>
+  ArrayBuffer.isView(value) === true && !(value instanceof DataView)
+
+/** 深度遍历，把 typed array（含 Buffer）换成 `{ $zr-u8: base64 }` 标记。 */
+export function markInvokeBinary(value: unknown, depth = 0): unknown {
+  if (depth >= MAX_DEPTH) return value
+  if (isTypedArray(value)) return { [BINARY_MARKER]: Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString('base64') }
+  if (Array.isArray(value)) {
+    let changed = false
+    const out: unknown[] = []
+    for (const item of value) {
+      const marked = markInvokeBinary(item, depth + 1)
+      if (marked !== item) changed = true
+      out.push(marked)
+    }
+    return changed ? out : value
+  }
+  if (isPlainObject(value)) {
+    let changed = false
+    const out: Record<string, unknown> = {}
+    for (const [key, item] of Object.entries(value)) {
+      const marked = markInvokeBinary(item, depth + 1)
+      if (marked !== item) changed = true
+      out[key] = marked
+    }
+    return changed ? out : value
+  }
+  return value
+}
+
+/** 深度遍历，把 `{ $zr-u8: base64 }` 标记还原成 `Uint8Array`。
+ *  标记只会是本模块的 `markInvokeBinary` 写下的（键名即凭据），base64
+ *  恒有效；万一混入同键的怪值，`Buffer.from(..., 'base64')` 的宽容解码
+ *  也不会抛。非标记对象原样返回（同一引用，不惊动浅比较的调用方）。 */
+export function restoreInvokeBinary(value: unknown, depth = 0): unknown {
+  if (depth >= MAX_DEPTH) return value
+  if (Array.isArray(value)) {
+    let changed = false
+    const out: unknown[] = value.map((item) => {
+      const restored = restoreInvokeBinary(item, depth + 1)
+      if (restored !== item) changed = true
+      return restored
+    })
+    return changed ? out : value
+  }
+  if (isPlainObject(value)) {
+    const marked = value[BINARY_MARKER]
+    // 空串也是合法标记（base64 空串 = 0 字节，mark 自己写下的）；
+    // 只排除非字符串与带兄弟键的诱饵形状。
+    if (typeof marked === 'string' && Object.keys(value).length === 1) {
+      return new Uint8Array(Buffer.from(marked, 'base64'))
+    }
+    let changed = false
+    const out: Record<string, unknown> = {}
+    for (const [key, item] of Object.entries(value)) {
+      const restored = restoreInvokeBinary(item, depth + 1)
+      if (restored !== item) changed = true
+      out[key] = restored
+    }
+    return changed ? out : value
+  }
+  return value
+}
+
+/** dispatchRpc 信封的附件旁路形状（dsh-api-gateway 的 encodeRpcResult）：
+ *  Uint8Array 不进 JSON 值，抽到 `attachments: [{path, bytes}]`，原位置
+ *  置 null，渲染层按 path 回填。远程路径必须产出同样的契约，否则
+ *  typed array 在后台→浏览器的桥上被 JSON 压扁（2026-10-14 实机定位）。 */
+export interface ResultAttachment {
+  path: (string | number)[]
+  bytes: Uint8Array
+}
+
+/** 把（已还原的）结果值里的 Uint8Array 抽成附件；值内原位置置 null。
+ *  没有 typed array 时 value 原引用返回、attachments 为空数组。 */
+export function extractResultAttachments(value: unknown): { value: unknown; attachments: ResultAttachment[] } {
+  const attachments: ResultAttachment[] = []
+  const walk = (input: unknown, path: (string | number)[], depth: number): unknown => {
+    if (depth >= MAX_DEPTH) return input
+    if (isTypedArray(input)) {
+      attachments.push({ path, bytes: input as Uint8Array })
+      return null
+    }
+    if (Array.isArray(input)) {
+      let changed = false
+      const out: unknown[] = input.map((item, index) => {
+        const extracted = walk(item, [...path, index], depth + 1)
+        if (extracted !== item) changed = true
+        return extracted
+      })
+      return changed ? out : input
+    }
+    if (isPlainObject(input)) {
+      let changed = false
+      const out: Record<string, unknown> = {}
+      for (const [key, item] of Object.entries(input)) {
+        const extracted = walk(item, [...path, key], depth + 1)
+        if (extracted !== item) changed = true
+        out[key] = extracted
+      }
+      return changed ? out : input
+    }
+    return input
+  }
+  return { value: walk(value, [], 0), attachments }
+}

package/src/owner-peer.ts

@@ -0,0 +1,81 @@
+/**
+ * The owner Peer this plugin speaks as when it calls the typert gateway on
+ * its own behalf (relay routes, admin projections, the intercept
+ * self-check, the `$events` relay subscription).
+ *
+ * DSH 0.2.1-alpha.3 removed the gateway's implicit operator fallback
+ * (`gateway.operatorPeer()`, `connection.operator` and the `OperatorPeer`
+ * export are gone): every gateway call — `invoke`, `stream`,
+ * `openWireStream`, `dispatchRpc` — now asserts a live Peer, and `$events` /
+ * `$events/result` additionally demand `principal.kind === 'owner'` and
+ * `interactions === 'answer'`, with the result answered by the SAME Peer that
+ * opened the stream. The sanctioned in-process door is
+ * `connection.createPeer({ principal: { kind: 'owner' }, interactions:
+ * 'answer' })` (docs/upgrade-guide/v0.2.1-alpha.2/operator-connect), whose
+ * Peer is disposed with the Context that read `connection`.
+ *
+ * Resolution order: a cached `createPeer` Peer (recreated once its scope is
+ * disposed), else `connection.browserPeer` (also an owner/answer Peer),
+ * else `undefined` — the pre-alpha.3 behavior, where the gateway itself
+ * defaulted a missing Peer to its operator.
+ */
+
+/** Minimal structural view of a typert `PeerScope`. */
+export interface PeerLike {
+  readonly signal?: AbortSignal
+}
+
+/** The connection-service members this module reads. */
+export interface PeerConnectionLike {
+  createPeer?: (options: { principal: { kind: 'owner' }; interactions?: 'answer' | 'none' }) => unknown
+  browserPeer?: unknown
+}
+
+function isLive(peer: unknown): boolean {
+  if (peer === null || typeof peer !== 'object') return false
+  const signal = (peer as PeerLike).signal
+  return !(signal instanceof AbortSignal) || !signal.aborted
+}
+
+/**
+ * Build a lazy, caching owner-Peer source over a connection-service reader.
+ * The reader runs per call (the service may be absent or restarted). The
+ * cache is keyed on the Peer's LIVENESS, not on the connection object's
+ * identity: `ctx.reflect.get('connection')` hands out a fresh proxy per read,
+ * so an identity key would mint a new Peer per call — and the gateway
+ * refuses a `$events/result` from any Peer but the one that opened
+ * `$events` (found by the alpha.3 live smoke). A restarted connection
+ * service disposes its Peers, which is exactly when a new one is minted.
+ * @param getConnection - live reader of `ctx.connection` (may return undefined).
+ * @returns a function answering the Peer to pass, or undefined to let the
+ *   host default it (pre-alpha.3 hosts).
+ */
+export function createOwnerPeerSource(getConnection: () => unknown): () => unknown {
+  let cached: unknown
+  return () => {
+    let connection: PeerConnectionLike | undefined
+    try {
+      const value = getConnection()
+      connection = value !== null && typeof value === 'object' ? (value as PeerConnectionLike) : undefined
+    } catch {
+      connection = undefined
+    }
+    if (connection === undefined) return undefined
+    if (typeof connection.createPeer === 'function') {
+      if (isLive(cached)) return cached
+      cached = connection.createPeer({ principal: { kind: 'owner' }, interactions: 'answer' })
+      return cached
+    }
+    const browser = connection.browserPeer
+    return browser !== null && typeof browser === 'object' ? browser : undefined
+  }
+}
+
+/**
+ * Attach `peer` to one gateway request object when a Peer is available;
+ * otherwise return the request unchanged (pre-alpha.3 shape).
+ */
+export function withPeer<T extends object>(request: T, getPeer: (() => unknown) | undefined): T & { peer?: unknown } {
+  const peer = getPeer?.()
+  return peer === undefined ? request : { ...request, peer }
+}

package/src/relay-server.ts

@@ -26,6 +26,7 @@
  * a 404.
  */
 
+import { withPeer } from './owner-peer.js'
 import { randomBytes, timingSafeEqual } from 'node:crypto'
 import { Readable, Transform } from 'node:stream'
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
@@ -48,6 +49,7 @@ import { routeMethodsOf, routeMaxBodyOf } from './plugin-bridge.js'
 import { createPluginTunnel, validatePluginCall, type PluginTunnelRoutes } from './plugin-tunnel.js'
 import type { PluginLoopback } from './plugin-loopback.js'
 import { isLoopbackAuthError } from './plugin-loopback.js'
+import { INVOKE_BINARY_RESULT_METHODS, markInvokeBinary } from './invoke-binary.js'
 import type { NormalizedAdapter, AdapterVerdict } from './plugin-adapter-core.js'
 import { matchAdapterRoute, locateAdapterIds, adapterOwnsRegistryEntry, AdapterMultiValueQueryError } from './plugin-adapter-core.js'
 
@@ -207,12 +209,13 @@ const JOB_CACHE_LIMIT = 1024
  *   before its typert dispatch — and returns the `{ok,…}` envelope itself.
  */
 export interface RelayGateway {
-  invoke(call: { namespace: string; method: string; args: unknown; signal?: AbortSignal }): Promise<unknown>
+  invoke(call: { namespace: string; method: string; args: unknown; signal?: AbortSignal; peer?: unknown }): Promise<unknown>
   stream(call: {
     namespace: string
     method: string
     args: unknown
     signal?: AbortSignal
+    peer?: unknown
   }): Promise<AsyncIterable<unknown>>
   /** The host's wire adapter, shared by the WebSocket mux and the local
    * transports. `open` is the async 0.2.0 method. */
@@ -267,6 +270,12 @@ export interface RelayHandlerOptions {
    * synthetic Request to the same exact-fetch route table the browser's
    * `/api` transport uses — no loopback HTTP, no login state. */
   getApiFetch?: () => ((request: Request) => Promise<Response>) | undefined
+  /** The owner Peer every gateway call is made as (DSH 0.2.1-alpha.3+
+   * requires one; `$events` and `$events/result` need an owner Peer with
+   * `interactions: 'answer'`, the SAME one for both). Built by
+   * {@link createOwnerPeerSource}; absent or answering undefined keeps the
+   * pre-alpha.3 behavior (the host defaults the Peer). */
+  getPeer?: () => unknown
   /** Stream heartbeat interval in ms (a `{"type":"ping"}` line that keeps
    * reverse proxies from timing the idle stream away); defaults to 15000.
    * Tests inject a small value. */
@@ -874,12 +883,12 @@ export function createRelayHandler(options: RelayHandlerOptions): RelayHandler {
     const cached = recentJobs.get(sessionId)
     if (cached !== undefined && cached.has(jobId)) return cached.get(jobId) === sessionId
     try {
-      const iterable = await gateway.stream({
+      const iterable = await gateway.stream(withPeer({
         namespace: 'job',
         method: 'list',
         args: { request: { sessionId } },
         signal,
-      })
+      }, options.getPeer))
       for await (const frame of iterable) {
         rememberJobs(sessionId, frame)
         const jobs = recentJobs.get(sessionId)
@@ -905,7 +914,7 @@ export function createRelayHandler(options: RelayHandlerOptions): RelayHandler {
    */
   const workspaceExists = async (workspaceId: string, signal: AbortSignal): Promise<boolean> => {
     try {
-      const iterable = await gateway.stream({ namespace: 'workspace', method: 'follow', args: {}, signal })
+      const iterable = await gateway.stream(withPeer({ namespace: 'workspace', method: 'follow', args: {}, signal }, options.getPeer))
       for await (const frame of iterable) {
         if (!isPlainObject(frame) || frame.type !== 'baseline') return false
         const value = isPlainObject(frame.value) ? frame.value : undefined
@@ -938,7 +947,7 @@ export function createRelayHandler(options: RelayHandlerOptions): RelayHandler {
       '$events',
       { args: {} },
       undefined,
-      undefined,
+      options.getPeer?.(),
       signal,
     )) as unknown
     if (
@@ -1216,7 +1225,7 @@ export function createRelayHandler(options: RelayHandlerOptions): RelayHandler {
           '$events/result',
           { args: { clientId: owner.clientId, eventId: originalEventId, outcome: parsed.result } },
           hangUp.signal,
-          undefined,
+          options.getPeer?.(),
         )) as unknown
         responseJson(res, 200, isPlainObject(envelope) ? envelope : { ok: false, error: { code: 'internal' } })
       } catch (error) {
@@ -1340,7 +1349,7 @@ export function createRelayHandler(options: RelayHandlerOptions): RelayHandler {
           responseJson(res, 403, { ok: false, error: { code: 'not-shared' } })
           return
         }
-        const value = await gateway.invoke({ namespace, method, args, signal: hangUp.signal })
+        const value = await gateway.invoke(withPeer({ namespace, method, args, signal: hangUp.signal }, options.getPeer))
         // T31: a session created or forked THROUGH the relay is shared
         // automatically — the client only ever sees shared sessions, so an
         // unshared result would be born unreachable. Re-sharing (a fork the
@@ -1363,7 +1372,14 @@ export function createRelayHandler(options: RelayHandlerOptions): RelayHandler {
               : decision.filter === 'model-catalog'
                 ? filterModelCatalogResult(value)
                 : value
-        responseJson(res, 200, { ok: true, value: travels })
+        // 2026-10-14: a binary-result method (workspaceFiles/readBytes) cannot
+        // ride JSON.stringify — typed arrays collapse into plain objects and
+        // the sub-client's own zod validation rejects the answer (remote image
+        // preview: "expected Uint8Array"). The marker round-trip
+        // (invoke-binary.ts) is restored on the client half (intercept.ts).
+        const wire =
+          INVOKE_BINARY_RESULT_METHODS.has(`${namespace}/${method}`) ? markInvokeBinary(travels) : travels
+        responseJson(res, 200, { ok: true, value: wire })
       } catch (error) {
         // The gateway's own failures (unknown namespace, absent service) are
         // business answers, not transport errors: they ride a 200 envelope
@@ -2463,12 +2479,12 @@ export function createRelayHandler(options: RelayHandlerOptions): RelayHandler {
           const syncProjections = async (sessionId: string): Promise<void> => {
             let result: unknown
             try {
-              result = await gateway.invoke({
+              result = await gateway.invoke(withPeer({
                 namespace: 'session',
                 method: 'projections',
                 args: { request: { sessionId } },
                 signal: hangUp.signal,
-              })
+              }, options.getPeer))
             } catch {
               return // projections unavailable — the next live projection frame will flow anyway
             }
@@ -2588,7 +2604,7 @@ export function createRelayHandler(options: RelayHandlerOptions): RelayHandler {
             const iterable =
               eventsSub !== undefined
                 ? await openEventsStream(hangUp.signal)
-                : await gateway.stream({ namespace, method, args, signal: hangUp.signal })
+                : await gateway.stream(withPeer({ namespace, method, args, signal: hangUp.signal }, options.getPeer))
             for await (const frame of iterable) {
               if (finished || clientGone) break
               if (namespace === 'job' && method === 'list') rememberJobs(ownerSessionIdOf(args), frame)