@avasapp/agent-bridge 0.1.0

package/dist/client/index.cjs

@@ -0,0 +1,568 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  AgentBridgeCallError: () => AgentBridgeCallError,
+  connect: () => connect,
+  connectSession: () => connectSession,
+  listDevices: () => listDevices,
+  listSessions: () => listSessions
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/client/discover.ts
+var DEFAULT_METRO = "localhost:8081";
+function metroHost(metro) {
+  return (metro ?? process.env.AGENT_BRIDGE_METRO ?? DEFAULT_METRO).replace(/^https?:\/\//, "").replace(/\/+$/, "");
+}
+async function expoHostUri(metro) {
+  try {
+    const res = await fetch(`http://${metro}/`, {
+      headers: {
+        "expo-platform": "ios",
+        accept: "application/expo+json,application/json"
+      },
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) return null;
+    const manifest = await res.json();
+    return manifest.extra?.expoClient?.hostUri ?? manifest.extra?.expoGo?.debuggerHost ?? manifest.hostUri ?? null;
+  } catch {
+    return null;
+  }
+}
+async function listCdpTargets(metro) {
+  const res = await fetch(`http://${metro}/json/list`, {
+    signal: AbortSignal.timeout(3e3)
+  });
+  if (!res.ok)
+    throw new Error(
+      `Metro at ${metro} answered /json/list with HTTP ${res.status}`
+    );
+  return await res.json();
+}
+function pickOne(items, filter, label) {
+  const matching = filter ? items.filter(
+    (item) => label(item).toLowerCase().includes(filter.toLowerCase())
+  ) : items;
+  const connected = items.map(label).join("; ") || "none";
+  if (matching.length === 0) {
+    throw new Error(
+      filter ? `No app matches "${filter}". Connected: ${connected}` : "No app is connected to Metro."
+    );
+  }
+  if (matching.length > 1 && !filter) {
+    throw new Error(
+      `${matching.length} apps are connected; pick one with --device. Connected: ${connected}`
+    );
+  }
+  return matching[0];
+}
+
+// src/shared/protocol.ts
+var PLUGIN_NAME = "agent-bridge";
+var CDP_GLOBAL = "__AGENT_BRIDGE__";
+var CDP_REPLY_BINDING = "__agentBridgeReply";
+function toAsciiJson(value) {
+  return JSON.stringify(value).replace(
+    /[\u007f-￿]/g,
+    (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`
+  );
+}
+
+// src/client/connection.ts
+var import_ws = __toESM(require("ws"), 1);
+function openSocket(url, headers) {
+  return new Promise((resolve, reject) => {
+    const ws = new import_ws.default(url, headers ? { headers } : void 0);
+    let opened = false;
+    ws.on("error", (event) => {
+      if (opened) return;
+      const message = event?.message ?? String(event);
+      reject(new Error(`Could not open ${url}: ${message}`));
+    });
+    ws.once("close", () => {
+      if (!opened) reject(new Error(`${url} closed before opening`));
+    });
+    ws.once("open", () => {
+      opened = true;
+      resolve(ws);
+    });
+  });
+}
+var newCallId = () => `c${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+function createPending() {
+  const waiting = /* @__PURE__ */ new Map();
+  return {
+    wait(id, tool, timeoutMs) {
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          waiting.delete(id);
+          reject(new Error(`No reply to "${tool}" within ${timeoutMs} ms`));
+        }, timeoutMs);
+        waiting.set(id, (result) => {
+          clearTimeout(timer);
+          waiting.delete(id);
+          resolve(result);
+        });
+      });
+    },
+    settle(result) {
+      waiting.get(result.id)?.(result);
+    },
+    failAll(reason) {
+      for (const [id, done] of waiting) {
+        done({ id, from: "", ok: false, error: reason, ms: 0 });
+      }
+    }
+  };
+}
+
+// src/client/expo.ts
+var deviceLabel = (d) => `${d.name} (${d.platform}, ${d.deviceId})`;
+async function openBroadcast(metro, discoveryMs) {
+  const ws = await openSocket(`ws://${metro}/expo-dev-plugins/broadcast`);
+  const devices = /* @__PURE__ */ new Map();
+  const pending = createPending();
+  ws.on("message", (data, isBinary) => {
+    if (isBinary) return;
+    let frame;
+    try {
+      frame = JSON.parse(String(data));
+    } catch {
+      return;
+    }
+    if (frame.messageKey?.pluginName !== PLUGIN_NAME) return;
+    if (frame.messageKey.method === "hello:reply") {
+      const info = frame.payload;
+      devices.set(info.deviceId, info);
+    } else if (frame.messageKey.method === "result") {
+      pending.settle(frame.payload);
+    }
+  });
+  ws.on("close", () => pending.failAll("Expo's dev-tools socket closed"));
+  const send = (method, payload) => ws.send(
+    JSON.stringify({
+      messageKey: { pluginName: PLUGIN_NAME, method },
+      payload
+    })
+  );
+  send("hello", {});
+  await new Promise((r) => setTimeout(r, discoveryMs));
+  return { ws, devices, pending, send };
+}
+async function listExpoDevices(metro, discoveryMs = 600) {
+  const { ws, devices } = await openBroadcast(metro, discoveryMs);
+  ws.close();
+  return [...devices.values()];
+}
+async function connectExpo(metro, device, discoveryMs = 600) {
+  const { ws, devices, pending, send } = await openBroadcast(metro, discoveryMs);
+  let info;
+  try {
+    info = pickOne([...devices.values()], device, deviceLabel);
+  } catch (error) {
+    ws.close();
+    throw error;
+  }
+  return {
+    transport: "expo",
+    device: info,
+    call(tool, args, timeoutMs) {
+      const call = {
+        id: newCallId(),
+        tool,
+        args,
+        to: info.deviceId
+      };
+      const reply = pending.wait(call.id, tool, timeoutMs);
+      send("call", call);
+      return reply;
+    },
+    close: () => ws.close()
+  };
+}
+
+// src/client/cdp.ts
+var import_ws2 = __toESM(require("ws"), 1);
+var targetLabel = (t) => `${t.title}${t.deviceName ? ` [${t.deviceName}]` : ""}`;
+async function connectCdp(metro, device) {
+  const target = pickOne(await listCdpTargets(metro), device, targetLabel);
+  const hostUri = await expoHostUri(metro);
+  const port = metro.split(":")[1] ?? "8081";
+  const origin = hostUri ? `http://${hostUri}` : `http://localhost:${port}`;
+  const closedEarly = `Metro closed the debugger socket. Origin sent: ${origin}. Is that the host Metro advertises?`;
+  const ws = await openSocket(target.webSocketDebuggerUrl, {
+    Origin: origin
+  }).catch(() => {
+    throw new Error(closedEarly);
+  });
+  let seq = 0;
+  let answered = false;
+  const commands = /* @__PURE__ */ new Map();
+  const pending = createPending();
+  ws.on("message", (data) => {
+    const message = JSON.parse(String(data));
+    if (message.id && commands.has(message.id)) {
+      answered = true;
+      commands.get(message.id)?.resolve(message);
+      commands.delete(message.id);
+    } else if (message.method === "Runtime.bindingCalled" && message.params?.name === CDP_REPLY_BINDING) {
+      pending.settle(JSON.parse(message.params.payload));
+    }
+  });
+  ws.on("close", () => {
+    const reason = answered ? "The debugger socket closed" : closedEarly;
+    for (const command of commands.values()) command.reject(new Error(reason));
+    commands.clear();
+    pending.failAll(reason);
+  });
+  const send = (method, params = {}) => new Promise((resolve, reject) => {
+    if (ws.readyState !== import_ws2.default.OPEN) {
+      reject(new Error(answered ? "The debugger socket closed" : closedEarly));
+      return;
+    }
+    const id = ++seq;
+    commands.set(id, { resolve, reject });
+    ws.send(JSON.stringify({ id, method, params }));
+  });
+  const evaluate = async (expression) => {
+    const message = await send("Runtime.evaluate", {
+      expression,
+      returnByValue: true
+    });
+    const details = message.result?.exceptionDetails;
+    if (details) {
+      const text = details.exception?.description ?? details.text ?? "evaluation failed";
+      throw new Error(text.split("\n")[0]);
+    }
+    return message.result?.result?.value;
+  };
+  await send("Runtime.enable");
+  await send("Runtime.addBinding", { name: CDP_REPLY_BINDING });
+  let info;
+  try {
+    info = JSON.parse(
+      String(await evaluate(`${CDP_GLOBAL}.info()`))
+    );
+  } catch {
+    ws.close();
+    throw new Error(
+      `agent-bridge isn't running in ${targetLabel(target)}. Is useAgentBridge mounted in a dev build?`
+    );
+  }
+  return {
+    transport: "cdp",
+    device: { ...info, name: `${info.name} (${targetLabel(target)})` },
+    async call(tool, args, timeoutMs) {
+      const call = { id: newCallId(), tool, args };
+      const reply = pending.wait(call.id, tool, timeoutMs);
+      try {
+        await evaluate(
+          `${CDP_GLOBAL}.dispatch(${JSON.stringify(toAsciiJson(call))})`
+        );
+      } catch (error) {
+        pending.settle({
+          id: call.id,
+          from: info.deviceId,
+          ok: false,
+          error: String(error),
+          ms: 0
+        });
+      }
+      return reply;
+    },
+    close: () => ws.close()
+  };
+}
+
+// src/client/open.ts
+async function openConnection(options = {}) {
+  const metro = metroHost(options.metro);
+  const want = options.transport ?? "auto";
+  let expoError;
+  if (want !== "cdp") {
+    try {
+      return await connectExpo(metro, options.device);
+    } catch (error) {
+      if (want === "expo") throw error;
+      expoError = error;
+    }
+  }
+  try {
+    return await connectCdp(metro, options.device);
+  } catch (error) {
+    const expoNote = expoError ? ` (Expo socket: ${String(expoError)})` : "";
+    throw new Error(
+      `${error instanceof Error ? error.message : String(error)}${expoNote}`
+    );
+  }
+}
+
+// src/client/session/client.ts
+var import_node_net = require("net");
+var import_node_readline = require("readline");
+
+// src/client/session/state.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var uid = () => process.getuid?.() ?? (0, import_node_os.userInfo)().username;
+function privateDir(dir) {
+  (0, import_node_fs.mkdirSync)(dir, { recursive: true, mode: 448 });
+  const stat = (0, import_node_fs.lstatSync)(dir);
+  if (!stat.isDirectory())
+    throw new Error(`${dir} is not a directory; remove it and retry`);
+  if (process.getuid && stat.uid !== process.getuid())
+    throw new Error(`${dir} belongs to another user; refusing to use it`);
+  if (process.platform !== "win32" && (stat.mode & 63) !== 0)
+    (0, import_node_fs.chmodSync)(dir, 448);
+  return dir;
+}
+function stateDir() {
+  return privateDir(
+    process.env.AGENT_BRIDGE_STATE_DIR ?? (process.env.XDG_RUNTIME_DIR ? (0, import_node_path.join)(process.env.XDG_RUNTIME_DIR, "agent-bridge") : (0, import_node_path.join)((0, import_node_os.tmpdir)(), `agent-bridge-${uid()}`))
+  );
+}
+var shortHash = (text) => (0, import_node_crypto.createHash)("sha256").update(text).digest("hex").slice(0, 16);
+function socketPath(name, dir) {
+  if (process.platform === "win32")
+    return `\\\\.\\pipe\\agent-bridge-${shortHash(dir)}-${name}`;
+  const path = (0, import_node_path.join)(dir, `${name}.sock`);
+  if (Buffer.byteLength(path) <= 100) return path;
+  const short = privateDir(`/tmp/agent-bridge-${uid()}`);
+  return (0, import_node_path.join)(short, `${shortHash(path)}.sock`);
+}
+var sessionFiles = (name, dir = stateDir()) => ({
+  state: (0, import_node_path.join)(dir, `${name}.json`),
+  error: (0, import_node_path.join)(dir, `${name}.error`),
+  log: (0, import_node_path.join)(dir, `${name}.log`),
+  socket: socketPath(name, dir)
+});
+function checkName(name) {
+  if (!/^[\w.-]{1,40}$/.test(name))
+    throw new Error(
+      `Session name "${name}" must be 1-40 letters, digits, ".", "_" or "-"`
+    );
+  return name;
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function removeSessionFiles(name, dir = stateDir()) {
+  const files = sessionFiles(name, dir);
+  (0, import_node_fs.rmSync)(files.state, { force: true });
+  if (process.platform !== "win32") (0, import_node_fs.rmSync)(files.socket, { force: true });
+}
+function readState(file) {
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function listSessions(dir = stateDir()) {
+  const live = [];
+  for (const entry of (0, import_node_fs.readdirSync)(dir)) {
+    if (!entry.endsWith(".json")) continue;
+    const state = readState((0, import_node_path.join)(dir, entry));
+    if (!state) continue;
+    if (isAlive(state.pid)) live.push(state);
+    else removeSessionFiles(state.name, dir);
+  }
+  return live.sort((a, b) => a.startedAt - b.startedAt);
+}
+function readSession(name, dir = stateDir()) {
+  return listSessions(dir).find((s) => s.name === name) ?? null;
+}
+function pickSession(filter) {
+  if (filter.name) {
+    const named = readSession(checkName(filter.name));
+    if (!named) throw new Error(`No session named "${filter.name}" is running`);
+    return named;
+  }
+  const device = filter.device?.toLowerCase();
+  const matching = listSessions().filter(
+    (s) => s.metro === filter.metro && (!device || s.device.name.toLowerCase().includes(device) || s.device.deviceId.toLowerCase().includes(device)) && (!filter.transport || filter.transport === "auto" || filter.transport === s.transport)
+  );
+  return matching.length === 1 ? matching[0] : null;
+}
+
+// src/client/session/client.ts
+function openSessionLink(state) {
+  return new Promise((resolve, reject) => {
+    const socket = (0, import_node_net.createConnection)(state.socket);
+    const waiting = /* @__PURE__ */ new Map();
+    let seq = 0;
+    let open = false;
+    const gone = `Session "${state.name}" closed the connection`;
+    socket.once("connect", () => {
+      open = true;
+      resolve({
+        request: (req) => new Promise((done, fail) => {
+          if (socket.destroyed || socket.writableEnded) {
+            fail(new Error(gone));
+            return;
+          }
+          const id = ++seq;
+          waiting.set(id, done);
+          socket.write(`${JSON.stringify({ ...req, id })}
+`);
+        }),
+        close: () => socket.end()
+      });
+    });
+    socket.on("error", (error) => {
+      if (!open)
+        reject(
+          new Error(
+            `Session "${state.name}" isn't answering on ${state.socket}: ${error.message}`
+          )
+        );
+    });
+    socket.on("close", () => {
+      for (const [id, done] of waiting) done({ id, error: gone });
+      waiting.clear();
+    });
+    (0, import_node_readline.createInterface)({ input: socket }).on("line", (line) => {
+      const res = JSON.parse(line);
+      waiting.get(res.id)?.(res);
+      waiting.delete(res.id);
+    });
+  });
+}
+async function connectSession(options = {}) {
+  const state = pickSession({
+    name: options.name ?? process.env.AGENT_BRIDGE_SESSION,
+    metro: metroHost(options.metro),
+    device: options.device,
+    transport: options.transport
+  });
+  if (!state)
+    throw new Error(
+      "No single session matches. Start one with `agent-bridge session start`, or name it."
+    );
+  const link = await openSessionLink(state);
+  const info = await link.request({ op: "info" });
+  if (info.error || !info.device || !info.transport) {
+    link.close();
+    throw new Error(info.error ?? `Session "${state.name}" sent no device`);
+  }
+  const device = info.device;
+  const timed = async (tool, ...args) => {
+    const res = await link.request({
+      op: "call",
+      tool,
+      args,
+      timeoutMs: options.timeoutMs
+    });
+    if (res.error || !res.result) throw new Error(res.error ?? "No result");
+    const result = res.result;
+    const logs = result.logs ?? [];
+    if (!result.ok) throw new AgentBridgeCallError(tool, result.error, logs);
+    const { id: _id, from: _from, ok: _ok, ms: appMs, value, ...extra } = result;
+    return { ...extra, value, ms: res.ms ?? 0, appMs, logs };
+  };
+  return {
+    session: info.state ?? state,
+    transport: info.transport,
+    device,
+    timed,
+    call: async (tool, ...args) => (await timed(tool, ...args)).value,
+    tools: () => device.tools,
+    close: link.close
+  };
+}
+
+// src/client/index.ts
+var AgentBridgeCallError = class extends Error {
+  constructor(tool, message, logs = []) {
+    super(`${tool}: ${message}`);
+    this.tool = tool;
+    this.logs = logs;
+    this.name = "AgentBridgeCallError";
+  }
+  tool;
+  logs;
+};
+async function connect(options = {}) {
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  const conn = await openConnection(options);
+  const timed = async (tool, ...args) => {
+    const t0 = performance.now();
+    const result = await conn.call(tool, args, timeoutMs);
+    const ms = performance.now() - t0;
+    const logs = result.logs ?? [];
+    if (!result.ok) throw new AgentBridgeCallError(tool, result.error, logs);
+    return { value: result.value, ms, appMs: result.ms, logs };
+  };
+  return {
+    transport: conn.transport,
+    device: conn.device,
+    timed,
+    call: async (tool, ...args) => (await timed(tool, ...args)).value,
+    tools: () => conn.device.tools,
+    close: conn.close
+  };
+}
+async function listDevices(options = {}) {
+  const metro = metroHost(options.metro);
+  const [expo, cdp] = await Promise.all([
+    listExpoDevices(metro).catch(() => []),
+    listCdpTargets(metro).catch(() => [])
+  ]);
+  return [
+    ...expo.map((d) => ({
+      transport: "expo",
+      name: d.name,
+      deviceId: d.deviceId,
+      tools: d.tools.length
+    })),
+    ...cdp.map((t) => ({
+      transport: "cdp",
+      name: `${t.title}${t.deviceName ? ` [${t.deviceName}]` : ""}`
+    }))
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentBridgeCallError,
+  connect,
+  connectSession,
+  listDevices,
+  listSessions
+});

package/dist/client/index.d.ts

@@ -0,0 +1,112 @@
+/** An error or warning the app logged, threw or left unhandled. */
+type LogEntry = {
+    level: 'error' | 'warn';
+    message: string;
+    /** First lines of the stack, when there was an Error. */
+    stack?: string;
+    /** Date.now() in the app. */
+    at: number;
+    /** The tool that was running when it was logged. */
+    during?: string;
+    /** Otherwise, the last tool that had finished. */
+    after?: string;
+};
+type ToolInfo = {
+    name: string;
+    description?: string;
+};
+type DeviceInfo = {
+    deviceId: string;
+    name: string;
+    platform: string;
+    protocol: number;
+    tools: ToolInfo[];
+};
+
+type TransportName = 'expo' | 'cdp';
+
+/** What a running session writes next to its socket. Readable only by the user. */
+type SessionState = {
+    name: string;
+    pid: number;
+    socket: string;
+    metro: string;
+    device: {
+        name: string;
+        deviceId: string;
+        platform: string;
+    };
+    /** The --device filter the session was started with, reused to reconnect. */
+    deviceFilter?: string;
+    transport: TransportName;
+    startedAt: number;
+    lastCallAt: number;
+    /** 0 means no idle timeout. */
+    idleMs: number;
+};
+/** Live sessions. State left by a daemon that died is removed on the way. */
+declare function listSessions(dir?: string): SessionState[];
+
+type SessionConnectOptions = {
+    /** Session name. Defaults to $AGENT_BRIDGE_SESSION, else the only session on this Metro. */
+    name?: string;
+    metro?: string;
+    device?: string;
+    transport?: 'auto' | TransportName;
+    /** Per-call timeout. Default: the session's (10 s). */
+    timeoutMs?: number;
+};
+/**
+ * Like `connect()`, through a running session (`agent-bridge session start`):
+ * no discovery, and the app stays connected when this closes.
+ */
+declare function connectSession(options?: SessionConnectOptions): Promise<AgentBridge & {
+    session: SessionState;
+}>;
+
+type ConnectOptions = {
+    /** Metro's host:port. Defaults to $AGENT_BRIDGE_METRO, then localhost:8081. */
+    metro?: string;
+    /** Part of the app's name or device name, when more than one is connected. */
+    device?: string;
+    /** "auto" tries Expo's socket first and falls back to CDP. */
+    transport?: 'auto' | TransportName;
+    /** Per-call timeout. Default 10 s. */
+    timeoutMs?: number;
+};
+declare class AgentBridgeCallError extends Error {
+    readonly tool: string;
+    /** Errors the app attached to the failed reply. */
+    readonly logs: LogEntry[];
+    constructor(tool: string, message: string, 
+    /** Errors the app attached to the failed reply. */
+    logs?: LogEntry[]);
+}
+/** `logs`: errors the app recorded since its previous reply. */
+type Timed<T> = {
+    value: T;
+    ms: number;
+    appMs: number;
+    logs: LogEntry[];
+};
+type AgentBridge = {
+    transport: TransportName;
+    device: DeviceInfo;
+    /** Calls a tool and returns its value; throws AgentBridgeCallError if the tool threw. */
+    call: <T = unknown>(tool: string, ...args: unknown[]) => Promise<NoInfer<T>>;
+    /** Like `call`, plus the round trip and the time spent inside the app. */
+    timed: <T = unknown>(tool: string, ...args: unknown[]) => Promise<Timed<NoInfer<T>>>;
+    tools: () => ToolInfo[];
+    close: () => void;
+};
+declare function connect(options?: ConnectOptions): Promise<AgentBridge>;
+type ListedDevice = {
+    transport: TransportName;
+    name: string;
+    deviceId?: string;
+    tools?: number;
+};
+/** Apps with the bridge on Expo's socket, plus every React Native page Metro knows. */
+declare function listDevices(options?: Pick<ConnectOptions, 'metro'>): Promise<ListedDevice[]>;
+
+export { type AgentBridge, AgentBridgeCallError, type ConnectOptions, type DeviceInfo, type ListedDevice, type LogEntry, type SessionConnectOptions, type SessionState, type Timed, type ToolInfo, type TransportName, connect, connectSession, listDevices, listSessions };

package/dist/client/index.js

@@ -0,0 +1,14 @@
+import {
+  AgentBridgeCallError,
+  connect,
+  connectSession,
+  listDevices,
+  listSessions
+} from "../chunk-UEWFQWCY.js";
+export {
+  AgentBridgeCallError,
+  connect,
+  connectSession,
+  listDevices,
+  listSessions
+};