threadwire 0.1.5 → 0.1.8

package/src/model-broker.js

@@ -0,0 +1,313 @@
+// @ts-nocheck
+/* eslint-disable jsdoc/require-jsdoc */
+
+import {constants} from "node:fs"
+import {open} from "node:fs/promises"
+import {createServer} from "node:http"
+import {bearerToken, createGrantStore, validateBrokerRequest, validateResponsesBody} from "./model-broker-policy.js"
+import {abortable, readResponseCapped} from "./absolute-deadline.js"
+
+const MAX_BODY_BYTES = 2_097_152
+const MAX_SECRET_BYTES = 65_536
+
+/** @param {{environment?: NodeJS.ProcessEnv, fetchImplementation?: typeof fetch}} [options] */
+export async function startModelBroker(options = {}) {
+  const environment = options.environment ?? process.env
+  const host = environment.THREADWIRE_MODEL_BROKER_HOST ?? "0.0.0.0"
+  const port = portValue(environment.THREADWIRE_MODEL_BROKER_PORT, 8789)
+  const adminToken = safeSetting(environment.THREADWIRE_MODEL_BROKER_ADMIN_TOKEN, "THREADWIRE_MODEL_BROKER_ADMIN_TOKEN")
+  const upstream = upstreamUrl(environment.THREADWIRE_CODEX_UPSTREAM_URL)
+  let credential = await readSecretFile(environment.THREADWIRE_CODEX_CREDENTIAL_FILE)
+  let generation = 1
+  let reloading = false
+  let stopping = false
+  const shutdown = new AbortController()
+  const controlSockets = new Set()
+  const grants = createGrantStore()
+  /** @type {Map<string, import("node:http").Server>} */
+  const listeners = new Map()
+  /** @type {Map<string, {controller: AbortController, timer: NodeJS.Timeout, sockets: Set<import("node:net").Socket>}>} */
+  const grantRuntimes = new Map()
+  const fetchImplementation = options.fetchImplementation ?? fetch
+  const revokeGrant = async (token) => {
+    grants.revoke(token)
+    const runtime = grantRuntimes.get(token)
+    grantRuntimes.delete(token)
+    if (runtime !== undefined) {
+      clearTimeout(runtime.timer)
+      runtime.controller.abort(new Error("Broker grant expired"))
+      for (const socket of runtime.sockets) socket.destroy()
+      runtime.sockets.clear()
+    }
+    await closeListener(listeners, token, 1000)
+  }
+
+  const server = createServer(async (request, response) => {
+    try {
+      if (stopping) throw new Error("Model broker is shutting down")
+      if (request.method === "GET" && request.url === "/healthz") {
+        response.writeHead(200, {"content-type": "application/json"})
+        response.end(JSON.stringify({ok: true, generation}))
+        return
+      }
+      if (request.url === "/admin/grants" && request.method === "POST") {
+        requireAdmin(request.headers.authorization, adminToken)
+        if (reloading) throw new Error("Model broker reload is active")
+        const body = await readJson(request, shutdown.signal)
+        const grant = parseGrant(body)
+        const expiresAt = Date.now() + grant.ttlMs
+        const token = grants.issue(grant)
+        const controller = new AbortController()
+        const sockets = new Set()
+        const listener = createServer((workerRequest, workerResponse) => {
+          proxyWorkerRequest(workerRequest, workerResponse, {
+            grants, token, grant, credential: () => credential, upstream, fetchImplementation,
+            signal: controller.signal
+          }).catch((error) => {
+            if (workerResponse.destroyed) return
+            process.stderr.write(`threadwire-model-broker: ${error instanceof Error ? error.message : "request failed"}\n`)
+            const status = isClientError(error) ? 403 : 502
+            sendJson(workerResponse, status, {error: status === 403 ? "request denied" : "model broker unavailable"})
+          })
+        })
+        listener.on("connection", (socket) => {
+          if (controller.signal.aborted) {
+            socket.destroy()
+            return
+          }
+          sockets.add(socket)
+          socket.once("close", () => sockets.delete(socket))
+        })
+        try {
+          await listen(listener, 0, grant.brokerAddress)
+        } catch (error) {
+          grants.revoke(token)
+          throw error
+        }
+        listeners.set(token, listener)
+        const expiryTimer = setTimeout(() => { void revokeGrant(token) }, Math.max(1, expiresAt - Date.now()))
+        expiryTimer.unref()
+        grantRuntimes.set(token, {controller, timer: expiryTimer, sockets})
+        const address = listener.address()
+        if (address === null || typeof address === "string") throw new Error("Invalid broker listener")
+        sendJson(response, 201, {token, generation, port: address.port})
+        return
+      }
+      if (request.url?.startsWith("/admin/grants/") && request.method === "DELETE") {
+        requireAdmin(request.headers.authorization, adminToken)
+        const token = decodeURIComponent(request.url.slice("/admin/grants/".length))
+        await revokeGrant(token)
+        response.writeHead(204)
+        response.end()
+        return
+      }
+      if (request.url?.startsWith("/admin/grants/") && request.url.endsWith("/activate") && request.method === "POST") {
+        requireAdmin(request.headers.authorization, adminToken)
+        const token = decodeURIComponent(request.url.slice("/admin/grants/".length, -"/activate".length))
+        grants.activate(token)
+        sendJson(response, 200, {ok: true})
+        return
+      }
+      if (request.url === "/admin/reload" && request.method === "POST") {
+        requireAdmin(request.headers.authorization, adminToken)
+        if (reloading) throw new Error("Model broker reload is active")
+        reloading = true
+        try {
+          const replacement = await readSecretFile(environment.THREADWIRE_CODEX_CREDENTIAL_FILE)
+          grants.clear()
+          await Promise.all([...listeners.keys()].map(revokeGrant))
+          credential = replacement
+          generation += 1
+        } finally {
+          reloading = false
+        }
+        sendJson(response, 200, {ok: true, generation})
+        return
+      }
+      sendJson(response, 403, {error: "request denied"})
+    } catch (error) {
+      const status = isClientError(error) ? 403 : 502
+      sendJson(response, status, {error: status === 403 ? "request denied" : "model broker unavailable"})
+    }
+  })
+  server.on("connection", (socket) => {
+    if (shutdown.signal.aborted) return socket.destroy()
+    controlSockets.add(socket)
+    socket.once("close", () => controlSockets.delete(socket))
+  })
+  await listen(server, port, host)
+  return {
+    server,
+    close: async () => {
+      stopping = true
+      shutdown.abort(new Error("Model broker is shutting down"))
+      for (const socket of controlSockets) socket.destroy()
+      await Promise.all([...listeners.keys()].map(revokeGrant))
+      await Promise.race([
+        new Promise((resolve) => server.close(() => resolve(undefined))),
+        new Promise((resolve) => {
+          const timer = setTimeout(resolve, 1000)
+          timer.unref()
+        })
+      ])
+    },
+    activeListeners: () => listeners.size,
+    config: {host, port, upstream: upstream.toString()}
+  }
+}
+
+/** @param {unknown} value */
+function parseGrant(value) {
+  if (!isRecord(value) || value.provider !== "codex" || typeof value.runId !== "string" || typeof value.networkId !== "string" || typeof value.model !== "string" || typeof value.brokerAddress !== "string") {
+    throw new Error("Invalid broker grant")
+  }
+  if (!/^(?:\d{1,3}\.){3}\d{1,3}$/u.test(value.brokerAddress)) throw new Error("Invalid broker grant")
+  const ttlMs = value.ttlMs
+  if (typeof ttlMs !== "number") throw new Error("Invalid broker grant")
+  return {provider: "codex", runId: value.runId, networkId: value.networkId, model: value.model, brokerAddress: value.brokerAddress, ttlMs}
+}
+
+async function proxyWorkerRequest(request, response, options) {
+  throwIfAborted(options.signal)
+  const policyHeaders = {...request.headers}
+  delete policyHeaders.host
+  delete policyHeaders.connection
+  delete policyHeaders["transfer-encoding"]
+  validateBrokerRequest({method: request.method, path: request.url, headers: policyHeaders})
+  const suppliedToken = bearerToken(request.headers.authorization)
+  if (suppliedToken !== options.token) throw new Error("Broker grant token mismatch")
+  const grant = options.grants.authorize(suppliedToken, {
+    provider: "codex", networkId: options.grant.networkId, runId: options.grant.runId
+  })
+  const body = await readBody(request, options.signal)
+  throwIfAborted(options.signal)
+  options.grants.authorize(suppliedToken, {
+    provider: "codex", networkId: options.grant.networkId, runId: options.grant.runId
+  })
+  validateResponsesBody(body, grant.model)
+  throwIfAborted(options.signal)
+  const upstreamResponse = await abortable(options.fetchImplementation(new URL("/v1/responses", options.upstream), {
+    method: "POST",
+    redirect: "error",
+    headers: {
+      authorization: `Bearer ${options.credential()}`,
+      "content-type": "application/json",
+      "user-agent": "threadwire-model-broker/1"
+    },
+    body,
+    signal: options.signal
+  }), options.signal)
+  throwIfAborted(options.signal)
+  const bytes = await readResponseCapped(upstreamResponse, MAX_BODY_BYTES, options.signal)
+  throwIfAborted(options.signal)
+  response.writeHead(upstreamResponse.status, {"content-type": safeContentType(upstreamResponse.headers.get("content-type"))})
+  response.end(bytes)
+}
+
+async function closeListener(listeners, token, timeoutMs) {
+  const listener = listeners.get(token)
+  listeners.delete(token)
+  if (listener === undefined) return
+  await Promise.race([
+    new Promise((resolve) => listener.close(() => resolve(undefined))),
+    new Promise((resolve) => {
+      const timer = setTimeout(resolve, timeoutMs)
+      timer.unref()
+    })
+  ])
+}
+
+async function readSecretFile(path) {
+  const safePath = safeSetting(path, "THREADWIRE_CODEX_CREDENTIAL_FILE")
+  let handle
+  try {
+    handle = await open(safePath, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK)
+    const metadata = await handle.stat()
+    if (!metadata.isFile() || metadata.size < 1 || metadata.size > MAX_SECRET_BYTES || (metadata.mode & 0o022) !== 0) throw new Error()
+    const value = (await handle.readFile("utf8")).replace(/[\r\n]+$/u, "")
+    if (value.length === 0 || /[\r\n]/u.test(value)) throw new Error()
+    return value
+  } catch {
+    throw new Error("Codex credential file is unavailable")
+  } finally {
+    await handle?.close().catch(() => {})
+  }
+}
+
+async function readJson(request, signal) {
+  const body = await readBody(request, signal)
+  try {
+    return JSON.parse(body.toString("utf8"))
+  } catch {
+    throw new Error("Invalid request")
+  }
+}
+
+async function readBody(request, signal) {
+  const chunks = []
+  let size = 0
+  for await (const chunk of request) {
+    throwIfAborted(signal)
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+    size += buffer.length
+    if (size > MAX_BODY_BYTES) throw new Error("Request exceeded capacity")
+    chunks.push(buffer)
+  }
+  throwIfAborted(signal)
+  return Buffer.concat(chunks)
+}
+
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : new Error("Broker grant expired")
+}
+
+function requireAdmin(value, expected) {
+  if (value !== `Bearer ${expected}`) throw new Error("Request denied")
+}
+
+function upstreamUrl(value) {
+  const url = new URL(safeSetting(value, "THREADWIRE_CODEX_UPSTREAM_URL"))
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+    throw new Error("THREADWIRE_CODEX_UPSTREAM_URL is invalid")
+  }
+  return url
+}
+
+function safeSetting(value, name) {
+  if (typeof value !== "string" || value.length === 0 || /[\r\n]/u.test(value)) throw new Error(`${name} is required`)
+  return value
+}
+
+function portValue(value, fallback) {
+  if (value === undefined) return fallback
+  const number = Number(value)
+  if (!/^\d+$/u.test(value) || !Number.isSafeInteger(number) || number < 1 || number > 65535) throw new Error("Invalid model broker port")
+  return number
+}
+
+function safeContentType(value) {
+  return value && /^[\w.+-]+\/[\w.+-]+(?:;\s*charset=[\w-]+)?$/u.test(value) ? value : "application/json"
+}
+
+function sendJson(response, status, value) {
+  response.writeHead(status, {"content-type": "application/json"})
+  response.end(JSON.stringify(value))
+}
+
+function isClientError(error) {
+  return error instanceof Error && /denied|grant|Invalid request|capacity/u.test(error.message)
+}
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function listen(server, port, host) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject)
+    server.listen(port, host, () => {
+      server.removeListener("error", reject)
+      resolve(undefined)
+    })
+  })
+}

