opencode-drive 0.1.2 → 0.1.4

package/src/client/backend.ts

@@ -1,16 +1,25 @@
-import {
-  Backend,
-  type JsonRpc,
-} from "./protocol.js"
+import { Backend, type JsonRpc } from "./protocol.js"
 
 const defaultBackendPort = 40950
 
 type BackendMethods = {
-  readonly "llm.attach": { readonly params: undefined; readonly result: { readonly attached: true } }
-  readonly "llm.chunk": { readonly params: Backend.ChunkParams; readonly result: { readonly ok: true } }
-  readonly "llm.finish": { readonly params: Partial<Backend.FinishParams> & Pick<Backend.FinishParams, "id">; readonly result: { readonly ok: true } }
-  readonly "llm.disconnect": { readonly params: Backend.DisconnectParams; readonly result: { readonly ok: true } }
-  readonly "llm.pending": { readonly params: undefined; readonly result: { readonly exchanges: ReadonlyArray<Backend.OpenedExchange> } }
+  readonly "llm.attach": {
+    readonly params: undefined
+    readonly result: { readonly attached: true }
+  }
+  readonly "llm.chunk": {
+    readonly params: Backend.ChunkParams
+    readonly result: { readonly ok: true }
+  }
+  readonly "llm.finish": {
+    readonly params: Partial<Backend.FinishParams> &
+      Pick<Backend.FinishParams, "id">
+    readonly result: { readonly ok: true }
+  }
+  readonly "llm.disconnect": {
+    readonly params: Backend.DisconnectParams
+    readonly result: { readonly ok: true }
+  }
 }
 
 type BackendMethodName = keyof BackendMethods
@@ -45,21 +54,37 @@ export class BackendSimulationClient {
   private readonly socket: WebSocket
   private readonly timeout: number
   private nextId = 1
+  private closing = false
   private readonly pending = new Map<number, Waiter>()
-  private readonly llmRequests = new Set<(request: Backend.OpenedExchange) => void>()
+  private readonly llmRequests = new Set<
+    (request: Backend.OpenedExchange) => void
+  >()
 
   private constructor(socket: WebSocket, url: string, timeout: number) {
     this.socket = socket
     this.url = url
     this.timeout = timeout
-    socket.addEventListener("message", (event) => this.onMessage(String(event.data)))
-    socket.addEventListener("close", () => this.rejectAll(new BackendSimulationError("connection closed")))
-    socket.addEventListener("error", () => this.rejectAll(new BackendSimulationError("connection error")))
+    socket.addEventListener("message", (event) =>
+      this.onMessage(String(event.data)),
+    )
+    socket.addEventListener("close", () =>
+      this.rejectAll(new BackendSimulationError("connection closed")),
+    )
+    socket.addEventListener("error", () =>
+      this.rejectAll(new BackendSimulationError("connection error")),
+    )
   }
 
-  static async connect(options?: BackendSimulationClientOptions): Promise<BackendSimulationClient> {
+  static async connect(
+    options?: BackendSimulationClientOptions,
+  ): Promise<BackendSimulationClient> {
     const timeout = options?.timeout ?? 30_000
-    if (options?.url !== undefined) return new BackendSimulationClient(await open(options.url), options.url, timeout)
+    if (options?.url !== undefined)
+      return new BackendSimulationClient(
+        await open(options.url),
+        options.url,
+        timeout,
+      )
     const first = options?.port ?? defaultBackendPort
     const attempts = options?.portAttempts ?? 10
     for (let offset = 0; offset < attempts; offset++) {
@@ -68,28 +93,52 @@ export class BackendSimulationClient {
         return new BackendSimulationClient(await open(url), url, timeout)
       } catch {}
     }
-    throw new BackendSimulationError(`no backend simulation server found on ports ${first}-${first + attempts - 1}`)
+    throw new BackendSimulationError(
+      `no backend simulation server found on ports ${first}-${first + attempts - 1}`,
+    )
   }
 
   async call<M extends BackendMethodName>(
     method: M,
     params?: BackendMethods[M]["params"],
   ): Promise<BackendMethods[M]["result"]> {
-    if (this.socket.readyState !== WebSocket.OPEN) throw new BackendSimulationError("connection is not open", method)
+    if (this.socket.readyState !== WebSocket.OPEN)
+      throw new BackendSimulationError("connection is not open", method)
     const id = this.nextId++
     const promise = new Promise<unknown>((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id)
-        reject(new BackendSimulationError(`timed out after ${this.timeout}ms`, method))
+        reject(
+          new BackendSimulationError(
+            `timed out after ${this.timeout}ms`,
+            method,
+          ),
+        )
       }, this.timeout)
       this.pending.set(id, { method, resolve, reject, timer })
     })
