@coolclaw/clawtopia-connector 0.1.0

package/dist/chunk-5OV44BPP.js

@@ -0,0 +1,1128 @@
+// src/protocol.ts
+import { randomUUID } from "crypto";
+var PROTOCOL_VERSION = 1;
+var EXACT_ACK_CAPABILITY = "EXACT_MESSAGE_ACK_V1";
+var RECEIPT_CAPABILITY = "MESSAGE_PROCESSING_RECEIPT_V1";
+var MEDIA_INPUT_CAPABILITY = "MEDIA_INPUT_V1";
+var GAME_CAPABILITY = "WEREWOLF_STRUCTURED_JSON_MESSAGE_V1";
+var PROMPT_PASSTHROUGH_CAPABILITY = "AGENT_TASK_PROMPT_PASSTHROUGH_V1";
+var DEFAULT_CAPABILITIES = [GAME_CAPABILITY, EXACT_ACK_CAPABILITY, RECEIPT_CAPABILITY, PROMPT_PASSTHROUGH_CAPABILITY, MEDIA_INPUT_CAPABILITY];
+function createFrame(type, payload, ack) {
+  return { v: PROTOCOL_VERSION, type, id: `cli_${randomUUID()}`, ts: Date.now(), ...ack ? { ack } : {}, ...payload === void 0 ? {} : { payload } };
+}
+function respondFrame(type, ack, payload) {
+  return createFrame(type, payload, ack.id);
+}
+function encodeFrame(frame) {
+  return JSON.stringify(frame);
+}
+var FrameDecodeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FrameDecodeError";
+  }
+};
+function decodeFrame(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw.toString());
+  } catch (error) {
+    throw new FrameDecodeError(`invalid JSON: ${error.message}`);
+  }
+  if (!isRecord(value) || value.v !== PROTOCOL_VERSION || typeof value.type !== "string" || !value.type || typeof value.id !== "string" || !value.id || typeof value.ts !== "number" || !Number.isFinite(value.ts)) {
+    throw new FrameDecodeError("invalid frame: expected {v:1,type,id,ts}");
+  }
+  if (value.ack !== void 0 && typeof value.ack !== "string") throw new FrameDecodeError("invalid frame ack");
+  return { v: PROTOCOL_VERSION, type: value.type, id: value.id, ts: value.ts, ...typeof value.ack === "string" ? { ack: value.ack } : {}, ...Object.hasOwn(value, "payload") ? { payload: value.payload } : {} };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isInboundMessage(frame) {
+  return frame.type === "PRIVATE_MESSAGE" || frame.type === "GROUP_MESSAGE";
+}
+function isGameEvent(frame) {
+  return frame.type === "GAME_EVENT";
+}
+function readSeq(frame) {
+  const p = isRecord(frame.payload) ? frame.payload : void 0;
+  return typeof p?.seq === "number" && Number.isSafeInteger(p.seq) && p.seq > 0 ? p.seq : void 0;
+}
+function readMessageId(frame) {
+  const p = isRecord(frame.payload) ? frame.payload : void 0;
+  return typeof p?.messageId === "string" && p.messageId ? p.messageId : void 0;
+}
+
+// src/channel-client.ts
+import WebSocket from "ws";
+var ChannelClient = class {
+  constructor(options) {
+    this.options = options;
+    const capabilities = options.capabilities ?? [...DEFAULT_CAPABILITIES];
+    if (!capabilities.includes(EXACT_ACK_CAPABILITY)) throw new Error(`connector requires ${EXACT_ACK_CAPABILITY}`);
+  }
+  options;
+  socket;
+  heartbeat;
+  reconnectTimer;
+  pending = /* @__PURE__ */ new Map();
+  stopped = true;
+  reconnectAttempt = 0;
+  helloPayload;
+  frameHandler;
+  setFrameHandler(handler) {
+    this.frameHandler = handler;
+  }
+  async start() {
+    this.stopped = false;
+    await this.connect();
+  }
+  async stop() {
+    this.stopped = true;
+    this.clearReconnect();
+    this.clearHeartbeat();
+    this.rejectPending(new Error("channel client stopped"));
+    const socket = this.socket;
+    this.socket = void 0;
+    if (!socket || socket.readyState === WebSocket.CLOSED) return;
+    await new Promise((resolve3) => {
+      const done = () => resolve3();
+      socket.once("close", done);
+      socket.close(1e3, "connector stopped");
+      setTimeout(done, 1e3).unref?.();
+    });
+  }
+  isConnected() {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+  getHelloPayload() {
+    return this.helloPayload;
+  }
+  getGatewayUrl() {
+    return this.options.gatewayUrl;
+  }
+  async request(frame) {
+    if (!this.isConnected()) throw new Error("channel client is not connected");
+    const timeoutMs = this.options.requestTimeoutMs ?? 1e4;
+    return new Promise((resolve3, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(frame.id);
+        reject(new Error(`channel request timed out: ${frame.type}`));
+      }, timeoutMs);
+      this.pending.set(frame.id, { resolve: (value) => resolve3(value), reject, timer });
+      try {
+        this.socket.send(encodeFrame(frame));
+      } catch (error) {
+        clearTimeout(timer);
+        this.pending.delete(frame.id);
+        reject(asError(error));
+      }
+    });
+  }
+  send(frame) {
+    if (!this.isConnected()) throw new Error("channel client is not connected");
+    this.socket.send(encodeFrame(frame));
+  }
+  async ack(serverSeq, messageId) {
+    const payload = { serverSeq, ...messageId ? { messageId } : {} };
+    const response = await this.request(createFrame("ACK", payload));
+    if (response?.ok !== true) throw new Error("server rejected message ACK");
+  }
+  async receipt(payload) {
+    const response = await this.request(createFrame("MESSAGE_RECEIPT", payload));
+    if (response?.ok !== true) throw new Error("server rejected processing receipt");
+  }
+  async connect() {
+    this.notify("connecting");
+    const url = buildWsUrl(this.options.gatewayUrl);
+    const capabilities = this.options.capabilities ?? [...DEFAULT_CAPABILITIES];
+    const socket = new WebSocket(url, { headers: {
+      Authorization: `Bearer ${this.options.token}`,
+      "X-CoolClaw-Agent-Id": this.options.agentId,
+      "X-CoolClaw-Plugin-Version": this.options.connectorVersion,
+      "X-CoolClaw-Capabilities": capabilities.join(",")
+    } });
+    this.socket = socket;
+    await new Promise((resolve3, reject) => {
+      let hello = false;
+      const cleanup = () => {
+        socket.off("error", onError);
+        socket.off("message", onMessage);
+        socket.off("close", onClose);
+      };
+      const onError = (error) => {
+        if (!hello) {
+          cleanup();
+          reject(error);
+        } else this.options.onError?.(error);
+      };
+      const onClose = (code) => {
+        if (!hello) {
+          cleanup();
+          reject(new Error(`channel closed before HELLO: ${code}`));
+        }
+        this.handleClose(code);
+      };
+      const onMessage = (data) => {
+        try {
+          const frame = decodeFrame(data);
+          if (frame.type === "HELLO" && !hello) {
+            hello = true;
+            this.helloPayload = frame.payload;
+            this.reconnectAttempt = 0;
+            cleanup();
+            socket.on("message", (next) => this.handleRaw(next));
+            socket.on("close", (code) => this.handleClose(code));
+            socket.on("error", (error) => this.options.onError?.(asError(error)));
+            this.startHeartbeat(frame.payload);
+            this.notify("connected");
+            resolve3();
+          }
+          if (!hello || frame.type === "HELLO") return;
+          void this.handleFrame(frame).catch((error) => this.options.onError?.(asError(error)));
+        } catch (error) {
+          this.options.onError?.(asError(error));
+        }
+      };
+      socket.on("error", onError);
+      socket.on("message", onMessage);
+      socket.on("close", onClose);
+    });
+  }
+  handleRaw(data) {
+    try {
+      void this.handleFrame(decodeFrame(data)).catch((error) => this.options.onError?.(asError(error)));
+    } catch (error) {
+      this.options.onError?.(asError(error));
+    }
+  }
+  async handleFrame(frame) {
+    if (frame.ack) {
+      const request = this.pending.get(frame.ack);
+      if (request) {
+        clearTimeout(request.timer);
+        this.pending.delete(frame.ack);
+        if (frame.type === "ERROR") request.reject(new Error(readError(frame.payload)));
+        else request.resolve(frame.payload);
+        return;
+      }
+    }
+    if (frame.type === "PING") {
+      this.send(respondFrameSafe("PONG", frame, { clientTime: Date.now() }));
+      return;
+    }
+    if (frame.type === "PONG" || frame.type === "HELLO") return;
+    await (this.frameHandler ?? this.options.onFrame)?.(frame, this);
+  }
+  startHeartbeat(payload) {
+    this.clearHeartbeat();
+    const interval = this.options.heartbeatIntervalMs ?? readPingInterval(payload) ?? 2e4;
+    this.heartbeat = setInterval(() => {
+      if (this.isConnected()) this.send(createFrame("PING", { clientTime: Date.now() }));
+    }, interval);
+    this.heartbeat.unref?.();
+  }
+  handleClose(code) {
+    this.clearHeartbeat();
+    this.rejectPending(new Error(`channel connection closed: ${code}`));
+    if (this.stopped || isTerminalClose(code)) {
+      this.notify("disconnected");
+      return;
+    }
+    this.notify("reconnecting");
+    this.scheduleReconnect();
+  }
+  scheduleReconnect() {
+    this.clearReconnect();
+    const base = this.options.reconnectDelayMs ?? 1e3;
+    const delay = Math.min(base * 2 ** this.reconnectAttempt++, 6e4);
+    this.reconnectTimer = setTimeout(() => {
+      if (!this.stopped) void this.connect().catch((error) => {
+        this.options.onError?.(asError(error));
+        if (!this.stopped) this.scheduleReconnect();
+      });
+    }, delay);
+    this.reconnectTimer.unref?.();
+  }
+  rejectPending(error) {
+    for (const [id, request] of this.pending) {
+      clearTimeout(request.timer);
+      request.reject(error);
+      this.pending.delete(id);
+    }
+  }
+  clearHeartbeat() {
+    if (this.heartbeat) {
+      clearInterval(this.heartbeat);
+      this.heartbeat = void 0;
+    }
+  }
+  clearReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
+  }
+  notify(state) {
+    this.options.onStateChange?.(state);
+  }
+};
+function respondFrameSafe(type, frame, payload) {
+  return { ...createFrame(type, payload), ack: frame.id };
+}
+function buildWsUrl(gatewayUrl) {
+  const base = gatewayUrl.replace(/\/+$/u, "");
+  const url = base.replace(/^http:/u, "ws:").replace(/^https:/u, "wss:");
+  return url.endsWith("/ws/channel") ? url : `${url}/ws/channel`;
+}
+function readPingInterval(payload) {
+  return isRecord2(payload) && typeof payload.pingIntervalMs === "number" && payload.pingIntervalMs > 0 ? payload.pingIntervalMs : void 0;
+}
+function readError(payload) {
+  return isRecord2(payload) && typeof payload.message === "string" ? payload.message : "channel request failed";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function asError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function isTerminalClose(code) {
+  return [4001, 4002, 4003, 4004, 4005, 4008].includes(code);
+}
+
+// src/flavor.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+var DEV_FLAVOR = {
+  key: "clawtopia",
+  packageName: "@clawtopia/clawtopia-connector",
+  environment: "local",
+  defaultGatewayUrl: "http://localhost:8110/riddle"
+};
+function packageRoot() {
+  return dirname(dirname(fileURLToPath(import.meta.url)));
+}
+function parseFlavor(raw) {
+  const value = JSON.parse(raw);
+  if (value.key !== "clawtopia" && value.key !== "coolclaw" || !value.packageName || !value.environment || !value.defaultGatewayUrl) {
+    throw new Error("invalid connector flavor descriptor");
+  }
+  return { key: value.key, packageName: value.packageName, environment: value.environment, defaultGatewayUrl: value.defaultGatewayUrl };
+}
+function activeFlavor(env = process.env) {
+  const file = env.CLAWTOPIA_FLAVOR_FILE ? resolve(env.CLAWTOPIA_FLAVOR_FILE) : join(packageRoot(), "flavor.json");
+  if (!existsSync(file)) return DEV_FLAVOR;
+  return parseFlavor(readFileSync(file, "utf8"));
+}
+function assertEnvironmentMatches(flavor, serverEnvironment) {
+  if (flavor.environment === "local") return;
+  if (typeof serverEnvironment !== "string" || !serverEnvironment) return;
+  if (serverEnvironment !== flavor.environment) {
+    throw new Error(`pairing environment mismatch: ${flavor.packageName} serves ${flavor.environment}, pairing code belongs to ${serverEnvironment}`);
+  }
+}
+
+// src/config.ts
+import { homedir } from "os";
+import { join as join2, resolve as resolve2 } from "path";
+import { dirname as dirname2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { mkdir, open, readFile, rename, rm } from "fs/promises";
+import { randomUUID as randomUUID2 } from "crypto";
+function configRoot() {
+  return process.env.CLAWTOPIA_AGENT_HOME ?? join2(homedir(), ".config", "clawtopia-agent");
+}
+function normalizeProfileId(value) {
+  const id = value.trim();
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(id)) throw new Error("profile id must contain 1-64 letters, numbers, dot, underscore or hyphen");
+  return id;
+}
+function profileConfigPath(profileId = process.env.CLAWTOPIA_AGENT_PROFILE ?? "default") {
+  if (process.env.CLAWTOPIA_AGENT_CONFIG && profileId === "default") return resolve2(process.env.CLAWTOPIA_AGENT_CONFIG);
+  return join2(configRoot(), "profiles", normalizeProfileId(profileId), "config.json");
+}
+var defaultConfigPath = profileConfigPath;
+function bundledWorkerPath() {
+  const platform = process.platform;
+  const architecture = process.arch === "x64" ? "x64" : process.arch === "arm64" ? "arm64" : process.arch;
+  const packageRoot2 = dirname2(dirname2(fileURLToPath2(import.meta.url)));
+  const candidate = join2(packageRoot2, "worker", `${platform}-${architecture}`, "agent-worker");
+  return existsSync2(candidate) ? candidate : "agent-worker";
+}
+function defaultConfig(profileId = process.env.CLAWTOPIA_AGENT_PROFILE ?? "default") {
+  const id = normalizeProfileId(profileId);
+  const flavor = activeFlavor();
+  return { schemaVersion: 1, profileId: id, gatewayUrl: flavor.defaultGatewayUrl, environment: flavor.environment, agentId: "", token: "", runtime: "claudecode", workerPath: bundledWorkerPath(), workDir: join2(homedir(), ".local", "share", "clawtopia-agent", "profiles", id, "work"), connectorVersion: "0.1.0", permissionPolicy: "deny", pairingEndpoint: "/api/agent/pairing/exchange" };
+}
+async function loadConfig(path = defaultConfigPath()) {
+  const value = JSON.parse(await readFile(path, "utf8"));
+  const pathId = profileIdFromPath(path);
+  const id = typeof value.profileId === "string" ? normalizeProfileId(value.profileId) : pathId ?? "default";
+  if (pathId && id !== pathId) throw new Error(`profile mismatch: config belongs to ${id}, path belongs to ${pathId}`);
+  return { ...defaultConfig(id), ...value, profileId: id, schemaVersion: value.schemaVersion ?? 1 };
+}
+async function saveConfig(config, path = profileConfigPath(config.profileId)) {
+  const id = normalizeProfileId(config.profileId);
+  const target = resolve2(path);
+  const expected = resolve2(profileConfigPath(id));
+  if (!process.env.CLAWTOPIA_AGENT_CONFIG && target !== expected) throw new Error(`profile config must be ${expected}`);
+  const pathId = profileIdFromPath(target);
+  if (pathId && pathId !== id) throw new Error(`profile mismatch: config belongs to ${id}, path belongs to ${pathId}`);
+  await mkdir(join2(target, ".."), { recursive: true, mode: 448 });
+  const temporary = `${target}.tmp-${randomUUID2()}`;
+  try {
+    const handle = await open(temporary, "wx", 384);
+    try {
+      await handle.writeFile(`${JSON.stringify({ ...config, schemaVersion: 1, profileId: id }, null, 2)}
+`, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await rename(temporary, target);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+function profileEnvironment(config, configPath = profileConfigPath(config.profileId)) {
+  const profilePath = resolve2(configPath);
+  return {
+    CLAWTOPIA_PROFILE_CONFIG: profilePath,
+    CLAWTOPIA_PROFILE_ID: config.profileId,
+    CLAWTOPIA_AGENT_ID: config.agentId,
+    CLAWTOPIA_GATEWAY_URL: config.gatewayUrl,
+    CLAWTOPIA_AGENT_TOKEN: config.token,
+    COOLCLAW_GATEWAY_URL: config.gatewayUrl,
+    COOLCLAW_AGENT_ID: config.agentId,
+    COOLCLAW_AGENT_TOKEN: config.token
+  };
+}
+function profileIdFromPath(path) {
+  const match = path.replaceAll("\\", "/").match(/\/profiles\/([^/]+)\/config\.json$/u);
+  return match?.[1] ? normalizeProfileId(match[1]) : void 0;
+}
+
+// src/state-store.ts
+import { mkdir as mkdir2, readFile as readFile2, rename as rename2, rm as rm2, writeFile } from "fs/promises";
+import { randomUUID as randomUUID3 } from "crypto";
+import { dirname as dirname3 } from "path";
+var EMPTY_STATE = { version: 1, processedMessageIds: [], processedEventIds: [], sessionIds: {}, agentSessionIds: {}, inflight: {}, updatedAt: 0 };
+var MemoryStateStore = class {
+  state = cloneState(EMPTY_STATE);
+  async load() {
+    return cloneState(this.state);
+  }
+  async save(state) {
+    this.state = cloneState(state);
+  }
+};
+var JsonFileStateStore = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  writeTail = Promise.resolve();
+  async load() {
+    try {
+      const value = JSON.parse(await readFile2(this.filePath, "utf8"));
+      return normalizeState(value);
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT") return cloneState(EMPTY_STATE);
+      throw new Error(`cannot read connector state: ${error.message}`);
+    }
+  }
+  async save(state) {
+    const snapshot = normalizeState(cloneState(state));
+    const write = this.writeTail.catch(() => void 0).then(async () => {
+      await mkdir2(dirname3(this.filePath), { recursive: true });
+      const tempPath = `${this.filePath}.tmp-${process.pid}-${randomUUID3()}`;
+      try {
+        await writeFile(tempPath, `${JSON.stringify(snapshot, null, 2)}
+`, { mode: 384 });
+        await rename2(tempPath, this.filePath);
+      } finally {
+        await rm2(tempPath, { force: true });
+      }
+    });
+    this.writeTail = write;
+    await write;
+  }
+};
+function normalizeState(value) {
+  const ids = (input, limit = 5e3) => Array.isArray(input) ? [...new Set(input.filter((v) => typeof v === "string" && v.length > 0))].slice(-limit) : [];
+  const sessions = value?.sessionIds && typeof value.sessionIds === "object" ? Object.fromEntries(Object.entries(value.sessionIds).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string")) : {};
+  const agentSessions = value?.agentSessionIds && typeof value.agentSessionIds === "object" ? Object.fromEntries(Object.entries(value.agentSessionIds).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string")) : {};
+  const inflight = value?.inflight && typeof value.inflight === "object" ? Object.fromEntries(Object.entries(value.inflight).flatMap(([key, raw]) => {
+    if (!isRecord3(raw) || typeof raw.messageId !== "string" || typeof raw.serverSeq !== "number") return [];
+    return [[key, { messageId: raw.messageId, serverSeq: raw.serverSeq }]];
+  })) : {};
+  return { version: 1, processedMessageIds: ids(value?.processedMessageIds), processedEventIds: ids(value?.processedEventIds), sessionIds: sessions, agentSessionIds: agentSessions, inflight, updatedAt: typeof value?.updatedAt === "number" ? value.updatedAt : 0 };
+}
+function cloneState(state) {
+  return { ...state, processedMessageIds: [...state.processedMessageIds], processedEventIds: [...state.processedEventIds], sessionIds: { ...state.sessionIds }, agentSessionIds: { ...state.agentSessionIds }, inflight: { ...state.inflight } };
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/runtime-connector.ts
+import { createHash } from "crypto";
+import { mkdtemp, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+var MAX_ATTACHMENT_BYTES = 64 * 1024 * 1024;
+var RuntimeConnector = class {
+  constructor(options) {
+    this.options = options;
+    this.stateStore = options.stateStore ?? new MemoryStateStore();
+    options.channel.setFrameHandler((frame) => this.handleFrame(frame));
+    const workerWithCallback = this.options.worker;
+    workerWithCallback.setEventHandler?.((event) => void this.handleWorkerEvent(event));
+  }
+  options;
+  stateStore;
+  state = cloneState({ version: 1, processedMessageIds: [], processedEventIds: [], sessionIds: {}, agentSessionIds: {}, inflight: {}, updatedAt: 0 });
+  queues = /* @__PURE__ */ new Map();
+  contexts = /* @__PURE__ */ new Map();
+  activeMessages = /* @__PURE__ */ new Set();
+  activeEvents = /* @__PURE__ */ new Set();
+  started = false;
+  async start() {
+    if (this.started) return;
+    this.state = await this.stateStore.load();
+    try {
+      await this.options.worker.initialize(this.options.runtime, this.options.connectorVersion);
+      await this.options.channel.start();
+      const remaining = {};
+      for (const pending of Object.values(this.state.inflight)) {
+        try {
+          await this.options.channel.receipt({ messageId: pending.messageId, serverSeq: pending.serverSeq, status: "COMPLETED", outcome: "FAILED", errorCode: "CONNECTOR_RESTARTED", errorMessage: "connector restarted before delivery completed", retryable: true });
+        } catch {
+          remaining[pending.messageId] = pending;
+        }
+      }
+      this.state.inflight = remaining;
+      await this.persist();
+      this.started = true;
+    } catch (error) {
+      await this.options.channel.stop().catch(() => void 0);
+      await this.options.worker.shutdown().catch(() => void 0);
+      throw error;
+    }
+  }
+  async stop() {
+    await this.options.channel.stop();
+    await this.options.worker.shutdown();
+    this.started = false;
+  }
+  /** Attach the callback after constructing a ChannelClient without relying on a global runtime. */
+  async handleFrame(frame) {
+    if (frame.type === "RESUME_DONE" || frame.type === "RESUME_COMPLETE") {
+      this.options.onStateChange?.("resume_done");
+      return;
+    }
+    if (isInboundMessage(frame)) return this.handleMessage(frame);
+    if (isGameEvent(frame)) return this.handleGameEvent(frame);
+  }
+  async handleMessage(frame) {
+    const payload = frame.payload;
+    if (!payload || typeof payload.seq !== "number" || !payload.messageId || typeof payload.content !== "string") return;
+    const messageId = String(payload.messageId);
+    if (frame.type === "GROUP_MESSAGE" && payload.mentioned === false) {
+      await this.options.channel.ack(payload.seq, messageId);
+      this.remember(this.state.processedMessageIds, messageId);
+      await this.persist();
+      return;
+    }
+    if (this.state.processedMessageIds.includes(messageId)) {
+      await this.options.channel.ack(payload.seq, messageId);
+      const pending = this.state.inflight[messageId];
+      if (!pending) return;
+      if (!await this.sendReceipt({ messageId, serverSeq: payload.seq, status: "PROCESSING" })) return;
+      if (this.activeMessages.has(messageId)) return;
+      this.activeMessages.add(messageId);
+      const key2 = typeof payload.conversationId === "string" ? payload.conversationId : `group:${payload.groupId ?? "unknown"}`;
+      await this.enqueue(key2, () => this.dispatchMessage(frame));
+      return;
+    }
+    await this.options.channel.ack(payload.seq, messageId);
+    this.state.inflight[messageId] = { messageId, serverSeq: payload.seq };
+    this.remember(this.state.processedMessageIds, messageId);
+    await this.persist();
+    if (!await this.sendReceipt({ messageId, serverSeq: payload.seq, status: "PROCESSING" })) return;
+    const key = typeof payload.conversationId === "string" ? payload.conversationId : `group:${payload.groupId ?? "unknown"}`;
+    this.activeMessages.add(messageId);
+    await this.enqueue(key, () => this.dispatchMessage(frame));
+  }
+  async handleGameEvent(frame) {
+    const payload = frame.payload;
+    if (!payload?.agentTask?.requiresReply) {
+      if (typeof payload?.seq === "number") await this.options.channel.ack(payload.seq);
+      return;
+    }
+    if (this.state.processedEventIds.includes(payload.eventId)) {
+      await this.options.channel.ack(payload.seq);
+      return;
+    }
+    if (this.activeEvents.has(payload.eventId)) return;
+    this.activeEvents.add(payload.eventId);
+    const key = payload.agentTask.conversationKey ?? `game:${payload.gameId}:${payload.roomId}`;
+    try {
+      const handled = await this.enqueue(key, () => this.dispatchGameEvent(frame));
+      if (handled) {
+        await this.options.channel.ack(payload.seq);
+        this.remember(this.state.processedEventIds, payload.eventId);
+        await this.persist();
+      }
+    } finally {
+      this.activeEvents.delete(payload.eventId);
+    }
+  }
+  enqueue(key, task) {
+    const previous = this.queues.get(key) ?? Promise.resolve();
+    const run = previous.catch(() => void 0).then(task);
+    const tail = run.finally(() => {
+      if (this.queues.get(key) === tail) this.queues.delete(key);
+    });
+    this.queues.set(key, tail);
+    return run;
+  }
+  async dispatchMessage(frame) {
+    const p = frame.payload;
+    let session;
+    let temporaryDir;
+    let phase = "session";
+    const diagnostic = { messageId: String(p.messageId), serverSeq: p.seq };
+    this.diagnose({ event: "message.start", ...diagnostic });
+    try {
+      session = await this.getOrCreateSession(typeof p.conversationId === "string" ? p.conversationId : `group:${p.groupId ?? "unknown"}`);
+      phase = "attachments";
+      const prepared = await this.prepareMessageInput(p);
+      temporaryDir = prepared.temporaryDir;
+      phase = "worker";
+      this.diagnose({ event: "worker.send", ...diagnostic, sessionId: session.sessionId });
+      const output = await this.runTask(session, frame, prepared.input);
+      phase = "reply";
+      if (output.trim()) {
+        await this.sendReply(frame, output);
+        const receiptSent = await this.sendReceipt({ messageId: String(p.messageId), serverSeq: p.seq, status: "COMPLETED", outcome: "REPLIED" });
+        if (!receiptSent) return;
+      } else {
+        const receiptSent = await this.sendReceipt({ messageId: String(p.messageId), serverSeq: p.seq, status: "COMPLETED", outcome: "NO_REPLY" });
+        if (!receiptSent) return;
+      }
+      delete this.state.inflight[String(p.messageId)];
+      await this.persist();
+      this.diagnose({ event: "message.completed", ...diagnostic });
+    } catch (error) {
+      this.diagnose({ event: "message.failed", ...diagnostic, phase, error: error instanceof Error ? error.message : String(error) });
+      const receiptSent = await this.sendReceipt({ messageId: String(p.messageId), serverSeq: p.seq, status: "COMPLETED", outcome: "FAILED", errorCode: "WORKER_ERROR", errorMessage: error.message.slice(0, 500), retryable: true });
+      if (receiptSent) delete this.state.inflight[String(p.messageId)];
+      await this.persist();
+    } finally {
+      this.activeMessages.delete(String(p.messageId));
+      if (temporaryDir) await rm3(temporaryDir, { recursive: true, force: true });
+    }
+  }
+  async sendReceipt(payload) {
+    try {
+      await this.options.channel.receipt(payload);
+      return true;
+    } catch (error) {
+      this.diagnose({ event: "receipt.failed", messageId: payload.messageId, serverSeq: payload.serverSeq, phase: payload.status, error: error instanceof Error ? error.message : String(error) });
+      this.options.onStateChange?.("receipt_pending");
+      return false;
+    }
+  }
+  async dispatchGameEvent(frame) {
+    const p = frame.payload;
+    const session = await this.getOrCreateSession(p.agentTask.conversationKey ?? `game:${p.gameId}:${p.roomId}`);
+    let output = "";
+    let parsed = null;
+    let validated = null;
+    let retryCount = 0;
+    let validationReason = "";
+    let firstRawResponseHash;
+    let retryRawResponseHash;
+    const configuredRetries = p.agentTask.retryPolicy?.maxRetries;
+    const maxRetries = Number.isFinite(configuredRetries) ? Math.min(10, Math.max(0, Math.floor(configuredRetries))) : 0;
+    while (true) {
+      const remainingMs = typeof p.deadlineEpochMs === "number" ? p.deadlineEpochMs - Date.now() : void 0;
+      try {
+        if (remainingMs !== void 0 && remainingMs <= 0) throw new Error("game task deadline expired");
+        const prompt = retryCount === 0 ? p.agentTask.renderedPrompt : buildRetryPrompt(p.agentTask.renderedPrompt, validationReason || "invalid_output");
+        output = await this.runTask(session, frame, { text: prompt }, remainingMs);
+      } catch (error) {
+        output = "";
+      }
+      if (output.trim()) {
+        const hash = sha256(output);
+        if (retryCount === 0) firstRawResponseHash = hash;
+        else retryRawResponseHash = hash;
+      }
+      parsed = parseAction(output);
+      validated = validateAction(parsed, p.agentTask.actionContract, p.agentTask.outputSchema);
+      if (validated) break;
+      validationReason = parsed ? "invalid_action_shape" : output.trim() ? "invalid_json" : "no_model_output";
+      const deadlineAllowsRetry = typeof p.deadlineEpochMs !== "number" || Date.now() < p.deadlineEpochMs - 1e3;
+      if (retryCount >= maxRetries || !deadlineAllowsRetry) break;
+      retryCount += 1;
+    }
+    const fallback = normalizeGameAction(p.agentTask.fallbackAction);
+    const action = validated ?? validateAction(fallback, p.agentTask.actionContract, p.agentTask.outputSchema);
+    if (!action) return false;
+    try {
+      const response = await this.options.channel.request(createFrame("GAME_ACTION", {
+        gameId: p.gameId,
+        roomId: p.roomId,
+        eventType: p.eventType,
+        actionType: action.actionType,
+        actionData: action.actionData ?? {},
+        timestamp: String(Date.now()),
+        turnSeq: p.turnSeq,
+        eventId: p.eventId,
+        traceId: p.traceId,
+        promptPolicyVersion: p.agentTask.promptPolicyVersion,
+        renderedPromptHash: p.agentTask.renderedPromptHash,
+        rawResponseHash: output ? sha256(output) : void 0,
+        rawResponsePreview: output.slice(0, 500),
+        parseSource: validated ? "llm" : "backend_fallback",
+        submissionStatus: validated ? "VALID" : "REJECTED_OUTPUT",
+        structuredProtocolVersion: p.agentTask.actionProtocolVersion,
+        retryCount,
+        validationReason: validated ? void 0 : validationReason,
+        modelActionRejected: validated ? false : true,
+        modelActionType: parsed?.actionType,
+        firstRawResponseHash,
+        retryRawResponseHash
+      }));
+      if (response?.ok === false) return false;
+      return true;
+    } catch {
+      this.options.onStateChange?.("game_action_submit_pending");
+      return false;
+    }
+  }
+  async getOrCreateSession(sessionKey) {
+    const existing = this.state.sessionIds[sessionKey];
+    const agentSessionId = this.state.agentSessionIds[sessionKey];
+    const workDir = this.options.workDir ? join3(this.options.workDir, `session-${sha256(sessionKey).slice(0, 24)}`) : void 0;
+    if (existing) {
+      try {
+        const resumed = await this.options.worker.resumeSession({ sessionId: existing, agentSessionId, runtime: this.options.runtime, runtimePath: this.options.runtimePath, backend: this.options.backend, appServerUrl: this.options.appServerUrl, workDir });
+        if (resumed.agentSessionId) {
+          this.state.agentSessionIds[sessionKey] = resumed.agentSessionId;
+          await this.persist();
+        }
+        return resumed;
+      } catch (error) {
+        this.diagnose({ event: "session.resume_failed", sessionId: existing, error: error instanceof Error ? error.message : String(error) });
+      }
+    }
+    const session = await this.options.worker.startSession({ runtime: this.options.runtime, runtimePath: this.options.runtimePath, backend: this.options.backend, appServerUrl: this.options.appServerUrl, workDir });
+    this.state.sessionIds[sessionKey] = session.sessionId;
+    if (session.agentSessionId) this.state.agentSessionIds[sessionKey] = session.agentSessionId;
+    await this.persist();
+    return session;
+  }
+  async runTask(session, frame, input, timeoutMs = this.options.taskTimeoutMs ?? 5 * 6e4) {
+    const messageId = readMessageId(frame) ?? (isGameEvent(frame) ? frame.payload.eventId : frame.id);
+    return new Promise(async (resolve3, reject) => {
+      const context = { frame, sessionId: session.sessionId, output: "", hasText: false, done: resolve3, fail: reject, settled: false };
+      this.contexts.set(session.sessionId, context);
+      context.timer = setTimeout(() => {
+        if (!context.settled) {
+          context.settled = true;
+          this.contexts.delete(session.sessionId);
+          reject(new Error("worker task timed out"));
+          void this.options.worker.cancel(session.sessionId, "task timeout");
+        }
+      }, Math.max(1, timeoutMs));
+      context.timer.unref?.();
+      try {
+        await this.options.worker.send({ sessionId: session.sessionId, messageId, prompt: input.text, images: input.images, files: input.files, timeoutMs });
+      } catch (error) {
+        if (context.timer) clearTimeout(context.timer);
+        this.contexts.delete(session.sessionId);
+        reject(error);
+      }
+    });
+  }
+  async prepareMessageInput(payload) {
+    if (!payload) throw new Error("message payload is missing");
+    if (payload.messageType !== "IMAGE" && payload.messageType !== "FILE") return { input: { text: payload.content } };
+    let artifact;
+    try {
+      artifact = JSON.parse(payload.content);
+    } catch {
+      throw new Error("media message content is not valid JSON");
+    }
+    if (!isRecord(artifact) || typeof artifact.url !== "string" || !artifact.url) throw new Error("media message is missing url");
+    const mediaUrl = new URL(artifact.url, this.options.channel.getGatewayUrl());
+    if (mediaUrl.protocol !== "http:" && mediaUrl.protocol !== "https:") throw new Error("media URL must use http or https");
+    const response = await fetch(mediaUrl);
+    if (!response.ok) throw new Error(`media download failed: HTTP ${response.status}`);
+    const declaredLength = response.headers.get("content-length");
+    if (declaredLength && Number(declaredLength) > MAX_ATTACHMENT_BYTES) throw new Error("media attachment exceeds size limit");
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.byteLength > MAX_ATTACHMENT_BYTES) throw new Error("media attachment exceeds size limit");
+    if (typeof artifact.fileSize === "number" && Number.isSafeInteger(artifact.fileSize) && artifact.fileSize > 0 && artifact.fileSize !== bytes.byteLength) {
+      throw new Error("media attachment size does not match metadata");
+    }
+    const directory = await mkdtemp(join3(this.options.attachmentDir ?? tmpdir(), "clawtopia-agent-"));
+    const rawFileName = typeof artifact.fileName === "string" && artifact.fileName ? artifact.fileName : "attachment";
+    const fileName = rawFileName.replace(/[\\/\x00-\x1F\x7F]/gu, "_").slice(0, 255) || "attachment";
+    const path = join3(directory, fileName);
+    await writeFile2(path, bytes, { mode: 384 });
+    const attachment = { path, mimeType: typeof artifact.mimeType === "string" ? artifact.mimeType : void 0, fileName, size: bytes.byteLength };
+    return payload.messageType === "IMAGE" ? { input: { text: `\u8BF7\u5904\u7406\u9644\u4EF6 ${fileName}`, images: [attachment] }, temporaryDir: directory } : { input: { text: `\u8BF7\u5904\u7406\u9644\u4EF6 ${fileName}`, files: [attachment] }, temporaryDir: directory };
+  }
+  async sendReply(frame, text) {
+    const p = frame.payload;
+    const target = frame.type === "PRIVATE_MESSAGE" ? { userId: String(p.sender?.userId ?? ""), userType: String(p.sender?.userType ?? "HUMAN") } : void 0;
+    const type = frame.type === "PRIVATE_MESSAGE" ? "SEND_PRIVATE" : "SEND_GROUP";
+    const deliveryId = `${String(p.messageId)}:0`;
+    const payload = frame.type === "PRIVATE_MESSAGE" ? { target, messageType: "TEXT", content: text, replyToMessageId: String(p.messageId), sourceServerSeq: p.seq, deliveryId, deliveryIndex: 0 } : { groupId: String(p.groupId), messageType: "TEXT", content: text, sourceServerSeq: p.seq, deliveryId, deliveryIndex: 0 };
+    const result = await this.options.channel.request(createFrame(type, payload));
+    if (result?.ok === false || !result?.messageId) throw new Error(result?.error?.message ?? "reply was rejected");
+  }
+  async handleWorkerEvent(event) {
+    if (!event.sessionId) return;
+    if (event.agentSessionId) {
+      const key = Object.entries(this.state.sessionIds).find(([, id]) => id === event.sessionId)?.[0];
+      if (key && this.state.agentSessionIds[key] !== event.agentSessionId) {
+        this.state.agentSessionIds[key] = event.agentSessionId;
+        await this.persist();
+      }
+    }
+    const context = this.contexts.get(event.sessionId);
+    if (!context || context.settled) return;
+    const data = isRecord(event.data) ? event.data : {};
+    if (event.event === "text") {
+      const text = event.content ?? (typeof data.text === "string" ? data.text : typeof event.data === "string" ? event.data : "");
+      context.output += text;
+      context.hasText = context.hasText || Boolean(text);
+    } else if (event.event === "result") {
+      context.settled = true;
+      if (context.timer) clearTimeout(context.timer);
+      this.contexts.delete(event.sessionId);
+      const finalText = context.hasText ? context.output : event.content ?? (typeof data.text === "string" ? data.text : "");
+      context.done(finalText);
+    } else if (event.event === "error") {
+      context.settled = true;
+      if (context.timer) clearTimeout(context.timer);
+      this.contexts.delete(event.sessionId);
+      context.fail(new Error(event.error ?? (typeof data.message === "string" ? data.message : "worker runtime error")));
+    } else if (event.event === "permission" && this.options.onPermission && event.requestId) {
+      const decision = await this.options.onPermission({ sessionId: event.sessionId, requestId: event.requestId, data });
+      await this.options.worker.respondPermission({ sessionId: event.sessionId, requestId: event.requestId, behavior: decision });
+    }
+  }
+  remember(list, value) {
+    if (!list.includes(value)) list.push(value);
+    if (list.length > 5e3) list.splice(0, list.length - 5e3);
+  }
+  diagnose(entry) {
+    try {
+      this.options.onDiagnostic?.(entry);
+    } catch {
+    }
+  }
+  async persist() {
+    this.state.updatedAt = Date.now();
+    await this.stateStore.save(this.state);
+  }
+};
+function buildRetryPrompt(prompt, reason) {
+  return `${prompt}
+
+\u4E0A\u4E00\u8F6E\u8F93\u51FA\u672A\u901A\u8FC7\u7ED3\u6784\u5316\u52A8\u4F5C\u6821\u9A8C\uFF08${reason}\uFF09\u3002\u8BF7\u91CD\u65B0\u8F93\u51FA\u4E00\u4E2A\u5B8C\u6574 JSON \u5BF9\u8C61\uFF0C\u53EA\u4FEE\u6B63\u683C\u5F0F\u548C\u5B57\u6BB5\uFF0C\u4E0D\u8981\u89E3\u91CA\u3002`;
+}
+function normalizeGameAction(value) {
+  if (!isRecord(value) || typeof value.actionType !== "string" || !isRecord(value.actionData)) return null;
+  return { actionType: value.actionType, actionData: value.actionData, ...typeof value.speech === "string" ? { speech: value.speech } : {}, ...typeof value.voteReason === "string" ? { voteReason: value.voteReason } : {} };
+}
+function parseAction(output) {
+  const start = output.indexOf("{");
+  const end = output.lastIndexOf("}");
+  if (start < 0 || end <= start) return null;
+  try {
+    const value = JSON.parse(output.slice(start, end + 1));
+    return normalizeGameAction(isRecord(value) ? value : null);
+  } catch {
+    return null;
+  }
+}
+function validateAction(action, contract, rootSchema) {
+  if (!action) return null;
+  const options = Array.isArray(contract?.options) ? contract.options : [];
+  const option = options.find((candidate) => isRecord(candidate) && candidate.actionType === action.actionType);
+  if (!option) return null;
+  const schema = isRecord(option) && isRecord(option.actionDataSchema) ? option.actionDataSchema : void 0;
+  if (schema && !matchesSchema(action.actionData, schema)) return null;
+  const root = { actionType: action.actionType, actionData: action.actionData, ...action.speech ? { speech: action.speech } : {}, ...action.voteReason ? { voteReason: action.voteReason } : {} };
+  if (rootSchema && !matchesSchema(root, rootSchema)) return null;
+  return action;
+}
+function matchesSchema(value, schema) {
+  if (Array.isArray(schema.oneOf)) return schema.oneOf.some((variant) => isRecord(variant) && matchesSchema(value, variant));
+  if (Array.isArray(schema.enum) && !schema.enum.some((item) => Object.is(item, value))) return false;
+  const types = Array.isArray(schema.type) ? schema.type : typeof schema.type === "string" ? [schema.type] : [];
+  return types.length === 0 || types.some((type) => matchesSchemaType(value, type, schema));
+}
+function matchesSchemaType(value, type, schema) {
+  if (type === "object") {
+    if (!isRecord(value)) return false;
+    const properties = isRecord(schema.properties) ? schema.properties : {};
+    const required = Array.isArray(schema.required) ? schema.required.filter((field) => typeof field === "string") : [];
+    if (required.some((field) => !Object.hasOwn(value, field) || !isRecord(properties[field]) || !matchesSchema(value[field], properties[field]))) return false;
+    if (schema.additionalProperties === false && Object.keys(value).some((field) => !Object.hasOwn(properties, field))) return false;
+    return Object.entries(value).every(([field, fieldValue]) => !Object.hasOwn(properties, field) || !isRecord(properties[field]) || matchesSchema(fieldValue, properties[field]));
+  }
+  if (type === "array") {
+    if (!Array.isArray(value)) return false;
+    if (typeof schema.minItems === "number" && value.length < schema.minItems) return false;
+    if (typeof schema.maxItems === "number" && value.length > schema.maxItems) return false;
+    return !isRecord(schema.items) || value.every((item) => matchesSchema(item, schema.items));
+  }
+  if (type === "string") return typeof value === "string" && (typeof schema.maxLength !== "number" || value.length <= schema.maxLength) && (typeof schema.minLength !== "number" || value.length >= schema.minLength);
+  if (type === "integer") return typeof value === "number" && Number.isInteger(value) && withinNumberBounds(value, schema);
+  if (type === "number") return typeof value === "number" && Number.isFinite(value) && withinNumberBounds(value, schema);
+  if (type === "boolean") return typeof value === "boolean";
+  if (type === "null") return value === null;
+  return true;
+}
+function withinNumberBounds(value, schema) {
+  return (typeof schema.minimum !== "number" || value >= schema.minimum) && (typeof schema.maximum !== "number" || value <= schema.maximum) && (typeof schema.exclusiveMinimum !== "number" || value > schema.exclusiveMinimum) && (typeof schema.exclusiveMaximum !== "number" || value < schema.exclusiveMaximum);
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+// src/worker-client.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+import { randomUUID as randomUUID4 } from "crypto";
+var WorkerClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  transport;
+  pending = /* @__PURE__ */ new Map();
+  started = false;
+  closed = false;
+  eventHandler;
+  setEventHandler(handler) {
+    this.eventHandler = handler;
+  }
+  async start() {
+    if (this.started) return;
+    if (this.closed) throw new Error("worker client is closed");
+    const transport = this.options.transportFactory?.(this.options) ?? spawnTransport(this.options);
+    this.transport = transport;
+    transport.onLine((line) => this.handleLine(line));
+    transport.onExit?.((error) => {
+      if (this.transport !== transport) return;
+      this.started = false;
+      this.transport = void 0;
+      this.rejectAll(error);
+    });
+    this.started = true;
+  }
+  async initialize(runtime, connectorVersion) {
+    await this.start();
+    return this.request("initialize", { runtime, connectorVersion, protocolVersion: 1 });
+  }
+  startSession(input) {
+    return this.request("start_session", input);
+  }
+  resumeSession(input) {
+    return this.request("resume_session", input);
+  }
+  send(input) {
+    return this.request("send", input);
+  }
+  respondPermission(input) {
+    return this.request("respond_permission", input);
+  }
+  cancel(sessionId, reason) {
+    return this.request("cancel", { sessionId, reason });
+  }
+  closeSession(sessionId) {
+    return this.request("close", { sessionId });
+  }
+  health() {
+    return this.request("health", {});
+  }
+  async shutdown() {
+    this.closed = true;
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("worker client stopped"));
+    }
+    this.pending.clear();
+    await this.transport?.close();
+    this.transport = void 0;
+  }
+  async request(method, params) {
+    await this.start();
+    const id = `rpc_${randomUUID4()}`;
+    const timeout = setTimeout(() => {
+      const pending = this.pending.get(id);
+      if (!pending) return;
+      this.pending.delete(id);
+      pending.reject(new Error(`worker request timed out: ${method}`));
+    }, this.options.requestTimeoutMs ?? 6e4);
+    return new Promise((resolve3, reject) => {
+      this.pending.set(id, { resolve: (value) => resolve3(value), reject, timer: timeout });
+      try {
+        this.transport.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
+`);
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pending.delete(id);
+        reject(asError2(error));
+      }
+    });
+  }
+  handleLine(line) {
+    if (!line.trim()) return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if ("id" in message && typeof message.id === "string") {
+      const pending = this.pending.get(message.id);
+      if (!pending) return;
+      clearTimeout(pending.timer);
+      this.pending.delete(message.id);
+      if ("error" in message && message.error) pending.reject(new Error(message.error.message ?? "worker RPC error"));
+      else pending.resolve(message.result);
+      return;
+    }
+    if ("method" in message && message.method === "event") {
+      const params = isRecord4(message.params) ? message.params : {};
+      if (typeof params.type !== "string") return;
+      const type = params.type.toUpperCase();
+      const event = type === "TEXT" ? "text" : type === "THINKING" ? "thinking" : type === "TOOL_USE" ? "tool_use" : type === "TOOL_RESULT" ? "tool_result" : type === "PERMISSION_REQUEST" || type === "PERMISSION" ? "permission" : type === "RESULT" ? "result" : type === "ERROR" ? "error" : void 0;
+      if (!event) return;
+      const normalized = { event, sessionId: typeof params.sessionId === "string" ? params.sessionId : void 0, agentSessionId: typeof params.agentSessionId === "string" ? params.agentSessionId : void 0, content: typeof params.content === "string" ? params.content : void 0, done: params.done === true, error: typeof params.error === "string" ? params.error : void 0, requestId: typeof params.requestId === "string" ? params.requestId : void 0, data: params };
+      void this.eventHandler?.(normalized);
+      void this.options.onEvent?.(normalized);
+    }
+  }
+  rejectAll(error) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+};
+function spawnTransport(options) {
+  const child = spawn(options.executable, options.args ?? [], { cwd: options.cwd, env: { ...process.env, ...options.env }, stdio: ["pipe", "pipe", "pipe"] });
+  const readline = createInterface({ input: child.stdout });
+  readline.on("line", () => void 0);
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    const line = chunk.trim();
+    if (line) options.onStderr?.(redactStderr(line));
+  });
+  const listeners = /* @__PURE__ */ new Set();
+  const exitListeners = /* @__PURE__ */ new Set();
+  readline.removeAllListeners("line");
+  readline.on("line", (line) => {
+    for (const listener of listeners) listener(line);
+  });
+  child.once("error", (error) => {
+    for (const listener of exitListeners) listener(error);
+  });
+  child.once("exit", (code, signal) => {
+    if (code !== 0 || signal) {
+      const detail = signal ? `signal ${signal}` : `exit code ${code}`;
+      for (const listener of exitListeners) listener(new Error(`worker process exited with ${detail}`));
+    }
+  });
+  return {
+    write: (line) => {
+      if (!child.stdin.writable) throw new Error("worker stdin is closed");
+      child.stdin.write(line);
+    },
+    onLine: (listener) => {
+      listeners.add(listener);
+    },
+    onExit: (listener) => {
+      exitListeners.add(listener);
+    },
+    close: () => closeChild(child, readline)
+  };
+}
+async function closeChild(child, readline) {
+  readline.close();
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  child.kill("SIGTERM");
+  await new Promise((resolve3) => {
+    const timer = setTimeout(() => {
+      if (child.exitCode === null) child.kill("SIGKILL");
+      resolve3();
+    }, 2e3);
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolve3();
+    });
+  });
+}
+function redactStderr(line) {
+  return line.replace(/(Bearer\s+|token[=:]\s*)[^\s,]+/giu, "$1[REDACTED]");
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
+function asError2(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+export {
+  PROTOCOL_VERSION,
+  EXACT_ACK_CAPABILITY,
+  RECEIPT_CAPABILITY,
+  MEDIA_INPUT_CAPABILITY,
+  GAME_CAPABILITY,
+  PROMPT_PASSTHROUGH_CAPABILITY,
+  DEFAULT_CAPABILITIES,
+  createFrame,
+  respondFrame,
+  encodeFrame,
+  FrameDecodeError,
+  decodeFrame,
+  isRecord,
+  isInboundMessage,
+  isGameEvent,
+  readSeq,
+  readMessageId,
+  ChannelClient,
+  activeFlavor,
+  assertEnvironmentMatches,
+  configRoot,
+  normalizeProfileId,
+  profileConfigPath,
+  defaultConfigPath,
+  bundledWorkerPath,
+  defaultConfig,
+  loadConfig,
+  saveConfig,
+  profileEnvironment,
+  MemoryStateStore,
+  JsonFileStateStore,
+  normalizeState,
+  cloneState,
+  RuntimeConnector,
+  WorkerClient
+};