package/src/mount-policy.js

@@ -0,0 +1,28 @@
+// @ts-check
+
+import {readFile} from "node:fs/promises"
+import {isAbsolute, relative} from "node:path"
+
+/** @param {string} root @param {(path: string, encoding: "utf8") => Promise<string>} [reader] */
+export async function assertNoNestedMounts(root, reader = readFile) {
+  const mountinfo = await reader("/proc/self/mountinfo", "utf8")
+  for (const line of mountinfo.split("\n")) {
+    if (line.length === 0) continue
+    const fields = line.split(" ")
+    const encoded = fields[4]
+    if (encoded === undefined) throw new Error("Mount topology unavailable")
+    const mountpoint = decodeMountinfo(encoded)
+    if (mountpoint !== root && within(root, mountpoint)) throw new Error("Nested worktree mounts are forbidden")
+  }
+}
+
+/** @param {string} root @param {string} child */
+function within(root, child) {
+  const path = relative(root, child)
+  return path !== "" && !path.startsWith("..") && !isAbsolute(path)
+}
+
+/** @param {string} value */
+function decodeMountinfo(value) {
+  return value.replace(/\\(040|011|012|134)/gu, (_, octal) => String.fromCharCode(Number.parseInt(octal, 8)))
+}

package/src/normalized-output.js