-    this.socket.send(JSON.stringify({ jsonrpc: "2.0", id, method, ...(params === undefined ? {} : { params }) }))
+    this.socket.send(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        method,
+        ...(params === undefined ? {} : { params }),
+      }),
+    )
     return (await promise) as BackendMethods[M]["result"]
   }
 
-  async attach(onRequest: (request: Backend.OpenedExchange) => void | Promise<void>) {
-    this.llmRequests.add((request) => void onRequest(request))
+  async attach(
+    onRequest: (request: Backend.OpenedExchange) => void | Promise<void>,
+  ) {
+    this.llmRequests.add((request) => {
+      void Promise.resolve(onRequest(request)).catch((error) => {
+        if (!this.closing)
+          console.error(
+            `error: ${error instanceof Error ? error.message : String(error)}`,
+          )
+      })
+    })
     return await this.call("llm.attach")
   }
 
@@ -98,19 +147,19 @@ export class BackendSimulationClient {
   }
 
   finish(id: string, reason?: Backend.FinishReason) {
-    return this.call("llm.finish", { id, ...(reason === undefined ? {} : { reason }) })
+    return this.call("llm.finish", {
+      id,
+      ...(reason === undefined ? {} : { reason }),
+    })
   }
 
   disconnect(id: string) {
     return this.call("llm.disconnect", { id })
   }
 
-  pendingExchanges() {
-    return this.call("llm.pending")
-  }
-
   close() {
-    this.socket.close()
+    this.closing = true
+    this.socket.terminate()
   }
 
   private onMessage(data: string) {
@@ -118,7 +167,8 @@ export class BackendSimulationClient {
     if (message === undefined) return
     if ("method" in message) {
       if (message.method === "llm.request") {
-        for (const listener of this.llmRequests) listener(message.params as Backend.OpenedExchange)
+        for (const listener of this.llmRequests)
+          listener(message.params as Backend.OpenedExchange)
       }
       return
     }
@@ -127,7 +177,10 @@ export class BackendSimulationClient {
     if (waiter === undefined) return
     this.pending.delete(message.id)
     clearTimeout(waiter.timer)
-    if (message.error) waiter.reject(new BackendSimulationError(message.error.message, waiter.method))
+    if (message.error)
+      waiter.reject(
+        new BackendSimulationError(message.error.message, waiter.method),
+      )
     else waiter.resolve(message.result)
   }
 
@@ -140,13 +193,21 @@ export class BackendSimulationClient {
   }
 }
 
-function parseResponse(data: string): JsonRpc.Response | { readonly method: string; readonly params: unknown } | undefined {
+function parseResponse(
+  data: string,
+):
+  | JsonRpc.Response
+  | { readonly method: string; readonly params: unknown }
+  | undefined {
   try {
     const value = JSON.parse(data) as unknown
     if (typeof value !== "object" || value === null) return undefined
     if (!("jsonrpc" in value) || value.jsonrpc !== "2.0") return undefined
     if ("method" in value && typeof value.method === "string") {
-      return { method: value.method, params: "params" in value ? value.params : undefined }
+      return {
+        method: value.method,
+        params: "params" in value ? value.params : undefined,
+      }
     }
     if (!("id" in value)) return undefined
     return value as JsonRpc.Response
@@ -175,5 +236,6 @@ function open(url: string): Promise<WebSocket> {
   })
 }
 
-export const connectBackendSimulation = (options?: BackendSimulationClientOptions): Promise<BackendSimulationClient> =>
-  BackendSimulationClient.connect(options)
+export const connectBackendSimulation = (
+  options?: BackendSimulationClientOptions,
+): Promise<BackendSimulationClient> => BackendSimulationClient.connect(options)

package/src/client/client.ts

@@ -1,21 +1,48 @@
-import {
-  Frontend,
-  type JsonRpc,
-} from "./protocol.js"
+import { Frontend, type JsonRpc } from "./protocol.js"
 
 const defaultPort = 40900
 
 type Methods = {
-  readonly "ui.screenshot": { readonly params: undefined; readonly result: Frontend.Screenshot }
-  readonly "ui.state": { readonly params: undefined; readonly result: Frontend.State }
-  readonly "ui.start-record": { readonly params: undefined; readonly result: Frontend.StartRecord }
-  readonly "ui.end-record": { readonly params: undefined; readonly result: Frontend.EndRecord }
-  readonly "ui.type": { readonly params: Frontend.TypeParams; readonly result: Frontend.State }
-  readonly "ui.press": { readonly params: Frontend.PressParams; readonly result: Frontend.State }
-  readonly "ui.enter": { readonly params: undefined; readonly result: Frontend.State }
-  readonly "ui.arrow": { readonly params: Frontend.ArrowParams; readonly result: Frontend.State }
-  readonly "ui.focus": { readonly params: Frontend.FocusParams; readonly result: Frontend.State }
-  readonly "ui.click": { readonly params: Frontend.ClickParams; readonly result: Frontend.State }
+  readonly "ui.screenshot": {
+    readonly params: undefined
+    readonly result: Frontend.Screenshot
+  }
+  readonly "ui.state": {
+    readonly params: undefined
+    readonly result: Frontend.State
+  }
+  readonly "ui.start-record": {
+    readonly params: undefined
+    readonly result: Frontend.StartRecord
+  }
+  readonly "ui.end-record": {
+    readonly params: undefined
+    readonly result: Frontend.EndRecord
+  }
+  readonly "ui.type": {
+    readonly params: Frontend.TypeParams
+    readonly result: Frontend.State
+  }
+  readonly "ui.press": {
+    readonly params: Frontend.PressParams
+    readonly result: Frontend.State
+  }
+  readonly "ui.enter": {
+    readonly params: undefined
+    readonly result: Frontend.State
+  }
+  readonly "ui.arrow": {
+    readonly params: Frontend.ArrowParams
+    readonly result: Frontend.State
+  }
+  readonly "ui.focus": {
+    readonly params: Frontend.FocusParams
+    readonly result: Frontend.State
+  }
+  readonly "ui.click": {
+    readonly params: Frontend.ClickParams
+    readonly result: Frontend.State
+  }
 }
 
 type MethodName = keyof Methods
@@ -73,12 +100,20 @@ export class SimulationClient {
     this.socket = socket
     this.url = url
     this.timeout = timeout
-    socket.addEventListener("message", (event) => this.onMessage(String(event.data)))
-    socket.addEventListener("close", () => this.rejectAll(new SimulationError("connection closed")))
-    socket.addEventListener("error", () => this.rejectAll(new SimulationError("connection error")))
+    socket.addEventListener("message", (event) =>
+      this.onMessage(String(event.data)),
+    )
+    socket.addEventListener("close", () =>
+      this.rejectAll(new SimulationError("connection closed")),
+    )
+    socket.addEventListener("error", () =>
+      this.rejectAll(new SimulationError("connection error")),
+    )
   }
 
-  static async connect(options?: SimulationClientOptions): Promise<SimulationClient> {
+  static async connect(
+    options?: SimulationClientOptions,
+  ): Promise<SimulationClient> {
     const timeout = options?.timeout ?? 30_000
     if (options?.url !== undefined) {
       return new SimulationClient(await open(options.url), options.url, timeout)
@@ -100,7 +135,10 @@ export class SimulationClient {
   }
 
   /** Raw JSON-RPC call. Prefer the typed wrappers below. */
-  async call<M extends MethodName>(method: M, params?: Methods[M]["params"]): Promise<Methods[M]["result"]> {
+  async call<M extends MethodName>(
+    method: M,
+    params?: Methods[M]["params"],
+  ): Promise<Methods[M]["result"]> {
     if (this.socket.readyState !== WebSocket.OPEN) {
       throw new SimulationError("connection is not open", method)
     }
@@ -112,7 +150,14 @@ export class SimulationClient {
       }, this.timeout)
       this.pending.set(id, { method, resolve, reject, timer })
     })
-    this.socket.send(JSON.stringify({ jsonrpc: "2.0", id, method, ...(params === undefined ? {} : { params }) }))
+    this.socket.send(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        method,
+        ...(params === undefined ? {} : { params }),
+      }),
+    )
     // The server contract types each method's result; the cast happens once
     // here rather than at every call site.
     return (await promise) as Methods[M]["result"]
@@ -142,15 +187,23 @@ export class SimulationClient {
     return this.call("ui.type", { text })
   }
 
-  pressKey(key: string, modifiers?: Frontend.KeyModifiers): Promise<Frontend.State> {
-    return this.call("ui.press", { key: key === "escape" ? "\u001b" : key, ...(modifiers === undefined ? {} : { modifiers }) })
+  pressKey(
+    key: string,
+    modifiers?: Frontend.KeyModifiers,
+  ): Promise<Frontend.State> {
+    return this.call("ui.press", {
+      key: key === "escape" ? "\u001b" : key,
+      ...(modifiers === undefined ? {} : { modifiers }),
+    })
   }
 
   pressEnter(): Promise<Frontend.State> {
     return this.call("ui.enter")
   }
 
-  pressArrow(direction: "up" | "down" | "left" | "right"): Promise<Frontend.State> {
+  pressArrow(
+    direction: "up" | "down" | "left" | "right",
+  ): Promise<Frontend.State> {
     return this.call("ui.arrow", { direction })
   }
 
@@ -165,7 +218,7 @@ export class SimulationClient {
   // ── lifecycle ─────────────────────────────────────────────────────────
 
   close(): void {
-    this.socket.close()
+    this.socket.terminate()
   }
 
   private onMessage(data: string) {
@@ -175,7 +228,8 @@ export class SimulationClient {
     if (waiter === undefined) return
     this.pending.delete(message.id)
     clearTimeout(waiter.timer)
-    if (message.error) waiter.reject(new SimulationError(message.error.message, waiter.method))
+    if (message.error)
+      waiter.reject(new SimulationError(message.error.message, waiter.method))
     else waiter.resolve(message.result)
   }
 
@@ -199,14 +253,16 @@ function parseResponse(data: string): JsonRpc.Response | undefined {
   if (!("jsonrpc" in value) || value.jsonrpc !== "2.0") return undefined
   if (!("id" in value)) return undefined
   const id = value.id
-  if (typeof id !== "number" && typeof id !== "string" && id !== null) return undefined
+  if (typeof id !== "number" && typeof id !== "string" && id !== null)
+    return undefined
   const result = "result" in value ? value.result : undefined
   const error = "error" in value ? value.error : undefined
   if (error !== undefined) {
     if (typeof error !== "object" || error === null) return undefined
     const code = "code" in error ? error.code : undefined
     const message = "message" in error ? error.message : undefined
-    if (typeof code !== "number" || typeof message !== "string") return undefined
+    if (typeof code !== "number" || typeof message !== "string")
+      return undefined
     return { jsonrpc: "2.0", id, error: { code, message } }
   }
   return { jsonrpc: "2.0", id, result: result as JsonRpc.Response["result"] }
@@ -232,5 +288,6 @@ function open(url: string): Promise<WebSocket> {
   })
 }
 
-export const connectSimulation = (options?: SimulationClientOptions): Promise<SimulationClient> =>
-  SimulationClient.connect(options)
+export const connectSimulation = (
+  options?: SimulationClientOptions,
+): Promise<SimulationClient> => SimulationClient.connect(options)

package/src/client/protocol.ts

@@ -31,7 +31,10 @@ export namespace JsonRpc {
 
   export const decodeRequest = Schema.decodeUnknownSync(Request)
 
-  export function success(id: Request["id"], result: unknown): Response | undefined {
+  export function success(
+    id: Request["id"],
+    result: unknown,
+  ): Response | undefined {
     if (id === undefined) return undefined
     return { jsonrpc: "2.0", id, result: result as Json }
   }
@@ -56,15 +59,29 @@ export namespace Frontend {
     super: Schema.optional(Schema.Boolean),
     hyper: Schema.optional(Schema.Boolean),
   })
-  export interface KeyModifiers extends Schema.Schema.Type<typeof KeyModifiers> {}
+  export interface KeyModifiers extends Schema.Schema.Type<
+    typeof KeyModifiers
+  > {}
 
   export const Action = Schema.Union([
     Schema.Struct({ type: Schema.Literal("ui.type"), text: Schema.String }),
-    Schema.Struct({ type: Schema.Literal("ui.press"), key: Schema.String, modifiers: Schema.optional(KeyModifiers) }),
+    Schema.Struct({
+      type: Schema.Literal("ui.press"),
+      key: Schema.String,
+      modifiers: Schema.optional(KeyModifiers),
+    }),
     Schema.Struct({ type: Schema.Literal("ui.enter") }),
-    Schema.Struct({ type: Schema.Literal("ui.arrow"), direction: Schema.Literals(["up", "down", "left", "right"]) }),
+    Schema.Struct({
+      type: Schema.Literal("ui.arrow"),
+      direction: Schema.Literals(["up", "down", "left", "right"]),
+    }),
     Schema.Struct({ type: Schema.Literal("ui.focus"), target: Schema.Number }),
-    Schema.Struct({ type: Schema.Literal("ui.click"), target: Schema.Number, x: Schema.Number, y: Schema.Number }),
+    Schema.Struct({
+      type: Schema.Literal("ui.click"),
+      target: Schema.Number,
+      x: Schema.Number,
+      y: Schema.Number,
+    }),
   ])
   export type Action = Schema.Schema.Type<typeof Action>
 
@@ -103,24 +120,53 @@ export namespace Frontend {
   export const TypeParams = Schema.Struct({ text: Schema.String })
   export interface TypeParams extends Schema.Schema.Type<typeof TypeParams> {}
 
-  export const PressParams = Schema.Struct({ key: Schema.String, modifiers: Schema.optional(KeyModifiers) })
+  export const PressParams = Schema.Struct({
+    key: Schema.String,
+    modifiers: Schema.optional(KeyModifiers),
+  })
   export interface PressParams extends Schema.Schema.Type<typeof PressParams> {}
 
-  export const ArrowParams = Schema.Struct({ direction: Schema.Literals(["up", "down", "left", "right"]) })
+  export const ArrowParams = Schema.Struct({
+    direction: Schema.Literals(["up", "down", "left", "right"]),
+  })
   export interface ArrowParams extends Schema.Schema.Type<typeof ArrowParams> {}
 
   export const FocusParams = Schema.Struct({ target: Schema.Number })
   export interface FocusParams extends Schema.Schema.Type<typeof FocusParams> {}
 
-  export const ClickParams = Schema.Struct({ target: Schema.Number, x: Schema.Number, y: Schema.Number })
+  export const ClickParams = Schema.Struct({
+    target: Schema.Number,
+    x: Schema.Number,
+    y: Schema.Number,
+  })
   export interface ClickParams extends Schema.Schema.Type<typeof ClickParams> {}
 
   export const Request = Schema.Union([
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.type"), params: TypeParams }),
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.press"), params: PressParams }),
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.arrow"), params: ArrowParams }),
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.focus"), params: FocusParams }),
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.click"), params: ClickParams }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("ui.type"),
+      params: TypeParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("ui.press"),
+      params: PressParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("ui.arrow"),
+      params: ArrowParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("ui.focus"),
+      params: FocusParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("ui.click"),
+      params: ClickParams,
+    }),
     Schema.Struct({
       ...JsonRpc.RequestFields,
       method: Schema.Literals([
@@ -134,47 +180,87 @@ export namespace Frontend {
   ])
   export type Request = Schema.Schema.Type<typeof Request>
   export const decodeRequest = Schema.decodeUnknownSync(Request)
-
 }
 
 export namespace Backend {
   export const Item = Schema.Union([
     Schema.Struct({ type: Schema.Literal("textDelta"), text: Schema.String }),
-    Schema.Struct({ type: Schema.Literal("reasoningDelta"), text: Schema.String }),
-    Schema.Struct({ type: Schema.Literal("toolCall"), id: Schema.String, name: Schema.String, input: Schema.Json }),
+    Schema.Struct({
+      type: Schema.Literal("reasoningDelta"),
+      text: Schema.String,
+    }),
+    Schema.Struct({
+      type: Schema.Literal("toolCall"),
+      index: Schema.Number,
+      id: Schema.String,
+      name: Schema.String,
+      input: Schema.Json,
+    }),
     Schema.Struct({ type: Schema.Literal("raw"), chunk: Schema.Json }),
   ])
   export type Item = Schema.Schema.Type<typeof Item>
 
-  export const FinishReason = Schema.Literals(["stop", "tool-calls", "length", "content-filter"])
+  export const FinishReason = Schema.Literals([
+    "stop",
+    "tool-calls",
+    "length",
+    "content-filter",
+  ])
   export type FinishReason = Schema.Schema.Type<typeof FinishReason>
 
-  export const ChunkParams = Schema.Struct({ id: Schema.String, items: Schema.Array(Item) })
+  export const ChunkParams = Schema.Struct({
+    id: Schema.String,
+    items: Schema.Array(Item),
+  })
   export interface ChunkParams extends Schema.Schema.Type<typeof ChunkParams> {}
 
   export const FinishParams = Schema.Struct({
     id: Schema.String,
-    reason: FinishReason.pipe(Schema.withDecodingDefault(Effect.succeed("stop" as const))),
+    reason: FinishReason.pipe(
+      Schema.withDecodingDefault(Effect.succeed("stop" as const)),
+    ),
   })
-  export interface FinishParams extends Schema.Schema.Type<typeof FinishParams> {}
+  export interface FinishParams extends Schema.Schema.Type<
+    typeof FinishParams
+  > {}
 
   export const DisconnectParams = Schema.Struct({ id: Schema.String })
-  export interface DisconnectParams extends Schema.Schema.Type<typeof DisconnectParams> {}
+  export interface DisconnectParams extends Schema.Schema.Type<
+    typeof DisconnectParams
+  > {}
 
   export const Request = Schema.Union([
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.chunk"), params: ChunkParams }),
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.finish"), params: FinishParams }),
-    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.disconnect"), params: DisconnectParams }),
     Schema.Struct({
       ...JsonRpc.RequestFields,
-      method: Schema.Literals(["llm.attach", "llm.pending"]),
+      method: Schema.Literal("llm.chunk"),
+      params: ChunkParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("llm.finish"),
+      params: FinishParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("llm.disconnect"),
+      params: DisconnectParams,
+    }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literal("llm.attach"),
     }),
   ])
   export type Request = Schema.Schema.Type<typeof Request>
   export const decodeRequest = Schema.decodeUnknownSync(Request)
 
-  export const OpenedExchange = Schema.Struct({ id: Schema.String, url: Schema.String, body: Schema.Json })
-  export interface OpenedExchange extends Schema.Schema.Type<typeof OpenedExchange> {}
+  export const OpenedExchange = Schema.Struct({
+    id: Schema.String,
+    url: Schema.String,
+    body: Schema.Json,
+  })
+  export interface OpenedExchange extends Schema.Schema.Type<
+    typeof OpenedExchange
+  > {}
 
   export const NetworkLogEntry = Schema.Struct({
     time: Schema.Number,
@@ -182,8 +268,9 @@ export namespace Backend {
     url: Schema.String,
     matched: Schema.Boolean,
   })
-  export interface NetworkLogEntry extends Schema.Schema.Type<typeof NetworkLogEntry> {}
-
+  export interface NetworkLogEntry extends Schema.Schema.Type<
+    typeof NetworkLogEntry
+  > {}
 }
 
 export * as SimulationProtocol from "./index"