@@ -0,0 +1,68 @@
+// @ts-check
+
+import {closeSync, fsyncSync, openSync, writeSync} from "node:fs"
+import {dirname} from "node:path"
+
+const filesystemOperations = {closeSync, fsyncSync, openSync, writeSync}
+
+/**
+ * @typedef {object} FilesystemOperations
+ * @property {(fileDescriptor: number) => void} closeSync Close a transcript.
+ * @property {(fileDescriptor: number) => void} fsyncSync Sync a transcript.
+ * @property {(path: string, flags: string, mode?: number) => number} openSync Open a transcript or directory.
+ * @property {(fileDescriptor: number, buffer: Buffer, offset: number, length: number) => number} writeSync
+ * Write transcript bytes.
+ */
+
+export class NormalizedOutput {
+  /**
+   * @param {Pick<NodeJS.WritableStream, "write">} output
+   * @param {string | undefined} transcriptPath
+   * @param {FilesystemOperations} [filesystem]
+   */
+  constructor(output, transcriptPath, filesystem = filesystemOperations) {
+    this.output = output
+    this.filesystem = filesystem
+    this.transcriptDirectory = transcriptPath === undefined ? undefined : dirname(transcriptPath)
+    this.fileDescriptor = transcriptPath === undefined
+      ? undefined
+      : this.filesystem.openSync(transcriptPath, "wx", 0o600)
+    this.closed = false
+  }
+
+  /** @param {string} record */
+  write(record) {
+    if (this.closed) throw new Error("Normalized output is closed")
+    if (this.fileDescriptor !== undefined) {
+      const bytes = Buffer.from(record)
+      let offset = 0
+      while (offset < bytes.length) {
+        const written = this.filesystem.writeSync(
+          this.fileDescriptor,
+          bytes,
+          offset,
+          bytes.length - offset
+        )
+        if (written === 0) throw new Error("Transcript write made zero bytes of progress")
+        offset += written
+      }
+      this.filesystem.fsyncSync(this.fileDescriptor)
+      const directoryDescriptor = this.filesystem.openSync(
+        /** @type {string} */ (this.transcriptDirectory),
+        "r"
+      )
+      try {
+        this.filesystem.fsyncSync(directoryDescriptor)
+      } finally {
+        this.filesystem.closeSync(directoryDescriptor)
+      }
+    }
+    this.output.write(record)
+  }
+
+  close() {
+    if (this.closed) return
+    this.closed = true
+    if (this.fileDescriptor !== undefined) this.filesystem.closeSync(this.fileDescriptor)
+  }
+}

package/src/notice-queue.js

@@ -4,7 +4,7 @@
  * A single unit of work handed to the transport: either a batched/chunked text
  * message, or a tool-activity message that must be correlated by `activity.key`
  * so its "finished" phase edits the exact Telegram message its "started" sent.
- * @typedef {{message: string | import("./types.js").OutgoingMessage, activity?: {key: string, phase: "started" | "finished"}}} Delivery
+ * @typedef {{message: string | import("./types.js").OutgoingMessage, metricClass?: string, activity?: {key: string, phase: "started" | "finished"}}} Delivery
  */
 
 const DEFAULT_MAX_LENGTH = 3500
@@ -13,10 +13,11 @@ const DEFAULT_MAX_PENDING_BYTES = 262_144
 
 export class NoticeQueue {
   /**
-   * @param {{sender: import("./types.js").NoticeSender, minimumIntervalMs?: number, batchWindowMs?: number, maxLength?: number, maxPendingNotices?: number, maxPendingBytes?: number, sleep?: (milliseconds: number) => Promise<void>, now?: () => number, random?: () => number}} options
+   * @param {{sender: import("./types.js").NoticeSender, onDelivered?: (metricClass: string, bytes: number) => void, minimumIntervalMs?: number, batchWindowMs?: number, maxLength?: number, maxPendingNotices?: number, maxPendingBytes?: number, sleep?: (milliseconds: number) => Promise<void>, now?: () => number, random?: () => number}} options
    */
   constructor(options) {
     this.sender = options.sender
+    this.onDelivered = options.onDelivered
     this.minimumIntervalMs = nonnegativeSafeInteger(options.minimumIntervalMs ?? 1000, "minimumIntervalMs")
     this.batchWindowMs = nonnegativeSafeInteger(options.batchWindowMs ?? 0, "batchWindowMs")
     this.maxLength = positiveSafeInteger(options.maxLength ?? DEFAULT_MAX_LENGTH, "maxLength")
@@ -85,19 +86,19 @@ export class NoticeQueue {
   takeBatch() {
     const first = this.shiftPending()
     if (!first) return {message: ""}
-    if ("activity" in first) return {message: this.capActivity(first), activity: first.activity}
-    if (first.format === "javascript-code") return {message: this.takeCodeBatch(first)}
+    if ("activity" in first) return {message: this.capActivity(first), activity: first.activity, ...metricClass(first)}
+    if (first.format === "javascript-code") return {message: this.takeCodeBatch(first), ...metricClass(first)}
     let text = first.text
     const batchSeparator = first.batchSeparator ?? "\n"
     while (this.pending.length > 0) {
       const next = this.pending[0]
-      if (!next || "activity" in next || next.format !== undefined || next.label !== first.label || (next.batchSeparator ?? "\n") !== batchSeparator) break
+      if (!next || "activity" in next || next.metricClass !== first.metricClass || next.format !== undefined || next.label !== first.label || (next.batchSeparator ?? "\n") !== batchSeparator) break
       const combined = `${text}${batchSeparator}${next.text}`
       if (combined.length > this.maxLength) break
       this.shiftPending()
       text = combined
     }
-    if (text.length <= this.maxLength) return {message: text}
+    if (text.length <= this.maxLength) return {message: text, ...metricClass(first)}
     const label = first.label ?? /^\[P\d+\] /u.exec(text)?.[0] ?? ""
     if (label.length >= this.maxLength) throw new NoticeQueueChunkingError()
     let end = safeChunkEnd(text, this.maxLength)
@@ -110,7 +111,7 @@ export class NoticeQueue {
     if (end <= label.length) throw new NoticeQueueChunkingError()
     const remainder = `${label}${text.slice(remainderStart)}`
     this.unshiftPending({...first, text: remainder})
-    return {message: text.slice(0, end)}
+    return {message: text.slice(0, end), ...metricClass(first)}
   }
 
   /**
@@ -196,10 +197,12 @@ export class NoticeQueue {
   async deliver(delivery) {
     if (delivery.activity === undefined) {
       await this.withRetry(() => this.sender.send(delivery.message))
+      this.noteDelivered(delivery)
       return
     }
     if (delivery.activity.phase === "started") {
       const sent = await this.withRetry(() => this.sender.send(delivery.message))
+      this.noteDelivered(delivery)
       const messageId = deliveredMessageId(sent)
       if (messageId !== undefined) this.activityMessageIds.set(delivery.activity.key, messageId)
       return
@@ -219,11 +222,18 @@ export class NoticeQueue {
     // swallow, so only an unrecoverable edit is dropped.
     try {
       await this.withRetry(() => edit(messageId, delivery.message))
+      this.noteDelivered(delivery)
     } catch {
       // Intentionally non-fatal: a failed completion edit never poisons the queue.
     }
   }
 
+  /** @param {Delivery} delivery */
+  noteDelivered(delivery) {
+    if (delivery.metricClass === undefined) return
+    this.onDelivered?.(delivery.metricClass, Buffer.byteLength(JSON.stringify(delivery.message), "utf8"))
+  }
+
   /** @template T @param {() => Promise<T>} operation @returns {Promise<T>} */
   async withRetry(operation) {
     for (let attempt = 0; attempt < 4; attempt += 1) {
@@ -241,6 +251,11 @@ export class NoticeQueue {
   }
 }
 
+/** @param {import("./types.js").RenderedNotice} notice */
+function metricClass(notice) {
+  return notice.metricClass === undefined ? {} : {metricClass: notice.metricClass}
+}
+
 /** @param {import("./types.js").SentMessage | void} sent @returns {number | undefined} */
 function deliveredMessageId(sent) {
   if (sent !== undefined && Number.isSafeInteger(sent.messageId)) return sent.messageId

package/src/providers/opencode.js

@@ -18,12 +18,11 @@ export function buildOpenCodeCommand(providerArguments, prompt, resumeSession, e
 export function createOpenCodeSessionId() {
   let emitted = false
   return (record) => {
-    if (emitted || !isRecord(record)) return undefined
-    const id = typeof record.sessionID === "string"
-      ? record.sessionID
-      : isRecord(record.part) && typeof record.part.sessionID === "string" ? record.part.sessionID : undefined
-    if (id !== undefined) emitted = true
-    return id
+    if (emitted) return undefined
+    const {sessionId, trusted} = recognizeOpenCodeRecord(record, () => [])
+    if (!trusted || sessionId === undefined) return undefined
+    emitted = true
+    return sessionId
   }
 }
 
@@ -31,29 +30,47 @@ export function createOpenCodeSessionId() {
 export function createOpenCodeParser() {
   let started = false
   const activeToolKeys = new Set()
-  return (record) => filterRepeatedToolStarts(parseOpenCodeRecord(record, () => {
+  return (record) => filterRepeatedToolStarts(recognizeOpenCodeRecord(record, () => {
     if (started) return []
     started = true
     return [{type: "lifecycle", phase: "started", summary: "OpenCode worker started"}]
-  }), activeToolKeys)
+  }).events, activeToolKeys)
 }
 
 /** @param {unknown} record @returns {import("../types.js").WorkerEvent[]} */
 export function parseOpenCodeEvent(record) {
-  return parseOpenCodeRecord(record, () => [{type: "lifecycle", phase: "started", summary: "OpenCode worker started"}])
+  return recognizeOpenCodeRecord(record, () => [{type: "lifecycle", phase: "started", summary: "OpenCode worker started"}]).events
 }
 
-/** @param {unknown} record @param {() => import("../types.js").WorkerEvent[]} start @returns {import("../types.js").WorkerEvent[]} */
-function parseOpenCodeRecord(record, start) {
-  if (!isRecord(record) || typeof record.type !== "string") return []
-  if (record.type === "step_start") return start()
-  if (record.type === "step_finish") return []
-  if (record.type === "error") return [{type: "lifecycle", phase: "failed", summary: "OpenCode worker failed"}]
+/**
+ * @param {unknown} record
+ * @param {() => import("../types.js").WorkerEvent[]} start
+ * @returns {{trusted: boolean, sessionId: string | undefined, events: import("../types.js").WorkerEvent[]}}
+ */
+function recognizeOpenCodeRecord(record, start) {
+  if (!isRecord(record) || typeof record.type !== "string") return {trusted: false, sessionId: undefined, events: []}
+  const part = isRecord(record.part) ? record.part : undefined
+  if (record.type === "step_start" && part?.type === "step-start") {
+    return {trusted: true, sessionId: sessionIdForKnownRecord(record, part), events: start()}
+  }
+  if (record.type === "step_finish" && part?.type === "step-finish") {
+    return {trusted: true, sessionId: sessionIdForKnownRecord(record, part), events: []}
+  }
+  if (record.type === "error" && part?.type === "error") {
+    return {trusted: true, sessionId: sessionIdForKnownRecord(record, part), events: [{type: "lifecycle", phase: "failed", summary: "OpenCode worker failed"}]}
+  }
   if (record.type === "text" && isRecord(record.part) && typeof record.part.text === "string") {
-    return [{type: "text-delta", text: record.part.text, streamId: stringValue(record.part.id, "opencode:assistant")}]
+    return {
+      trusted: true,
+      sessionId: sessionIdForKnownRecord(record, record.part),
+      events: [{type: "text-delta", text: record.part.text, streamId: stringValue(record.part.id, "opencode:assistant")}]
+    }
   }
-  if (record.type === "tool_use" && isRecord(record.part)) return parseTool(record.part)
-  return []
+  if (record.type === "tool_use" && isRecord(record.part)) {
+    const events = parseTool(record.part)
+    if (events.length > 0) return {trusted: true, sessionId: sessionIdForKnownRecord(record, record.part), events}
+  }
+  return {trusted: false, sessionId: undefined, events: []}
 }
 
 /** @param {Record<string, unknown>} part @returns {import("../types.js").WorkerEvent[]} */
@@ -104,6 +121,13 @@ function stringValue(value, fallback) {
   return typeof value === "string" ? value : fallback
 }
 
+/** @param {Record<string, unknown>} record @param {Record<string, unknown> | undefined} [part] */
+function sessionIdForKnownRecord(record, part) {
+  if (typeof record.sessionID === "string") return record.sessionID
+  if (part !== undefined && typeof part.sessionID === "string") return part.sessionID
+  return undefined
+}
+
 /** @param {unknown} value @returns {value is Record<string, unknown>} */
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value)

package/src/relay-write.js

@@ -0,0 +1,44 @@
+// @ts-check
+
+const MODEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u
+const COLORS = new Set(["always", "never", "auto"])
+
+/** @param {string[]} arguments_ */
+export function validateRelayWriteProviderArguments(arguments_) {
+  /** @type {string[]} */
+  const normalized = []
+  let model = "gpt-5-codex"
+  for (let index = 0; index < arguments_.length; index += 1) {
+    const argument = /** @type {string} */ (arguments_[index])
+    if (argument === "--model" || argument === "-m") {
+      const value = arguments_[index + 1]
+      if (value === undefined || !MODEL_PATTERN.test(value)) throw new Error("Provider argument is unavailable in relay write mode")
+      model = value
+      normalized.push("--model", value)
+      index += 1
+      continue
+    }
+    if (argument.startsWith("--model=")) {
+      const value = argument.slice("--model=".length)
+      if (!MODEL_PATTERN.test(value)) throw new Error("Provider argument is unavailable in relay write mode")
+      model = value
+      normalized.push("--model", value)
+      continue
+    }
+    if (argument === "--color") {
+      const value = arguments_[index + 1]
+      if (value === undefined || !COLORS.has(value)) throw new Error("Provider argument is unavailable in relay write mode")
+      normalized.push("--color", value)
+      index += 1
+      continue
+    }
+    if (argument.startsWith("--color=")) {
+      const value = argument.slice("--color=".length)
+      if (!COLORS.has(value)) throw new Error("Provider argument is unavailable in relay write mode")
+      normalized.push("--color", value)
+      continue
+    }
+    throw new Error("Provider argument is unavailable in relay write mode")
+  }
+  return {arguments: normalized, model}
+}