@factory/droid-sdk 0.6.0 → 0.8.0

package/dist/node.js

@@ -0,0 +1,4731 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk4G2RKM2Hjs = require('./chunk-4G2RKM2H.js');
+
+// src/exec-core/client.ts
+var _events = require('events'); var _events2 = _interopRequireDefault(_events);
+var _uuid = require('uuid');
+var _zod = require('zod');
+
+// src/exec-core/constants.ts
+var DEFAULT_REQUEST_TIMEOUT2 = 3e4;
+var SESSION_INIT_TIMEOUT2 = 6e4;
+var COMPACTION_TIMEOUT2 = 24e4;
+var MCP_AUTH_TIMEOUT2 = 3e5;
+var WINDOWS_JOB_OBJECT_ERROR_MARKER = "AssignProcessToJobObject";
+var CLI_JSONRPC_CHILD_SPAWN_LATENCY_METRIC = "cli_jsonrpc_child_spawn_latency";
+var noopLogger = {
+  info() {
+  },
+  warn() {
+  },
+  exception() {
+  }
+};
+
+// src/exec-core/default-deps.ts
+function getRuntimeEnvironment() {
+  return _nullishCoalesce(_optionalChain([globalThis, 'access', _ => _.process, 'optionalAccess', _2 => _2.env]), () => ( {}));
+}
+var defaultExecCoreDeps = {
+  logger: {
+    info() {
+    },
+    warn() {
+    },
+    exception() {
+    }
+  },
+  metrics: {
+    addToCounter() {
+    },
+    recordDuration() {
+    }
+  },
+  tracing: {
+    getCurrentContext() {
+      return void 0;
+    },
+    injectContext() {
+    }
+  },
+  commandResolver: {
+    resolveDroidCommand(isDevelopment) {
+      return {
+        execPath: isDevelopment ? "droid-dev" : "droid",
+        prefixArgs: []
+      };
+    }
+  },
+  factoryPathResolver: {
+    getFactoryHome() {
+      const env = getRuntimeEnvironment();
+      return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(env.FACTORY_HOME_OVERRIDE, () => ( env.HOME)), () => ( env.USERPROFILE)), () => ( ""));
+    },
+    getFactoryDirName() {
+      return ".factory";
+    }
+  },
+  environmentResolver: {
+    resolveTransportLogEnvValue() {
+      return getRuntimeEnvironment().FACTORY_DROID_SDK_TRANSPORT_LOG;
+    },
+    sanitizeSpawnEnv(env) {
+      return env;
+    }
+  }
+};
+
+// src/exec-core/enums.ts
+var DroidClientEvent = /* @__PURE__ */ ((DroidClientEvent2) => {
+  DroidClientEvent2["SESSION_NOTIFICATION"] = "session_notification";
+  DroidClientEvent2["REQUEST_PERMISSION"] = "request_permission";
+  DroidClientEvent2["ASK_USER"] = "ask_user";
+  DroidClientEvent2["ERROR"] = "error";
+  return DroidClientEvent2;
+})(DroidClientEvent || {});
+var DroidProcessMode = /* @__PURE__ */ ((DroidProcessMode2) => {
+  DroidProcessMode2["Acp"] = "acp";
+  DroidProcessMode2["StreamJsonRpc"] = "stream-jsonrpc";
+  return DroidProcessMode2;
+})(DroidProcessMode || {});
+var TransportDirection = /* @__PURE__ */ ((TransportDirection2) => {
+  TransportDirection2["In"] = "in";
+  TransportDirection2["Out"] = "out";
+  TransportDirection2["OutFailed"] = "out_failed";
+  return TransportDirection2;
+})(TransportDirection || {});
+
+// ../droid-sdk-core/src/observability.ts
+function sanitizeAttributes(attributes) {
+  if (attributes === void 0) {
+    return void 0;
+  }
+  const sanitized = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      sanitized[key] = value;
+    }
+  }
+  return Object.keys(sanitized).length > 0 ? sanitized : void 0;
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    const code = "code" in error && typeof error.code === "string" ? error.code : void 0;
+    return {
+      name: error.name || void 0,
+      message: error.message,
+      ...code !== void 0 && { code }
+    };
+  }
+  return { message: String(error) };
+}
+function handleSinkFailure(error, options) {
+  try {
+    _optionalChain([options, 'optionalAccess', _3 => _3.onError, 'optionalCall', _4 => _4(error)]);
+  } catch (e2) {
+  }
+}
+function emitDroidLog(observability, event, options) {
+  const sink = _optionalChain([observability, 'optionalAccess', _5 => _5.logger]);
+  if (!sink) {
+    return false;
+  }
+  try {
+    sink.log({
+      level: event.level,
+      name: event.name,
+      message: event.message,
+      attributes: sanitizeAttributes(event.attributes),
+      ...event.error !== void 0 && {
+        error: serializeError(event.error)
+      }
+    });
+    return true;
+  } catch (error) {
+    handleSinkFailure(error, options);
+    return false;
+  }
+}
+function recordDroidMetric(observability, event, options) {
+  const sink = _optionalChain([observability, 'optionalAccess', _6 => _6.metrics]);
+  if (!sink) {
+    return false;
+  }
+  try {
+    sink.record({
+      name: event.name,
+      kind: event.kind,
+      value: event.value,
+      unit: event.unit,
+      attributes: sanitizeAttributes(event.attributes)
+    });
+    return true;
+  } catch (error) {
+    handleSinkFailure(error, options);
+    return false;
+  }
+}
+function injectDroidTraceContext(observability, carrier, options) {
+  const sink = _optionalChain([observability, 'optionalAccess', _7 => _7.tracing]);
+  if (!sink) {
+    return false;
+  }
+  try {
+    sink.inject(carrier);
+    return true;
+  } catch (error) {
+    handleSinkFailure(error, options);
+    return false;
+  }
+}
+
+// src/exec-core/deps.ts
+function logWarn(logger, message, metadata) {
+  logger.warn(message, metadata);
+}
+
+// src/exec-core/observability-adapter.ts
+function createSinkFailureOptions(fallback) {
+  return {
+    onError(sinkError) {
+      logWarn(fallback, "[droid-sdk observability] customer sink threw", {
+        cause: sinkError
+      });
+    }
+  };
+}
+var CONTENT_BEARING_KEYS = ["output", "preview", "stderrTail"];
+function redactContentForCustomerSink(metadata) {
+  if (metadata === void 0) {
+    return void 0;
+  }
+  let redacted;
+  for (const key of CONTENT_BEARING_KEYS) {
+    if (!(key in metadata)) {
+      continue;
+    }
+    redacted ??= { ...metadata };
+    const value = redacted[key];
+    delete redacted[key];
+    if (typeof value === "string") {
+      redacted[`${key}ByteLength`] = new TextEncoder().encode(value).byteLength;
+    }
+  }
+  return _nullishCoalesce(redacted, () => ( metadata));
+}
+function createLogger(observability, fallback) {
+  const sink = _optionalChain([observability, 'optionalAccess', _8 => _8.logger]);
+  if (!sink) {
+    return fallback;
+  }
+  const sinkObservability = { logger: sink };
+  const sinkFailureOptions = createSinkFailureOptions(fallback);
+  return {
+    info(message, metadata) {
+      emitDroidLog(
+        sinkObservability,
+        {
+          level: "info",
+          name: "droid.sdk.info",
+          message,
+          attributes: redactContentForCustomerSink(metadata)
+        },
+        sinkFailureOptions
+      );
+    },
+    warn(message, metadata) {
+      emitDroidLog(
+        sinkObservability,
+        {
+          level: "warn",
+          name: "droid.sdk.warn",
+          message,
+          attributes: redactContentForCustomerSink(metadata)
+        },
+        sinkFailureOptions
+      );
+    },
+    exception(error, message, metadata) {
+      emitDroidLog(
+        sinkObservability,
+        {
+          level: "error",
+          name: "droid.sdk.error",
+          message,
+          attributes: redactContentForCustomerSink(metadata),
+          error
+        },
+        sinkFailureOptions
+      );
+    }
+  };
+}
+function createMetrics(observability, fallback, failureLogger) {
+  const sink = _optionalChain([observability, 'optionalAccess', _9 => _9.metrics]);
+  if (!sink) {
+    return fallback;
+  }
+  const sinkObservability = { metrics: sink };
+  const sinkFailureOptions = createSinkFailureOptions(failureLogger);
+  return {
+    addToCounter(metric, value, tags) {
+      recordDroidMetric(
+        sinkObservability,
+        {
+          name: metric,
+          kind: "counter",
+          value,
+          unit: "1",
+          attributes: tags
+        },
+        sinkFailureOptions
+      );
+    },
+    recordDuration(metric, valueMs, tags) {
+      recordDroidMetric(
+        sinkObservability,
+        {
+          name: metric,
+          kind: "histogram",
+          value: valueMs,
+          unit: "ms",
+          attributes: tags
+        },
+        sinkFailureOptions
+      );
+    }
+  };
+}
+function createTracing(observability, fallback, failureLogger) {
+  const sink = _optionalChain([observability, 'optionalAccess', _10 => _10.tracing]);
+  if (!sink) {
+    return fallback;
+  }
+  const sinkObservability = { tracing: sink };
+  const sinkFailureOptions = createSinkFailureOptions(failureLogger);
+  return {
+    getCurrentContext() {
+      return {};
+    },
+    injectContext(meta) {
+      const carrier = {};
+      if (!injectDroidTraceContext(sinkObservability, carrier, sinkFailureOptions)) {
+        return;
+      }
+      if (carrier.traceparent !== void 0) {
+        meta.traceparent = carrier.traceparent;
+      }
+      if (carrier.tracestate !== void 0) {
+        meta.tracestate = carrier.tracestate;
+      }
+    }
+  };
+}
+function resolveExecCoreDeps(observability, fallback = defaultExecCoreDeps) {
+  return {
+    logger: createLogger(observability, fallback.logger),
+    metrics: createMetrics(observability, fallback.metrics, fallback.logger),
+    tracing: createTracing(observability, fallback.tracing, fallback.logger),
+    commandResolver: fallback.commandResolver,
+    factoryPathResolver: fallback.factoryPathResolver,
+    environmentResolver: fallback.environmentResolver
+  };
+}
+
+// src/exec-core/client.ts
+function getResponseId(response) {
+  const parsed = _chunk4G2RKM2Hjs.JsonRpcBaseResponseSchema.safeParse(response);
+  return parsed.success ? parsed.data.id : void 0;
+}
+var JsonRpcEnvelopePeekSchema = _chunk4G2RKM2Hjs.JsonRpcEnvelopeSchema.partial().extend({
+  type: _zod.z.nativeEnum(_chunk4G2RKM2Hjs.JsonRpcMessageType).optional(),
+  method: _zod.z.string().optional(),
+  id: _zod.z.string().nullable().optional()
+}).passthrough();
+function inspectJsonRpcEnvelope2(message) {
+  const result = JsonRpcEnvelopePeekSchema.safeParse(message);
+  if (!result.success) {
+    return { protocolVersionMismatch: null };
+  }
+  const envelope = result.data;
+  return {
+    protocolVersionMismatch: envelope.factoryProtocolVersion !== void 0 && envelope.factoryProtocolVersion !== _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION ? {
+      localFactoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      peerFactoryProtocolVersion: envelope.factoryProtocolVersion,
+      messageType: envelope.type,
+      method: envelope.method,
+      requestId: envelope.id
+    } : null
+  };
+}
+var DroidClient = (_class = class _DroidClient extends _events2.default {
+  
+  
+  
+  __init() {this.pendingRequests = /* @__PURE__ */ new Map()}
+  __init2() {this.permissionHandlers = /* @__PURE__ */ new Map()}
+  __init3() {this.askUserHandlers = /* @__PURE__ */ new Map()}
+  __init4() {this.pendingPermissionRequests = /* @__PURE__ */ new Map()}
+  __init5() {this.pendingAskUserRequests = /* @__PURE__ */ new Map()}
+  __init6() {this.currentSessionId = null}
+  
+  /**
+   * Sticky error from a transport failure. Once set, all subsequent
+   * `sendRequest()` calls throw this error immediately, preventing
+   * requests from hanging on a dead transport.
+   */
+  __init7() {this.transportError = null}
+  __init8() {this.completedTurnObserved = false}
+  
+  
+  
+  constructor(options, deps = defaultExecCoreDeps) {
+    super();_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);;
+    this.transport = options.transport;
+    const resolved = resolveExecCoreDeps(options.observability, deps);
+    this.logger = resolved.logger;
+    this.tracing = resolved.tracing;
+    this.requestTimeout = _nullishCoalesce(options.requestTimeout, () => ( DEFAULT_REQUEST_TIMEOUT2));
+    this.sessionInitTimeout = _nullishCoalesce(options.sessionInitTimeout, () => ( SESSION_INIT_TIMEOUT2));
+    this.onRequestSettled = options.onRequestSettled;
+    this.transport.onMessage((message) => {
+      void this.handleMessage(message).catch((error) => {
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.emit(
+          "session_notification" /* SESSION_NOTIFICATION */,
+          _DroidClient.createNotificationEvent(
+            _DroidClient.createErrorNotification(err)
+          )
+        );
+      });
+    });
+    this.transport.onError((error) => {
+      const err = error instanceof Error ? error : new Error(String(error));
+      const expectedCleanExit = err instanceof _chunk4G2RKM2Hjs.ProcessExitError && err.exitCode === 0 && this.completedTurnObserved;
+      if (expectedCleanExit) {
+        this.logger.info("[DroidClient] Process exited after completed turn", {
+          exitCode: err.exitCode
+        });
+      } else {
+        this.logger.exception(err, "Transport error");
+      }
+      this.transportError = err;
+      this.rejectAllPending(err);
+      if (this.listenerCount("error" /* ERROR */) > 0) {
+        this.emit("error" /* ERROR */, err);
+      }
+      this.emit(
+        "session_notification" /* SESSION_NOTIFICATION */,
+        _DroidClient.createNotificationEvent(
+          _DroidClient.createErrorNotification(err)
+        )
+      );
+    });
+  }
+  get sessionId() {
+    return this.currentSessionId;
+  }
+  get isConnected() {
+    return this.transport.isConnected;
+  }
+  requireMcpOAuthOptOutSupport() {
+    if (this.peerProtocolVersion === _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION) {
+      return;
+    }
+    throw new (0, _chunk4G2RKM2Hjs.ProtocolError)(
+      "MCP OAuth opt-out requires a confirmed matching Droid protocol version. The connected Droid reported an incompatible protocol version and cannot disable OAuth for MCP servers.",
+      {
+        value: {
+          localFactoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+          peerFactoryProtocolVersion: this.peerProtocolVersion
+        }
+      }
+    );
+  }
+  validateMcpServersProtocolSupport(mcpServers) {
+    if (_optionalChain([mcpServers, 'optionalAccess', _11 => _11.some, 'call', _12 => _12((server) => "oauth" in server && server.oauth === false)])) {
+      this.requireMcpOAuthOptOutSupport();
+    }
+  }
+  async initializeSession(params) {
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.initialize_session" /* INITIALIZE_SESSION */,
+      params
+    };
+    const rawResponse = await this.sendRequest(
+      request,
+      this.sessionInitTimeout
+    );
+    const response = _chunk4G2RKM2Hjs.InitializeSessionResponseSchema.parse(rawResponse);
+    this.peerProtocolVersion = response.factoryProtocolVersion;
+    if (response.error) {
+      throw new (0, _chunk4G2RKM2Hjs.ProtocolError)("Initialize session request failed", {
+        requestId: request.id,
+        code: response.error.code,
+        message: response.error.message,
+        data: response.error.data
+      });
+    }
+    this.validateMcpServersProtocolSupport(params.mcpServers);
+    const result = _chunk4G2RKM2Hjs.InitializeSessionResultSchema.parse(response.result);
+    this.currentSessionId = result.sessionId;
+    return response;
+  }
+  async loadSession(params) {
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.load_session" /* LOAD_SESSION */,
+      params
+    };
+    const rawResponse = await this.sendRequest(
+      request,
+      this.sessionInitTimeout
+    );
+    const response = _chunk4G2RKM2Hjs.LoadSessionResponseSchema.parse(rawResponse);
+    this.peerProtocolVersion = response.factoryProtocolVersion;
+    if (response.error) {
+      const isSessionNotFound = response.error.code === -32004 /* ENTITY_NOT_FOUND */;
+      if (isSessionNotFound) {
+        throw new (0, _chunk4G2RKM2Hjs.SessionNotFoundError)(params.sessionId, {
+          requestId: request.id,
+          code: response.error.code,
+          message: response.error.message,
+          data: response.error.data
+        });
+      }
+      throw new (0, _chunk4G2RKM2Hjs.ProtocolError)("Load session request failed", {
+        requestId: request.id,
+        code: response.error.code,
+        message: response.error.message,
+        data: response.error.data
+      });
+    }
+    this.validateMcpServersProtocolSupport(params.mcpServers);
+    this.currentSessionId = params.sessionId;
+    return response;
+  }
+  async addUserMessage(params, requestId) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    this.completedTurnObserved = false;
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _nullishCoalesce(requestId, () => ( _uuid.v4.call(void 0, ))),
+      method: "droid.add_user_message" /* ADD_USER_MESSAGE */,
+      params: {
+        ...params.messageId && { messageId: params.messageId },
+        text: params.text,
+        images: params.images,
+        imagePaths: params.imagePaths,
+        files: params.files,
+        outputFormat: params.outputFormat,
+        ...params.skipAgentLoop && { skipAgentLoop: params.skipAgentLoop },
+        queuePlacement: _nullishCoalesce(params.queuePlacement, () => ( "end_of_turn")) /* EndOfTurn */,
+        ...params.role && { role: params.role },
+        ...params.visibility && { visibility: params.visibility }
+      }
+    };
+    const rawResponse = await this.sendRequest(request);
+    const response = _chunk4G2RKM2Hjs.AddUserMessageResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new (0, _chunk4G2RKM2Hjs.ProtocolError)("Add user message request failed", {
+        requestId: request.id,
+        code: response.error.code,
+        message: response.error.message,
+        data: response.error.data
+      });
+    }
+    return response;
+  }
+  /**
+   * Persists user-only messages without starting an agent turn.
+   *
+   * Use for daemon-owned activity that belongs in session history but was not
+   * produced by the agent, such as commands run while a session starts.
+   */
+  async appendMessages(params, requestId) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _nullishCoalesce(requestId, () => ( _uuid.v4.call(void 0, ))),
+      method: "droid.append_messages" /* APPEND_MESSAGES */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request);
+    const response = _chunk4G2RKM2Hjs.AppendMessagesResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new (0, _chunk4G2RKM2Hjs.ProtocolError)("Append messages request failed", {
+        requestId: request.id,
+        code: response.error.code,
+        message: response.error.message,
+        data: response.error.data
+      });
+    }
+    return response;
+  }
+  async resolveQueuedUserMessage(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.resolve_queued_user_message" /* RESOLVE_QUEUED_USER_MESSAGE */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.ResolveQueuedUserMessageResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new (0, _chunk4G2RKM2Hjs.ProtocolError)("Resolve queued user message request failed", {
+        requestId: request.id,
+        code: response.error.code,
+        message: response.error.message,
+        data: response.error.data
+      });
+    }
+    return response;
+  }
+  async interruptSession(params = {}) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.interrupt_session" /* INTERRUPT_SESSION */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.InterruptSessionResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new (0, _chunk4G2RKM2Hjs.ProtocolError)("Interrupt session request failed", {
+        requestId: request.id,
+        code: response.error.code,
+        message: response.error.message,
+        data: response.error.data
+      });
+    }
+    return response;
+  }
+  async closeSession(params = {}) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.close_session" /* CLOSE_SESSION */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.CloseSessionResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new (0, _chunk4G2RKM2Hjs.ProtocolError)("Close session request failed", {
+        requestId: request.id,
+        code: response.error.code,
+        message: response.error.message,
+        data: response.error.data
+      });
+    }
+    return response;
+  }
+  async killWorkerSession(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.kill_worker_session" /* KILL_WORKER_SESSION */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.KillWorkerSessionResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new (0, _chunk4G2RKM2Hjs.ProtocolError)("Kill worker session request failed", {
+        requestId: request.id,
+        code: response.error.code,
+        message: response.error.message,
+        data: response.error.data
+      });
+    }
+    return response;
+  }
+  async updateSessionSettings(params, requestId) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _nullishCoalesce(requestId, () => ( _uuid.v4.call(void 0, ))),
+      method: "droid.update_session_settings" /* UPDATE_SESSION_SETTINGS */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const responseParsed = _chunk4G2RKM2Hjs.UpdateSessionSettingsResponseSchema.safeParse(rawResponse);
+    if (!responseParsed.success) {
+      throw new (0, _chunk4G2RKM2Hjs.ProtocolError)(
+        "Invalid update session settings response format",
+        {
+          requestId: request.id,
+          code: -32700 /* PARSE_ERROR */,
+          message: responseParsed.error.message,
+          data: rawResponse
+        }
+      );
+    }
+    const response = responseParsed.data;
+    if (response.error) {
+      throw new (0, _chunk4G2RKM2Hjs.ProtocolError)("Update session settings request failed", {
+        requestId: request.id,
+        code: response.error.code,
+        message: response.error.message,
+        data: response.error.data
+      });
+    }
+    return response;
+  }
+  async changeWorkingDirectory(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.change_working_directory" /* CHANGE_WORKING_DIRECTORY */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.ChangeWorkingDirectoryResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new (0, _chunk4G2RKM2Hjs.ProtocolError)("Change working directory request failed", {
+        requestId: request.id,
+        code: response.error.code,
+        message: response.error.message,
+        data: response.error.data
+      });
+    }
+    return response;
+  }
+  async toggleMcpServer(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.toggle_mcp_server" /* TOGGLE_MCP_SERVER */,
+      params: {
+        serverName: params.serverName,
+        enabled: params.enabled,
+        settingsLevel: params.settingsLevel
+      }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.ToggleMcpServerResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async authenticateMcpServer(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.authenticate_mcp_server" /* AUTHENTICATE_MCP_SERVER */,
+      params: {
+        serverName: params.serverName
+      }
+    };
+    const rawResponse = await this.sendRequest(request, MCP_AUTH_TIMEOUT2);
+    const response = _chunk4G2RKM2Hjs.AuthenticateMcpServerResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async cancelMcpAuth(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.cancel_mcp_auth" /* CANCEL_MCP_AUTH */,
+      params: {
+        serverName: params.serverName
+      }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.CancelMcpAuthResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async clearMcpAuth(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.clear_mcp_auth" /* CLEAR_MCP_AUTH */,
+      params: {
+        serverName: params.serverName
+      }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.ClearMcpAuthResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async addMcpServer(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    if (params.oauth === false) {
+      this.requireMcpOAuthOptOutSupport();
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.add_mcp_server" /* ADD_MCP_SERVER */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.AddMcpServerResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async removeMcpServer(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.remove_mcp_server" /* REMOVE_MCP_SERVER */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.RemoveMcpServerResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async listModels(params = {}) {
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.list_models" /* LIST_MODELS */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    return _chunk4G2RKM2Hjs.ListModelsResponseSchema.parse(rawResponse);
+  }
+  async listMcpRegistry() {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.list_mcp_registry" /* LIST_MCP_REGISTRY */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.ListMcpRegistryResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async listMcpTools() {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.list_mcp_tools" /* LIST_MCP_TOOLS */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.ListMcpToolsResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async listTools(params = {}) {
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.list_tools" /* LIST_TOOLS */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.ListToolsResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async listMcpServers() {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.list_mcp_servers" /* LIST_MCP_SERVERS */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.ListMcpServersResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async toggleMcpTool(serverName, toolName, enabled) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.toggle_mcp_tool" /* TOGGLE_MCP_TOOL */,
+      params: { serverName, toolName, enabled }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.ToggleMcpToolResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async submitMcpAuthCode(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.submit_mcp_auth_code" /* SUBMIT_MCP_AUTH_CODE */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.SubmitMcpAuthCodeResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async submitMcpAuthError(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.submit_mcp_auth_error" /* SUBMIT_MCP_AUTH_ERROR */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.SubmitMcpAuthErrorResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async listSkills() {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.list_skills" /* LIST_SKILLS */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.ListSkillsResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async setSkillDisabled(skillName, disabled, settingsLevel) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.set_skill_disabled" /* SET_SKILL_DISABLED */,
+      params: { skillName, disabled, settingsLevel }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    return _chunk4G2RKM2Hjs.SetSkillDisabledResponseSchema.parse(rawResponse);
+  }
+  async listCommands() {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.list_commands" /* LIST_COMMANDS */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.ListCommandsResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async getContextStats() {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.get_context_stats" /* GET_CONTEXT_STATS */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.GetContextStatsResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async getContextBreakdown() {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.get_context_breakdown" /* GET_CONTEXT_BREAKDOWN */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.GetContextBreakdownResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async submitBugReport(userComment, clientLogs, source) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.submit_bug_report" /* SUBMIT_BUG_REPORT */,
+      params: { userComment, clientLogs, source }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = _chunk4G2RKM2Hjs.SubmitBugReportResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async getRewindInfo(params, timeout = this.requestTimeout) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.get_rewind_info" /* GET_REWIND_INFO */,
+      params: {
+        sessionId: this.currentSessionId,
+        messageId: params.messageId
+      }
+    };
+    const rawResponse = await this.sendRequest(request, timeout);
+    return _chunk4G2RKM2Hjs.GetRewindInfoResponseSchema.parse(rawResponse);
+  }
+  async executeRewind(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.execute_rewind" /* EXECUTE_REWIND */,
+      params: {
+        sessionId: this.currentSessionId,
+        messageId: params.messageId,
+        filesToRestore: params.filesToRestore,
+        filesToDelete: params.filesToDelete,
+        forkTitle: params.forkTitle
+      }
+    };
+    const rawResponse = await this.sendRequest(
+      request,
+      this.requestTimeout * 2
+    );
+    return _chunk4G2RKM2Hjs.ExecuteRewindResponseSchema.parse(rawResponse);
+  }
+  async compactSession(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.compact_session" /* COMPACT_SESSION */,
+      params: {
+        customInstructions: params.customInstructions
+      }
+    };
+    const rawResponse = await this.sendRequest(request, COMPACTION_TIMEOUT2);
+    return _chunk4G2RKM2Hjs.CompactSessionResponseSchema.parse(rawResponse);
+  }
+  async forkSession(params) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      method: "droid.fork_session" /* FORK_SESSION */,
+      params: _nullishCoalesce(params, () => ( {}))
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    return _chunk4G2RKM2Hjs.ForkSessionResponseSchema.parse(rawResponse);
+  }
+  async renameSession(params, requestId) {
+    if (!this.currentSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionError)(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _nullishCoalesce(requestId, () => ( _uuid.v4.call(void 0, ))),
+      method: "droid.rename_session" /* RENAME_SESSION */,
+      params: {
+        title: params.title
+      }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    return _chunk4G2RKM2Hjs.RenameSessionResponseSchema.parse(rawResponse);
+  }
+  async warmupCache() {
+    const response = {
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      type: "response",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      id: _uuid.v4.call(void 0, ),
+      result: {}
+    };
+    return _chunk4G2RKM2Hjs.WarmupCacheResponseSchema.parse(response);
+  }
+  onNotification(callback, filter) {
+    const handler = (notification) => {
+      if (_optionalChain([filter, 'optionalAccess', _13 => _13.type]) !== void 0 && filter.type !== notification.params.notification.type) {
+        return;
+      }
+      try {
+        callback(notification);
+      } catch (e3) {
+      }
+    };
+    this.on("session_notification" /* SESSION_NOTIFICATION */, handler);
+    return () => this.off("session_notification" /* SESSION_NOTIFICATION */, handler);
+  }
+  onError(callback) {
+    const handler = (error) => {
+      try {
+        callback(error);
+      } catch (e4) {
+      }
+    };
+    this.on("error" /* ERROR */, handler);
+    if (this.transportError) {
+      handler(this.transportError);
+    }
+    return () => this.off("error" /* ERROR */, handler);
+  }
+  setPermissionHandler(handler) {
+    this.permissionHandlers.set(
+      "default",
+      async (event) => await handler(event)
+    );
+  }
+  clearPermissionHandler() {
+    this.permissionHandlers.delete("default");
+  }
+  setAskUserHandler(handler) {
+    this.askUserHandlers.set("default", async (event) => await handler(event));
+  }
+  clearAskUserHandler() {
+    this.askUserHandlers.delete("default");
+  }
+  async close() {
+    const closeError = new (0, _chunk4G2RKM2Hjs.ConnectionError)(
+      "Droid client closed: pending requests cancelled"
+    );
+    this.rejectAllPending(closeError);
+    this.permissionHandlers.clear();
+    this.askUserHandlers.clear();
+    this.removeAllListeners();
+    await this.transport.close();
+  }
+  rejectAllPending(error) {
+    this.pendingRequests.forEach(({ timeoutId, reject }, requestId) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      reject(error);
+      this.notifyRequestSettled(requestId);
+    });
+    this.pendingRequests.clear();
+    this.pendingPermissionRequests.forEach(({ reject }) => {
+      reject(error);
+    });
+    this.pendingPermissionRequests.clear();
+    this.pendingAskUserRequests.forEach(({ reject }) => {
+      reject(error);
+    });
+    this.pendingAskUserRequests.clear();
+  }
+  settleRequest(requestId) {
+    this.pendingRequests.delete(requestId);
+    this.notifyRequestSettled(requestId);
+  }
+  notifyRequestSettled(requestId) {
+    try {
+      _optionalChain([this, 'access', _14 => _14.onRequestSettled, 'optionalCall', _15 => _15(requestId)]);
+    } catch (e5) {
+    }
+  }
+  async sendRequest(request, timeout) {
+    if (this.transportError) {
+      throw this.transportError;
+    }
+    const responsePromise = new Promise(
+      (resolve2, reject) => {
+        const timeoutId = timeout ? setTimeout(() => {
+          this.settleRequest(request.id);
+          reject(
+            new (0, _chunk4G2RKM2Hjs.TimeoutError)("Send request timed out", {
+              requestId: request.id,
+              method: request.method,
+              timeout
+            })
+          );
+        }, timeout) : void 0;
+        this.pendingRequests.set(request.id, {
+          method: request.method,
+          resolve: resolve2,
+          reject,
+          timeoutId
+        });
+      }
+    );
+    const _meta = {};
+    this.tracing.injectContext(_meta, this.tracing.getCurrentContext());
+    const requestWithMeta = _meta.traceparent ? { ...request, _meta } : request;
+    try {
+      this.logger.info("[DroidClient] [daemon -> droid] sending request", {
+        requestId: request.id,
+        method: request.method
+      });
+      await this.transport.send(JSON.stringify(requestWithMeta));
+    } catch (error) {
+      const pending = this.pendingRequests.get(request.id);
+      if (pending) {
+        if (pending.timeoutId) {
+          clearTimeout(pending.timeoutId);
+        }
+        this.settleRequest(request.id);
+        pending.reject(
+          new (0, _chunk4G2RKM2Hjs.ProtocolError)("[daemon -> droid] Failed to send request", {
+            requestId: request.id,
+            cause: error
+          })
+        );
+      }
+    }
+    return responsePromise;
+  }
+  async handleMessage(message) {
+    try {
+      const parsed = JSON.parse(message);
+      if ("result" in parsed || "error" in parsed) {
+        this.handleResponse(parsed);
+      } else if ("method" in parsed) {
+        await this.handleEvent(parsed);
+      } else {
+        throw new (0, _chunk4G2RKM2Hjs.ProtocolError)("Invalid message format", {
+          message
+        });
+      }
+    } catch (e6) {
+      this.logger.warn("[DroidClient] Failed to handle message", {
+        messageByteLength: new TextEncoder().encode(message).byteLength
+      });
+    }
+  }
+  handleResponse(response) {
+    try {
+      const responseId = getResponseId(response);
+      if (responseId !== null && responseId !== void 0) {
+        const pending = this.pendingRequests.get(responseId);
+        if (pending) {
+          let validatedResponse;
+          switch (pending.method) {
+            case "droid.initialize_session" /* INITIALIZE_SESSION */:
+              validatedResponse = _chunk4G2RKM2Hjs.InitializeSessionResponseSchema.parse(response);
+              break;
+            case "droid.load_session" /* LOAD_SESSION */:
+              validatedResponse = _chunk4G2RKM2Hjs.LoadSessionResponseSchema.parse(response);
+              break;
+            case "droid.add_user_message" /* ADD_USER_MESSAGE */:
+              validatedResponse = _chunk4G2RKM2Hjs.AddUserMessageResponseSchema.parse(response);
+              break;
+            case "droid.append_messages" /* APPEND_MESSAGES */:
+              validatedResponse = _chunk4G2RKM2Hjs.AppendMessagesResponseSchema.parse(response);
+              break;
+            case "droid.resolve_queued_user_message" /* RESOLVE_QUEUED_USER_MESSAGE */:
+              validatedResponse = _chunk4G2RKM2Hjs.ResolveQueuedUserMessageResponseSchema.parse(response);
+              break;
+            case "droid.interrupt_session" /* INTERRUPT_SESSION */:
+              validatedResponse = _chunk4G2RKM2Hjs.InterruptSessionResponseSchema.parse(response);
+              break;
+            case "droid.close_session" /* CLOSE_SESSION */:
+              validatedResponse = _chunk4G2RKM2Hjs.CloseSessionResponseSchema.parse(response);
+              break;
+            case "droid.update_session_settings" /* UPDATE_SESSION_SETTINGS */:
+              validatedResponse = _chunk4G2RKM2Hjs.UpdateSessionSettingsResponseSchema.parse(response);
+              break;
+            case "droid.change_working_directory" /* CHANGE_WORKING_DIRECTORY */:
+              validatedResponse = _chunk4G2RKM2Hjs.ChangeWorkingDirectoryResponseSchema.parse(response);
+              break;
+            case "droid.toggle_mcp_server" /* TOGGLE_MCP_SERVER */:
+              validatedResponse = _chunk4G2RKM2Hjs.ToggleMcpServerResponseSchema.parse(response);
+              break;
+            case "droid.authenticate_mcp_server" /* AUTHENTICATE_MCP_SERVER */:
+              validatedResponse = _chunk4G2RKM2Hjs.AuthenticateMcpServerResponseSchema.parse(response);
+              break;
+            case "droid.cancel_mcp_auth" /* CANCEL_MCP_AUTH */:
+              validatedResponse = _chunk4G2RKM2Hjs.CancelMcpAuthResponseSchema.parse(response);
+              break;
+            case "droid.clear_mcp_auth" /* CLEAR_MCP_AUTH */:
+              validatedResponse = _chunk4G2RKM2Hjs.ClearMcpAuthResponseSchema.parse(response);
+              break;
+            case "droid.add_mcp_server" /* ADD_MCP_SERVER */:
+              validatedResponse = _chunk4G2RKM2Hjs.AddMcpServerResponseSchema.parse(response);
+              break;
+            case "droid.remove_mcp_server" /* REMOVE_MCP_SERVER */:
+              validatedResponse = _chunk4G2RKM2Hjs.RemoveMcpServerResponseSchema.parse(response);
+              break;
+            case "droid.list_models" /* LIST_MODELS */:
+              validatedResponse = _chunk4G2RKM2Hjs.ListModelsResponseSchema.parse(response);
+              break;
+            case "droid.list_mcp_registry" /* LIST_MCP_REGISTRY */:
+              validatedResponse = _chunk4G2RKM2Hjs.ListMcpRegistryResponseSchema.parse(response);
+              break;
+            case "droid.list_mcp_tools" /* LIST_MCP_TOOLS */:
+              validatedResponse = _chunk4G2RKM2Hjs.ListMcpToolsResponseSchema.parse(response);
+              break;
+            case "droid.list_tools" /* LIST_TOOLS */:
+              validatedResponse = _chunk4G2RKM2Hjs.ListToolsResponseSchema.parse(response);
+              break;
+            case "droid.toggle_mcp_tool" /* TOGGLE_MCP_TOOL */:
+              validatedResponse = _chunk4G2RKM2Hjs.ToggleMcpToolResponseSchema.parse(response);
+              break;
+            case "droid.submit_mcp_auth_code" /* SUBMIT_MCP_AUTH_CODE */:
+              validatedResponse = _chunk4G2RKM2Hjs.SubmitMcpAuthCodeResponseSchema.parse(response);
+              break;
+            case "droid.submit_mcp_auth_error" /* SUBMIT_MCP_AUTH_ERROR */:
+              validatedResponse = _chunk4G2RKM2Hjs.SubmitMcpAuthErrorResponseSchema.parse(response);
+              break;
+            case "droid.kill_worker_session" /* KILL_WORKER_SESSION */:
+              validatedResponse = _chunk4G2RKM2Hjs.KillWorkerSessionResponseSchema.parse(response);
+              break;
+            case "droid.list_skills" /* LIST_SKILLS */:
+              validatedResponse = _chunk4G2RKM2Hjs.ListSkillsResponseSchema.parse(response);
+              break;
+            case "droid.set_skill_disabled" /* SET_SKILL_DISABLED */:
+              validatedResponse = _chunk4G2RKM2Hjs.SetSkillDisabledResponseSchema.parse(response);
+              break;
+            case "droid.list_commands" /* LIST_COMMANDS */:
+              validatedResponse = _chunk4G2RKM2Hjs.ListCommandsResponseSchema.parse(response);
+              break;
+            case "droid.submit_bug_report" /* SUBMIT_BUG_REPORT */:
+              validatedResponse = _chunk4G2RKM2Hjs.SubmitBugReportResponseSchema.parse(response);
+              break;
+            case "droid.list_mcp_servers" /* LIST_MCP_SERVERS */:
+              validatedResponse = _chunk4G2RKM2Hjs.ListMcpServersResponseSchema.parse(response);
+              break;
+            case "droid.get_rewind_info" /* GET_REWIND_INFO */:
+              validatedResponse = _chunk4G2RKM2Hjs.GetRewindInfoResponseSchema.parse(response);
+              break;
+            case "droid.execute_rewind" /* EXECUTE_REWIND */:
+              validatedResponse = _chunk4G2RKM2Hjs.ExecuteRewindResponseSchema.parse(response);
+              break;
+            case "droid.compact_session" /* COMPACT_SESSION */:
+              validatedResponse = _chunk4G2RKM2Hjs.CompactSessionResponseSchema.parse(response);
+              break;
+            case "droid.fork_session" /* FORK_SESSION */:
+              validatedResponse = _chunk4G2RKM2Hjs.ForkSessionResponseSchema.parse(response);
+              break;
+            case "droid.rename_session" /* RENAME_SESSION */:
+              validatedResponse = _chunk4G2RKM2Hjs.RenameSessionResponseSchema.parse(response);
+              break;
+            case "droid.get_context_stats" /* GET_CONTEXT_STATS */:
+              validatedResponse = _chunk4G2RKM2Hjs.GetContextStatsResponseSchema.parse(response);
+              break;
+            case "droid.get_context_breakdown" /* GET_CONTEXT_BREAKDOWN */:
+              validatedResponse = _chunk4G2RKM2Hjs.GetContextBreakdownResponseSchema.parse(response);
+              break;
+            case "droid.warmup_cache" /* WARMUP_CACHE */:
+              validatedResponse = _chunk4G2RKM2Hjs.WarmupCacheResponseSchema.parse(response);
+              break;
+            default: {
+              const exhaustiveCheck = pending.method;
+              throw new (0, _chunk4G2RKM2Hjs.DroidClientError)(
+                "Unsupported method in response handler",
+                {
+                  method: exhaustiveCheck
+                }
+              );
+            }
+          }
+          if (pending.timeoutId) {
+            clearTimeout(pending.timeoutId);
+          }
+          this.settleRequest(responseId);
+          pending.resolve(validatedResponse);
+        } else {
+          const validatedResponse = _chunk4G2RKM2Hjs.JsonRpcBaseResponseSchema.parse(response);
+          this.logger.info(
+            "[DroidClient] Received response for request not in pending map",
+            {
+              requestId: _nullishCoalesce(validatedResponse.id, () => ( void 0))
+            }
+          );
+        }
+      }
+    } catch (error) {
+      const responseId = getResponseId(response);
+      const pending = responseId !== null && responseId !== void 0 ? this.pendingRequests.get(responseId) : void 0;
+      const zodIssues = error instanceof _zod.z.ZodError ? error.issues.map((issue) => ({
+        path: issue.path,
+        code: issue.code,
+        message: issue.message
+      })) : void 0;
+      this.logger.exception(error, "Invalid response format", {
+        method: _optionalChain([pending, 'optionalAccess', _16 => _16.method]),
+        requestId: _nullishCoalesce(responseId, () => ( void 0)),
+        zodIssues
+      });
+      const err = error instanceof Error ? error : new Error(String(error));
+      const code = error instanceof _zod.z.ZodError ? -32700 /* PARSE_ERROR */ : -32603 /* INTERNAL_ERROR */;
+      const message = code === -32700 /* PARSE_ERROR */ ? "Invalid response format" : "Internal error while handling response";
+      if (responseId === null || responseId === void 0) {
+        return;
+      }
+      if (!pending) {
+        this.logger.info(
+          "[DroidClient] Dropping unhandleable response with no pending request",
+          {
+            requestId: responseId,
+            code,
+            message: err.message
+          }
+        );
+        return;
+      }
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
+      this.settleRequest(responseId);
+      const syntheticFailure = {
+        jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+        type: "response",
+        factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+        factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+        id: responseId,
+        error: {
+          code,
+          message,
+          data: err.message
+        }
+      };
+      pending.resolve(syntheticFailure);
+    }
+  }
+  async handleEvent(event) {
+    try {
+      const validatedEvent = _chunk4G2RKM2Hjs.CliRequestOrNotificationSchema.parse(event);
+      if (validatedEvent.method === "droid.session_notification" /* SESSION_NOTIFICATION */) {
+        const notification = validatedEvent.params.notification;
+        if (notification.type === "agent_turn_completed" /* AGENT_TURN_COMPLETED */) {
+          this.completedTurnObserved = true;
+        } else if (notification.type === "droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */ && notification.newState !== "idle" /* Idle */) {
+          this.completedTurnObserved = false;
+        }
+        this.emit("session_notification" /* SESSION_NOTIFICATION */, validatedEvent);
+      } else if (validatedEvent.method === "droid.request_permission" /* REQUEST_PERMISSION */) {
+        await this.handlePermissionRequest(validatedEvent);
+      } else if (validatedEvent.method === "droid.ask_user" /* ASK_USER */) {
+        await this.handleAskUserRequest(validatedEvent);
+      }
+    } catch (error) {
+      this.logDroppedEventParseError(error, event);
+      await this.replyWithParseFailureIfRequest(error, event);
+    }
+  }
+  /**
+   * When an incoming CLI->client request fails to parse, send back a
+   * structurally valid JsonRpcBaseResponseFailure so the peer's pending
+   * request doesn't hang. No-ops for notifications (no id to reply on)
+   * or events we can't correlate.
+   */
+  async replyWithParseFailureIfRequest(error, event) {
+    const type = _DroidClient.getNestedString(event, ["type"]);
+    const id = _DroidClient.getNestedString(event, ["id"]);
+    if (type !== "request" || !id) {
+      return;
+    }
+    const err = error instanceof Error ? error : new Error(String(error));
+    const code = error instanceof _zod.z.ZodError ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */;
+    const message = code === -32600 /* INVALID_REQUEST */ ? "Invalid request format" : "Internal error while handling request";
+    const errorResponse = {
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      type: "response",
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      id,
+      error: {
+        code,
+        message,
+        data: err.message
+      }
+    };
+    try {
+      await this.transport.send(JSON.stringify(errorResponse));
+    } catch (sendError) {
+      this.logger.exception(
+        sendError,
+        "Failed to send parse-failure response back to peer"
+      );
+    }
+  }
+  /**
+   * Invariant: parsing failures for incoming events (notifications or
+   * server-initiated requests) must NEVER surface as user-visible ERROR
+   * notifications. Version skew, unknown inner enum values, missing
+   * fields, or malformed shapes all degrade to a log-and-drop so the
+   * session continues quietly instead of flashing a synthetic error on
+   * every
+   */
+  logDroppedEventParseError(error, event) {
+    const { protocolVersionMismatch } = inspectJsonRpcEnvelope2(event);
+    const method = _DroidClient.getNestedString(event, ["method"]);
+    const notificationType = _DroidClient.getNestedString(event, [
+      "params",
+      "notification",
+      "type"
+    ]);
+    const sessionId = _nullishCoalesce(this.currentSessionId, () => ( _DroidClient.getNestedString(event, ["params", "sessionId"])));
+    const meta = {
+      value: {
+        method: _nullishCoalesce(method, () => ( void 0)),
+        notificationType: _nullishCoalesce(notificationType, () => ( void 0)),
+        protocolVersionMismatch: _nullishCoalesce(protocolVersionMismatch, () => ( void 0)),
+        sessionId: _nullishCoalesce(sessionId, () => ( void 0))
+      }
+    };
+    if (protocolVersionMismatch) {
+      this.logger.info(
+        "[DroidClient] Dropping unsupported event from newer peer",
+        meta
+      );
+    } else {
+      this.logger.warn("[DroidClient] Dropping malformed event", {
+        ...meta,
+        cause: error
+      });
+    }
+  }
+  async handlePermissionRequest(event) {
+    if (this.pendingPermissionRequests.has(event.id)) {
+      this.logger.info(
+        "[DroidClient] Ignoring duplicate pending permission request",
+        {
+          requestId: event.id
+        }
+      );
+      return;
+    }
+    this.logger.info("[DroidClient] Handling permission request", {
+      requestId: event.id,
+      toolCount: event.params.toolUses.length
+    });
+    this.emit("request_permission" /* REQUEST_PERMISSION */, event);
+    let selectedOption = "cancel" /* Cancel */;
+    let comment;
+    let editedSpecContent;
+    const handler = this.permissionHandlers.get("default");
+    if (handler) {
+      try {
+        this.logger.info(
+          "[DroidClient] Waiting for permission handler to resolve",
+          {
+            requestId: event.id
+          }
+        );
+        const handlerPromise = new Promise(
+          (resolve2, reject) => {
+            this.pendingPermissionRequests.set(event.id, { reject });
+            handler(event).then(resolve2).catch(reject).finally(() => {
+              this.pendingPermissionRequests.delete(event.id);
+            });
+          }
+        );
+        const handlerResult = await handlerPromise;
+        if (typeof handlerResult === "string" && handlerResult === "proceed_edit" /* ProceedEdit */) {
+          throw new (0, _chunk4G2RKM2Hjs.DroidClientError)(
+            "Permission handler returned proceed_edit without editedSpecContent"
+          );
+        }
+        const parsedHandlerResult = _chunk4G2RKM2Hjs.RequestPermissionResultSchema.safeParse(
+          typeof handlerResult === "string" ? { selectedOption: handlerResult } : handlerResult
+        );
+        if (parsedHandlerResult.success) {
+          selectedOption = parsedHandlerResult.data.selectedOption;
+          comment = parsedHandlerResult.data.comment;
+          editedSpecContent = parsedHandlerResult.data.editedSpecContent;
+        } else {
+          throw new (0, _chunk4G2RKM2Hjs.DroidClientError)(
+            "Permission handler returned invalid result",
+            {
+              cause: parsedHandlerResult.error
+            }
+          );
+        }
+        if (!event.params.options.some(
+          (option) => option.value === selectedOption
+        )) {
+          throw new (0, _chunk4G2RKM2Hjs.DroidClientError)(
+            `Permission handler selected unavailable option: ${selectedOption}`
+          );
+        }
+        this.logger.info("[DroidClient] Permission handler resolved", {
+          requestId: event.id,
+          result: selectedOption
+        });
+      } catch (error) {
+        this.logger.exception(
+          error,
+          "Failed to handle permission request (processing)"
+        );
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.emit(
+          "session_notification" /* SESSION_NOTIFICATION */,
+          _DroidClient.createNotificationEvent(
+            _DroidClient.createErrorNotification(err)
+          )
+        );
+        this.pendingPermissionRequests.delete(event.id);
+        const cancelResponse = {
+          type: "response",
+          jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+          factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+          factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+          id: event.id,
+          result: {
+            selectedOption: "cancel" /* Cancel */
+          }
+        };
+        try {
+          await this.transport.send(JSON.stringify(cancelResponse));
+        } catch (sendError) {
+          this.logger.exception(
+            sendError,
+            "Failed to handle permission request (send cancellation)"
+          );
+          const sendErr = sendError instanceof Error ? sendError : new Error(String(sendError));
+          this.emit(
+            "session_notification" /* SESSION_NOTIFICATION */,
+            _DroidClient.createNotificationEvent(
+              _DroidClient.createErrorNotification(sendErr)
+            )
+          );
+        }
+        return;
+      }
+    }
+    const response = {
+      type: "response",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      id: event.id,
+      result: {
+        selectedOption,
+        ...comment !== void 0 && { comment },
+        ...editedSpecContent !== void 0 && { editedSpecContent }
+      }
+    };
+    this.logger.info("[DroidClient] Sending permission response back to CLI", {
+      requestId: event.id,
+      result: String(selectedOption)
+    });
+    await this.transport.send(JSON.stringify(response));
+  }
+  async handleAskUserRequest(event) {
+    this.logger.info("[DroidClient] Handling ask-user request", {
+      requestId: event.id,
+      toolCallId: event.params.toolCallId,
+      questionCount: event.params.questions.length
+    });
+    this.emit("ask_user" /* ASK_USER */, event);
+    let result = { cancelled: true, answers: [] };
+    const handler = this.askUserHandlers.get("default");
+    if (handler) {
+      try {
+        this.logger.info(
+          "[DroidClient] Waiting for ask-user handler to resolve",
+          {
+            requestId: event.id
+          }
+        );
+        const handlerPromise = new Promise((resolve2, reject) => {
+          this.pendingAskUserRequests.set(event.id, { reject });
+          handler(event).then(resolve2).catch(reject).finally(() => {
+            this.pendingAskUserRequests.delete(event.id);
+          });
+        });
+        const parsedResult = _chunk4G2RKM2Hjs.AskUserResultSchema.safeParse(
+          await handlerPromise
+        );
+        if (!parsedResult.success) {
+          throw new (0, _chunk4G2RKM2Hjs.DroidClientError)(
+            "AskUser handler returned invalid result",
+            {
+              cause: parsedResult.error
+            }
+          );
+        }
+        result = parsedResult.data;
+        this.logger.info("[DroidClient] Ask-user handler resolved", {
+          requestId: event.id,
+          cancelled: _nullishCoalesce(result.cancelled, () => ( false)),
+          answerCount: result.answers.length
+        });
+      } catch (error) {
+        this.logger.exception(error, "Failed to handle ask-user request");
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.emit(
+          "session_notification" /* SESSION_NOTIFICATION */,
+          _DroidClient.createNotificationEvent(
+            _DroidClient.createErrorNotification(err)
+          )
+        );
+        this.pendingAskUserRequests.delete(event.id);
+        const cancelResponse = {
+          jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+          factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+          factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+          type: "response",
+          id: event.id,
+          result: {
+            cancelled: true,
+            answers: []
+          }
+        };
+        try {
+          await this.transport.send(JSON.stringify(cancelResponse));
+        } catch (sendError) {
+          this.logger.exception(
+            sendError,
+            "Failed to send ask-user cancellation"
+          );
+        }
+        return;
+      }
+    }
+    const response = {
+      type: "response",
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      id: event.id,
+      result
+    };
+    this.logger.info("[DroidClient] Sending ask-user response back to CLI", {
+      requestId: event.id,
+      cancelled: _nullishCoalesce(result.cancelled, () => ( false))
+    });
+    await this.transport.send(JSON.stringify(response));
+  }
+  static getErrorType(error) {
+    switch (error.constructor) {
+      case _chunk4G2RKM2Hjs.ConnectionError:
+        return "ConnectionError" /* CONNECTION_ERROR */;
+      case _chunk4G2RKM2Hjs.ProtocolError:
+        return "ProtocolError" /* PROTOCOL_ERROR */;
+      case _chunk4G2RKM2Hjs.SessionError:
+        return "SessionError" /* SESSION_ERROR */;
+      case _chunk4G2RKM2Hjs.TimeoutError:
+        return "TimeoutError" /* TIMEOUT_ERROR */;
+      case _chunk4G2RKM2Hjs.ProcessExitError:
+        return "ProcessExitError" /* PROCESS_EXIT_ERROR */;
+      case _chunk4G2RKM2Hjs.DroidClientError:
+        return "DroidClientError" /* DROID_CLIENT_ERROR */;
+      default:
+        return "Error" /* ERROR */;
+    }
+  }
+  static createErrorNotification(error) {
+    return {
+      type: "error" /* ERROR */,
+      message: error.message,
+      errorType: _DroidClient.getErrorType(error),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...error instanceof _chunk4G2RKM2Hjs.ProcessExitError && error.exitCode !== void 0 ? { exitCode: error.exitCode } : {},
+      error: {
+        name: error.name,
+        message: error.message
+      }
+    };
+  }
+  static getNestedString(value, path3) {
+    let current = value;
+    for (const key of path3) {
+      if (!_DroidClient.isRecord(current)) {
+        return null;
+      }
+      current = current[key];
+    }
+    return typeof current === "string" ? current : null;
+  }
+  static isRecord(value) {
+    return typeof value === "object" && value !== null;
+  }
+  /**
+   * Create a full SessionNotificationEvent for locally-generated notifications.
+   * Used when the SDK needs to emit error notifications that weren't received from the CLI.
+   */
+  static createNotificationEvent(notification) {
+    return {
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION2,
+      type: "notification",
+      factoryApiVersion: _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION,
+      method: "droid.session_notification" /* SESSION_NOTIFICATION */,
+      params: { notification }
+    };
+  }
+}, _class);
+
+// src/exec-core/managed-process.ts
+var _child_process = require('child_process');
+var _fs = require('fs'); var fs3 = _interopRequireWildcard(_fs);
+var _readline = require('readline'); var readline = _interopRequireWildcard(_readline);
+
+// src/exec-core/runtime-utils.ts
+var _os = require('os'); var os = _interopRequireWildcard(_os);
+var _path = require('path'); var path2 = _interopRequireWildcard(_path);
+function isErrnoException(error) {
+  return error !== null && typeof error === "object" && "code" in error && typeof error.code === "string";
+}
+function expandTilde(filepath) {
+  if (!filepath) {
+    return filepath;
+  }
+  if (filepath === "~") {
+    return _os.homedir.call(void 0, );
+  }
+  if (filepath.startsWith("~/") || filepath.startsWith("~\\")) {
+    return _path.join.call(void 0, _os.homedir.call(void 0, ), filepath.slice(2));
+  }
+  return filepath;
+}
+
+// src/exec-core/transport-logger.ts
+
+
+var LOG_FILE_NAME = "droid-transport.log";
+var LOG_DIR_MODE = 448;
+var LOG_FILE_MODE = 384;
+var state = null;
+var enabledCache = null;
+var HOST_PID_TAG = `host_pid=${process.pid}`;
+function isTruthy(value) {
+  const v = value.trim().toLowerCase();
+  return v !== "" && v !== "0" && v !== "false" && v !== "off" && v !== "no";
+}
+function directionMarker(direction) {
+  switch (direction) {
+    case "in" /* In */:
+      return "IN ";
+    case "out" /* Out */:
+      return "OUT";
+    case "out_failed" /* OutFailed */:
+      return "OUT!";
+    default:
+      return "???";
+  }
+}
+function isTransportLoggingEnabled(deps = defaultExecCoreDeps) {
+  if (enabledCache !== null) return enabledCache;
+  enabledCache = isTruthy(
+    _nullishCoalesce(deps.environmentResolver.resolveTransportLogEnvValue(), () => ( ""))
+  );
+  return enabledCache;
+}
+function looksLikePath(value) {
+  return path2.default.isAbsolute(value) || value.startsWith("~") || value.startsWith("./") || value.startsWith("../") || value.startsWith(".\\") || value.startsWith("..\\") || value.includes("/") || value.includes("\\");
+}
+function resolveLogPath(deps) {
+  const envValue = deps.environmentResolver.resolveTransportLogEnvValue();
+  const pathResolver = deps.factoryPathResolver;
+  if (envValue && looksLikePath(envValue)) {
+    if (envValue === "~" || envValue.startsWith("~/") || envValue.startsWith("~\\")) {
+      const rest = envValue.slice(2);
+      const home = pathResolver.getFactoryHome();
+      return rest ? path2.default.join(home, rest) : home;
+    }
+    return envValue;
+  }
+  return path2.default.join(
+    pathResolver.getFactoryHome(),
+    pathResolver.getFactoryDirName(),
+    "logs",
+    LOG_FILE_NAME
+  );
+}
+function initState(deps) {
+  const result = { stream: null, failed: false };
+  try {
+    const logPath = resolveLogPath(deps);
+    const logsDir = path2.default.dirname(logPath);
+    const logsDirExisted = fs3.default.existsSync(logsDir);
+    if (!logsDirExisted) {
+      fs3.default.mkdirSync(logsDir, { recursive: true, mode: LOG_DIR_MODE });
+    }
+    if (process.platform !== "win32" && !logsDirExisted) {
+      try {
+        fs3.default.chmodSync(logsDir, LOG_DIR_MODE);
+      } catch (chmodError) {
+        logWarn(
+          deps.logger,
+          "[droid-sdk transport-logger] failed to chmod logs dir",
+          {
+            cause: chmodError
+          }
+        );
+      }
+    }
+    const stream = fs3.default.createWriteStream(logPath, {
+      flags: "a",
+      encoding: "utf8",
+      mode: LOG_FILE_MODE
+    });
+    if (process.platform !== "win32") {
+      try {
+        fs3.default.chmodSync(logPath, LOG_FILE_MODE);
+      } catch (chmodError) {
+        logWarn(
+          deps.logger,
+          "[droid-sdk transport-logger] failed to chmod log file",
+          {
+            cause: chmodError
+          }
+        );
+      }
+    }
+    stream.on("error", (streamError) => {
+      deps.logger.warn("[droid-sdk transport-logger] write stream error", {
+        cause: streamError
+      });
+      result.stream = null;
+      result.failed = true;
+    });
+    result.stream = stream;
+  } catch (initError) {
+    logWarn(
+      deps.logger,
+      "[droid-sdk transport-logger] failed to open log file",
+      {
+        cause: initError
+      }
+    );
+    result.failed = true;
+  }
+  return result;
+}
+function getState(deps) {
+  if (!isTransportLoggingEnabled(deps)) return null;
+  if (state === null) {
+    state = initState(deps);
+  }
+  if (state.failed) return null;
+  return state;
+}
+function logTransportMessage(direction, message, childPid, deps = defaultExecCoreDeps) {
+  const s = getState(deps);
+  if (!s || !s.stream) return;
+  try {
+    const marker = directionMarker(direction);
+    const childTag = `[child_pid=${_nullishCoalesce(childPid, () => ( "-"))}]`;
+    s.stream.write(
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] [${HOST_PID_TAG}] ${childTag} ${marker} ${message}
+`
+    );
+  } catch (writeError) {
+    logWarn(
+      deps.logger,
+      "[droid-sdk transport-logger] write failed, disabling",
+      {
+        cause: writeError
+      }
+    );
+    s.failed = true;
+    s.stream = null;
+  }
+}
+async function __resetTransportLoggerForTests(deps = defaultExecCoreDeps) {
+  const stream = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _17 => _17.stream]), () => ( null));
+  state = null;
+  enabledCache = null;
+  if (!stream) return;
+  await new Promise((resolve2) => {
+    stream.once("finish", () => resolve2());
+    stream.once("error", () => resolve2());
+    try {
+      stream.end();
+    } catch (endError) {
+      logWarn(
+        deps.logger,
+        "[droid-sdk transport-logger] failed to end stream on reset",
+        {
+          cause: endError
+        }
+      );
+      resolve2();
+    }
+  });
+}
+
+// src/exec-core/managed-process.ts
+var MAX_NON_JSON_LOG_LENGTH = 200;
+var EXIT_STDIO_DRAIN_TIMEOUT_MS = 2e3;
+var GRACEFUL_EXIT_TIMEOUT_MS = 2e3;
+var FORCED_EXIT_TIMEOUT_MS = 3e3;
+function describeSpawnError(error, context) {
+  if (!isErrnoException(error)) {
+    return `Failed to start Droid: ${error.message}`;
+  }
+  if (error.code === "ENOENT") {
+    if (_optionalChain([context, 'optionalAccess', _18 => _18.cwd]) && !fs3.default.existsSync(context.cwd)) {
+      return `Failed to start Droid: working directory does not exist (${context.cwd})`;
+    }
+    return `Failed to start Droid: executable not found${_optionalChain([context, 'optionalAccess', _19 => _19.execPath]) ? ` (${context.execPath})` : ""}`;
+  }
+  if (error.code === "EACCES") {
+    return `Failed to start Droid: permission denied${_optionalChain([context, 'optionalAccess', _20 => _20.execPath]) ? ` (${context.execPath})` : ""}`;
+  }
+  return `Failed to start Droid: ${error.code}`;
+}
+function describeExitError(code, signal) {
+  if (signal) {
+    return `Droid process was killed (${signal})`;
+  }
+  if (code !== null) {
+    return `Droid process exited unexpectedly (exit code ${code})`;
+  }
+  return "Droid process exited unexpectedly";
+}
+var ManagedProcessImpl = (_class2 = class {
+  constructor(childProcess, logPrefix, spawnContext, deps, transportLoggerDeps = deps) {;_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);_class2.prototype.__init12.call(this);_class2.prototype.__init13.call(this);_class2.prototype.__init14.call(this);_class2.prototype.__init15.call(this);_class2.prototype.__init16.call(this);
+    this.logPrefix = logPrefix;
+    this.spawnContext = spawnContext;
+    this.transportLoggerDeps = transportLoggerDeps;
+    this._childProcess = childProcess;
+    this.logger = deps.logger;
+    this.setupHandlers();
+  }
+  
+  
+  
+  
+  __init9() {this.messageHandler = null}
+  __init10() {this.errorHandler = null}
+  __init11() {this.readlineInterface = null}
+  __init12() {this.isClosing = false}
+  /** Latch so exit teardown/classification runs exactly once per process. */
+  __init13() {this.exitFinalized = false}
+  __init14() {this.exitDrainTimer = null}
+  /**
+   * Sticky error from a process error or unexpected exit event. Once set,
+   * all subsequent `send()` calls throw this error immediately instead of
+   * hanging on a dead transport.
+   */
+  __init15() {this.processError = null}
+  __init16() {this.queuedSendPromise = Promise.resolve()}
+  
+  get childProcess() {
+    if (!this._childProcess) {
+      throw new (0, _chunk4G2RKM2Hjs.ConnectionError)("Process not connected");
+    }
+    return this._childProcess;
+  }
+  setupHandlers() {
+    if (!this.childProcess.stdout) {
+      throw new (0, _chunk4G2RKM2Hjs.ConnectionError)("Failed to get process stdout");
+    }
+    this.readlineInterface = readline.createInterface({
+      input: this.childProcess.stdout,
+      crlfDelay: Infinity
+    });
+    this.readlineInterface.on("line", (line) => {
+      const trimmedLine = line.trim();
+      if (this.messageHandler && trimmedLine) {
+        if (trimmedLine.startsWith("{") || trimmedLine.startsWith("[")) {
+          logTransportMessage(
+            "in" /* In */,
+            trimmedLine,
+            _optionalChain([this, 'access', _21 => _21._childProcess, 'optionalAccess', _22 => _22.pid]),
+            this.transportLoggerDeps
+          );
+          this.messageHandler(trimmedLine);
+        } else {
+          const truncated = trimmedLine.length > MAX_NON_JSON_LOG_LENGTH ? trimmedLine.substring(0, MAX_NON_JSON_LOG_LENGTH) : trimmedLine;
+          this.logger.warn("[droid process] non-JSON output", {
+            state: this.logPrefix,
+            output: truncated
+          });
+        }
+      }
+    });
+    this.childProcess.on("error", (error) => {
+      this.processError = new (0, _chunk4G2RKM2Hjs.ConnectionError)(
+        describeSpawnError(error, this.spawnContext),
+        {
+          error,
+          cwd: _optionalChain([this, 'access', _23 => _23.spawnContext, 'optionalAccess', _24 => _24.cwd]),
+          execPath: _optionalChain([this, 'access', _25 => _25.spawnContext, 'optionalAccess', _26 => _26.execPath])
+        }
+      );
+      if (!this.isClosing && this.errorHandler) {
+        this.errorHandler(this.processError);
+      }
+    });
+    this.childProcess.on("exit", (code, signal) => {
+      this.exitDrainTimer = setTimeout(() => {
+        this.finalizeExit(code, signal);
+      }, EXIT_STDIO_DRAIN_TIMEOUT_MS);
+      _optionalChain([this, 'access', _27 => _27.exitDrainTimer, 'access', _28 => _28.unref, 'optionalCall', _29 => _29()]);
+    });
+    this.childProcess.on("close", (code, signal) => {
+      this.finalizeExit(code, signal);
+    });
+    if (this.childProcess.stderr) {
+      this.childProcess.stderr.on("data", (data) => {
+        this.logger.warn("[droid process] stderr", {
+          state: this.logPrefix,
+          output: data.toString()
+        });
+      });
+    }
+  }
+  finalizeExit(code, signal) {
+    if (this.exitFinalized) {
+      return;
+    }
+    this.exitFinalized = true;
+    if (this.exitDrainTimer) {
+      clearTimeout(this.exitDrainTimer);
+      this.exitDrainTimer = null;
+    }
+    this._childProcess = null;
+    if (this.readlineInterface) {
+      this.readlineInterface.close();
+      this.readlineInterface = null;
+    }
+    if (!this.isClosing) {
+      this.processError = new (0, _chunk4G2RKM2Hjs.ProcessExitError)(
+        describeExitError(code, signal),
+        {
+          exitCode: _nullishCoalesce(code, () => ( void 0)),
+          signal: _nullishCoalesce(signal, () => ( void 0))
+        }
+      );
+      if (this.errorHandler) {
+        this.errorHandler(this.processError);
+      }
+    }
+  }
+  async send(message) {
+    if (this.processError) {
+      throw this.processError;
+    }
+    if (!this._childProcess || !this._childProcess.stdin) {
+      throw new (0, _chunk4G2RKM2Hjs.ConnectionError)("Process not connected");
+    }
+    const previousSends = this.queuedSendPromise;
+    this.queuedSendPromise = (async () => {
+      await previousSends.catch(() => {
+      });
+      if (!this._childProcess || !this._childProcess.stdin || this._childProcess.killed || this.isClosing) {
+        throw new (0, _chunk4G2RKM2Hjs.ConnectionError)("Process disconnected before write");
+      }
+      await new Promise((resolve2, reject) => {
+        try {
+          if (!this._childProcess || !this._childProcess.stdin) {
+            reject(new (0, _chunk4G2RKM2Hjs.ConnectionError)("Process stdin unavailable"));
+            return;
+          }
+          const stdin = this._childProcess.stdin;
+          if ("writable" in stdin && !stdin.writable) {
+            reject(new (0, _chunk4G2RKM2Hjs.ConnectionError)("Process stdin is not writable"));
+            return;
+          }
+          const childPid = _optionalChain([this, 'access', _30 => _30._childProcess, 'optionalAccess', _31 => _31.pid]);
+          stdin.write(`${message}
+`, (error) => {
+            if (error) {
+              logTransportMessage(
+                "out_failed" /* OutFailed */,
+                message,
+                childPid,
+                this.transportLoggerDeps
+              );
+              const errorMessage = error.message || String(error);
+              if (errorMessage.includes("EPIPE") || errorMessage.includes("ECONNRESET")) {
+                reject(
+                  new (0, _chunk4G2RKM2Hjs.ConnectionError)("Process stdin closed during write", {
+                    error
+                  })
+                );
+              } else {
+                reject(
+                  new (0, _chunk4G2RKM2Hjs.ConnectionError)("Failed to write to process stdin", {
+                    error
+                  })
+                );
+              }
+            } else {
+              logTransportMessage(
+                "out" /* Out */,
+                message,
+                childPid,
+                this.transportLoggerDeps
+              );
+              resolve2();
+            }
+          });
+        } catch (error) {
+          logWarn(
+            this.logger,
+            "[ManagedProcess] Error writing to process stdin",
+            {
+              cause: error
+            }
+          );
+          reject(
+            new (0, _chunk4G2RKM2Hjs.ConnectionError)("Error writing to process stdin", {
+              error: error instanceof Error ? error : new Error(String(error))
+            })
+          );
+        }
+      });
+    })();
+    return this.queuedSendPromise;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  async close() {
+    this.isClosing = true;
+    if (this._childProcess) {
+      const processToClose = this._childProcess;
+      if (processToClose.pid === void 0 || processToClose.exitCode !== null || processToClose.signalCode !== null && processToClose.signalCode !== void 0) {
+        this._childProcess = null;
+      } else {
+        await new Promise((resolve2) => {
+          let forcedExitTimeout;
+          const gracefulExitTimeout = setTimeout(() => {
+            if (processToClose.exitCode === null) {
+              if (process.platform === "win32") {
+                this.killProcessTree(processToClose, "SIGKILL");
+              } else {
+                this.killProcessTree(processToClose, "SIGTERM");
+                forcedExitTimeout = setTimeout(() => {
+                  if (processToClose.exitCode === null) {
+                    this.killProcessTree(processToClose, "SIGKILL");
+                  }
+                }, FORCED_EXIT_TIMEOUT_MS);
+              }
+            }
+          }, GRACEFUL_EXIT_TIMEOUT_MS);
+          processToClose.once("exit", () => {
+            clearTimeout(gracefulExitTimeout);
+            if (forcedExitTimeout) clearTimeout(forcedExitTimeout);
+            resolve2();
+          });
+          if (processToClose.stdin) {
+            processToClose.stdin.end();
+          }
+        });
+      }
+    }
+    if (this.readlineInterface) {
+      this.readlineInterface.close();
+      this.readlineInterface = null;
+    }
+    this.exitFinalized = true;
+    if (this.exitDrainTimer) {
+      clearTimeout(this.exitDrainTimer);
+      this.exitDrainTimer = null;
+    }
+    this._childProcess = null;
+    this.isClosing = false;
+  }
+  killProcessTree(childProcess, signal) {
+    if (process.platform !== "win32" || childProcess.pid === void 0) {
+      childProcess.kill(signal);
+      return;
+    }
+    const result = _child_process.spawnSync.call(void 0, 
+      "taskkill",
+      ["/PID", String(childProcess.pid), "/T", "/F"],
+      {
+        stdio: "ignore",
+        windowsHide: true
+      }
+    );
+    if (!result.error && result.status === 0) {
+      return;
+    }
+    logWarn(
+      this.logger,
+      "[ManagedProcess] Failed to kill Windows process tree",
+      {
+        pid: childProcess.pid,
+        signal,
+        status: result.status,
+        cause: result.error
+      }
+    );
+    childProcess.kill(signal);
+  }
+  get isConnected() {
+    return this._childProcess !== null && !this._childProcess.killed && this._childProcess.stdin !== null && !this._childProcess.stdin.destroyed && ("writable" in this._childProcess.stdin ? this._childProcess.stdin.writable : true);
+  }
+}, _class2);
+
+// src/exec-core/process-manager.ts
+
+
+// src/exec-core/windows-job-object-retry.ts
+var DEFAULT_BACKOFF_MS = [50, 150, 400];
+var DEFAULT_MAX_RETRIES = 2;
+var DEFAULT_GRACE_PERIOD_MS = 250;
+var defaultSleep = (ms) => new Promise((resolve2) => {
+  setTimeout(resolve2, ms);
+});
+function observeEarlySpawnFailure(childProcess, gracePeriodMs, sleep) {
+  const observation = {
+    exited: false,
+    code: null,
+    signal: null,
+    error: null,
+    stderr: ""
+  };
+  const stderrListener = (data) => {
+    observation.stderr += data.toString();
+  };
+  const exitListener = (code, signal) => {
+    observation.exited = true;
+    observation.code = code;
+    observation.signal = signal;
+  };
+  const errorListener = (err) => {
+    observation.error = err;
+  };
+  _optionalChain([childProcess, 'access', _32 => _32.stderr, 'optionalAccess', _33 => _33.on, 'call', _34 => _34("data", stderrListener)]);
+  childProcess.once("exit", exitListener);
+  childProcess.once("error", errorListener);
+  const cleanup = () => {
+    _optionalChain([childProcess, 'access', _35 => _35.stderr, 'optionalAccess', _36 => _36.off, 'call', _37 => _37("data", stderrListener)]);
+    childProcess.off("exit", exitListener);
+    childProcess.off("error", errorListener);
+  };
+  return new Promise((resolve2) => {
+    const resolveAndCleanup = () => {
+      cleanup();
+      resolve2(observation);
+    };
+    const onExitResolve = () => {
+      setImmediate(resolveAndCleanup);
+    };
+    childProcess.once("exit", onExitResolve);
+    childProcess.once("error", onExitResolve);
+    void sleep(gracePeriodMs).then(() => {
+      childProcess.off("exit", onExitResolve);
+      childProcess.off("error", onExitResolve);
+      resolveAndCleanup();
+    });
+  });
+}
+async function spawnWithWindowsJobObjectRetry(spawnFactory, options = {}) {
+  const enabled = _nullishCoalesce(options.enabled, () => ( process.platform === "win32"));
+  if (!enabled) {
+    return spawnFactory();
+  }
+  const maxRetries = _nullishCoalesce(options.maxRetries, () => ( DEFAULT_MAX_RETRIES));
+  const backoff = _nullishCoalesce(options.backoffMs, () => ( DEFAULT_BACKOFF_MS));
+  const gracePeriodMs = _nullishCoalesce(options.gracePeriodMs, () => ( DEFAULT_GRACE_PERIOD_MS));
+  const sleep = _nullishCoalesce(options.sleep, () => ( defaultSleep));
+  const logPrefix = _nullishCoalesce(options.logPrefix, () => ( "[spawnWithWindowsJobObjectRetry]"));
+  const logger = _nullishCoalesce(options.logger, () => ( noopLogger));
+  let lastChild = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const child = spawnFactory();
+    lastChild = child;
+    const observation = await observeEarlySpawnFailure(
+      child,
+      gracePeriodMs,
+      sleep
+    );
+    if (!observation.exited && !observation.error) {
+      return child;
+    }
+    const isRetryableJobObjectFailure = observation.stderr.includes(WINDOWS_JOB_OBJECT_ERROR_MARKER) || observation.exited && observation.code !== 0 && !observation.error;
+    if (attempt === maxRetries || !isRetryableJobObjectFailure) {
+      return child;
+    }
+    logger.warn("spawnWithWindowsJobObjectRetry: retrying on early failure", {
+      name: logPrefix,
+      attempt: attempt + 1,
+      maxAttempts: maxRetries,
+      exitCode: observation.code,
+      signal: observation.signal,
+      stderrTail: observation.stderr.slice(-256)
+    });
+    try {
+      await _optionalChain([options, 'access', _38 => _38.disposeEarlyExited, 'optionalCall', _39 => _39(child)]);
+    } catch (disposeErr) {
+      logWarn(logger, "spawnWithWindowsJobObjectRetry: dispose error", {
+        cause: disposeErr instanceof Error ? disposeErr : new Error(String(disposeErr)),
+        name: logPrefix
+      });
+    }
+    await sleep(_nullishCoalesce(_nullishCoalesce(backoff[attempt], () => ( backoff[backoff.length - 1])), () => ( 400)));
+  }
+  if (lastChild) return lastChild;
+  throw new (0, _chunk4G2RKM2Hjs.DroidClientError)(
+    "spawnWithWindowsJobObjectRetry: exhausted retries without child",
+    {}
+  );
+}
+
+// src/exec-core/process-manager.ts
+function buildArgs(config) {
+  const args = [];
+  if (config.mode === "acp" /* Acp */) {
+    args.push("exec", "--output-format", "acp");
+  } else {
+    args.push(
+      "exec",
+      "--input-format",
+      "stream-jsonrpc",
+      "--output-format",
+      "stream-jsonrpc"
+    );
+  }
+  if (config.extraArgs) {
+    args.push(...config.extraArgs);
+  }
+  return args;
+}
+var DroidProcessManager = class {
+  
+  
+  
+  
+  constructor(options = {}, deps = defaultExecCoreDeps) {
+    const resolved = resolveExecCoreDeps(options.observability, deps);
+    this.deps = resolved;
+    this.transportLoggerDeps = deps;
+    this.logger = resolved.logger;
+    this.commandResolver = resolved.commandResolver;
+  }
+  /**
+   * Spawn a new droid process with the given configuration.
+   *
+   * Returns a synchronous ManagedProcess as soon as the OS reports the child
+   * as spawned. This does not retry Windows Job Object spawn failures — use
+   * {@link DroidProcessManager#spawnWithWindowsRetry} for that.
+   */
+  spawn(config) {
+    const { logPrefix, execPath, expandedCwd, childProcess } = this.spawnChildProcess(config);
+    return new ManagedProcessImpl(
+      childProcess,
+      logPrefix,
+      {
+        cwd: expandedCwd,
+        execPath
+      },
+      this.deps,
+      this.transportLoggerDeps
+    );
+  }
+  /**
+   * Spawn a droid process with automatic retry for the Windows Job Object
+   * spawn error class (FAC-19070). On non-Windows platforms this behaves
+   * identically to {@link DroidProcessManager#spawn} but returns a promise.
+   *
+   * When a Windows child process exits within the startup grace period and
+   * the exit looks like the `AssignProcessToJobObject` failure pattern, the
+   * dead child is disposed and a fresh spawn is attempted, up to the
+   * configured retry cap.
+   */
+  async spawnWithWindowsRetry(config, retryOptions = {}) {
+    if (process.platform !== "win32") {
+      return this.spawn(config);
+    }
+    const planned = this.prepareSpawn(config);
+    const childProcess = await spawnWithWindowsJobObjectRetry(
+      () => this.invokeNodeSpawn(planned),
+      {
+        ...retryOptions,
+        logPrefix: "[DroidProcessManager]",
+        logger: this.logger,
+        disposeEarlyExited: (child) => {
+          try {
+            _optionalChain([child, 'access', _40 => _40.stdin, 'optionalAccess', _41 => _41.end, 'call', _42 => _42()]);
+          } catch (stdinErr) {
+            logWarn(
+              this.logger,
+              "DroidProcessManager: stdin.end() threw during dispose",
+              {
+                cause: stdinErr instanceof Error ? stdinErr : new Error(String(stdinErr))
+              }
+            );
+          }
+          try {
+            child.kill();
+          } catch (killErr) {
+            logWarn(
+              this.logger,
+              "DroidProcessManager: kill() threw during dispose",
+              {
+                cause: killErr instanceof Error ? killErr : new Error(String(killErr))
+              }
+            );
+          }
+        }
+      }
+    );
+    if (!childProcess.stdout || !childProcess.stdin) {
+      throw new (0, _chunk4G2RKM2Hjs.ConnectionError)("Failed to get process stdio");
+    }
+    return new ManagedProcessImpl(
+      childProcess,
+      planned.logPrefix,
+      {
+        cwd: planned.expandedCwd,
+        execPath: planned.execPath
+      },
+      this.deps,
+      this.transportLoggerDeps
+    );
+  }
+  prepareSpawn(config) {
+    const command = this.commandResolver.resolveDroidCommand(
+      _nullishCoalesce(config.isDevelopment, () => ( false))
+    );
+    const execPath = config.execPath || command.execPath;
+    const prefixArgs = config.execPath ? [] : command.prefixArgs;
+    const args = [...prefixArgs, ...buildArgs(config)];
+    const expandedCwd = config.cwd ? expandTilde(config.cwd) : void 0;
+    const logPrefix = config.mode === "acp" /* Acp */ ? "[droid acp]" : "[droid exec]";
+    this.logger.info("[droid process] Spawning", {
+      state: logPrefix,
+      path: execPath,
+      args,
+      cwd: expandedCwd,
+      version: process.env.CLI_VERSION || "unknown"
+    });
+    return {
+      logPrefix,
+      execPath,
+      expandedCwd,
+      args,
+      env: {
+        ...this.deps.environmentResolver.sanitizeSpawnEnv({
+          ...process.env,
+          ...config.env
+        }),
+        ...config.trustedEnv
+      },
+      enableIpc: _nullishCoalesce(config.enableIpc, () => ( false)),
+      stdio: config.stdio
+    };
+  }
+  invokeNodeSpawn(planned) {
+    const options = {
+      cwd: planned.expandedCwd,
+      env: planned.env,
+      stdio: _nullishCoalesce(planned.stdio, () => ( (planned.enableIpc ? ["pipe", "pipe", "pipe", "ipc"] : ["pipe", "pipe", "pipe"])))
+    };
+    if (planned.enableIpc) {
+      options.serialization = "json";
+    }
+    return _child_process.spawn.call(void 0, planned.execPath, planned.args, options);
+  }
+  spawnChildProcess(config) {
+    const planned = this.prepareSpawn(config);
+    const childProcess = this.invokeNodeSpawn(planned);
+    if (!childProcess.stdout || !childProcess.stdin) {
+      throw new (0, _chunk4G2RKM2Hjs.ConnectionError)("Failed to get process stdio");
+    }
+    return {
+      logPrefix: planned.logPrefix,
+      execPath: planned.execPath,
+      expandedCwd: planned.expandedCwd,
+      childProcess
+    };
+  }
+};
+
+// src/exec-core/process-transport.ts
+var ProcessTransport = (_class3 = class {
+  __init17() {this.managedProcess = null}
+  
+  
+  // Store handlers that may be registered before connect() is called
+  __init18() {this.messageHandler = null}
+  __init19() {this.errorHandler = null}
+  
+  constructor(options = {}, deps = defaultExecCoreDeps) {;_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);
+    this.options = options;
+    const resolved = resolveExecCoreDeps(options.observability, deps);
+    this.metrics = resolved.metrics;
+    this.processManager = new DroidProcessManager(
+      {
+        observability: options.observability
+      },
+      deps
+    );
+  }
+  async connect() {
+    if (this.managedProcess && this.managedProcess.isConnected) {
+      throw new (0, _chunk4G2RKM2Hjs.ConnectionError)("Transport already connected");
+    }
+    const config = {
+      execPath: this.options.droidExecPath,
+      isDevelopment: this.options.isDevelopment,
+      mode: "stream-jsonrpc" /* StreamJsonRpc */,
+      cwd: this.options.cwd,
+      env: this.options.env,
+      extraArgs: this.options.droidExecExtraArgs,
+      enableIpc: this.options.enableIpc
+    };
+    const spawnStart = performance.now();
+    let spawnOutcome = "error";
+    try {
+      this.managedProcess = process.platform === "win32" ? await this.processManager.spawnWithWindowsRetry(config) : this.processManager.spawn(config);
+      spawnOutcome = "success";
+    } finally {
+      this.metrics.recordDuration(
+        CLI_JSONRPC_CHILD_SPAWN_LATENCY_METRIC,
+        performance.now() - spawnStart,
+        { outcome: spawnOutcome, source: "process_transport" }
+      );
+    }
+    if (this.messageHandler) {
+      this.managedProcess.onMessage(this.messageHandler);
+    }
+    if (this.errorHandler) {
+      this.managedProcess.onError(this.errorHandler);
+    }
+  }
+  async send(message) {
+    if (!this.managedProcess) {
+      throw new (0, _chunk4G2RKM2Hjs.ConnectionError)("Transport not connected");
+    }
+    return this.managedProcess.send(message);
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+    if (this.managedProcess) {
+      this.managedProcess.onMessage(handler);
+    }
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+    if (this.managedProcess) {
+      this.managedProcess.onError(handler);
+    }
+  }
+  async close() {
+    if (this.managedProcess) {
+      await this.managedProcess.close();
+      this.managedProcess = null;
+    }
+  }
+  get isConnected() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _43 => _43.managedProcess, 'optionalAccess', _44 => _44.isConnected]), () => ( false));
+  }
+  getManagedProcess() {
+    return this.managedProcess;
+  }
+}, _class3);
+
+// src/helpers.ts
+function resolveApiKey(apiKey) {
+  const resolved = _nullishCoalesce(apiKey, () => ( process.env.FACTORY_API_KEY));
+  if (!resolved) {
+    throw new (0, _chunk4G2RKM2Hjs.DroidClientError)(
+      "No Factory API key found. Pass `apiKey` when creating the session, or set the FACTORY_API_KEY environment variable."
+    );
+  }
+  return resolved;
+}
+async function createTransport(options) {
+  if (options.transport) {
+    return options.transport;
+  }
+  const processTransport = new ProcessTransport({
+    droidExecPath: options.execPath,
+    droidExecExtraArgs: options.execArgs,
+    cwd: options.cwd,
+    env: { ...options.env, FACTORY_API_KEY: resolveApiKey(options.apiKey) },
+    observability: options.observability
+  });
+  await processTransport.connect();
+  return processTransport;
+}
+function setupClientHandlers(client, options) {
+  if (options.permissionHandler) {
+    const handler = options.permissionHandler;
+    client.setPermissionHandler((event) => handler(event.params));
+  }
+  if (options.askUserHandler) {
+    const handler = options.askUserHandler;
+    client.setAskUserHandler((event) => handler(event.params));
+  }
+}
+async function createConfiguredClient(options) {
+  const transport = await createTransport(options);
+  const client = new DroidClient({
+    transport,
+    observability: options.observability
+  });
+  setupClientHandlers(client, options);
+  return { transport, client };
+}
+async function closeQuietly(resource) {
+  if (!resource) {
+    return;
+  }
+  try {
+    await resource.close();
+  } catch (e7) {
+  }
+}
+function buildInitParams(options) {
+  return {
+    machineId: _nullishCoalesce(options.machineId, () => ( "default")),
+    cwd: _nullishCoalesce(options.cwd, () => ( process.cwd())),
+    ...options.modelId !== void 0 && { modelId: options.modelId },
+    ...options.autonomyLevel !== void 0 && {
+      autonomyLevel: options.autonomyLevel
+    },
+    ...options.interactionMode !== void 0 && {
+      interactionMode: options.interactionMode
+    },
+    ...options.reasoningEffort !== void 0 && {
+      reasoningEffort: options.reasoningEffort
+    },
+    ...options.systemPrompt !== void 0 && {
+      systemPrompt: options.systemPrompt
+    },
+    ...options.specModeModelId !== void 0 && {
+      specModeModelId: options.specModeModelId
+    },
+    ...options.specModeReasoningEffort !== void 0 && {
+      specModeReasoningEffort: options.specModeReasoningEffort
+    },
+    ...options.mcpServers !== void 0 && {
+      mcpServers: options.mcpServers
+    },
+    ...options.disabledToolIds !== void 0 && {
+      disabledToolIds: options.disabledToolIds
+    },
+    ...options.sessionSource !== void 0 && {
+      sessionSource: options.sessionSource
+    },
+    ...options.autoRejectPermissionRequests !== void 0 && {
+      autoRejectPermissionRequests: options.autoRejectPermissionRequests
+    },
+    ...options.disableBuiltinSkills !== void 0 && {
+      disableBuiltinSkills: options.disableBuiltinSkills
+    },
+    tags: [..._nullishCoalesce(options.tags, () => ( [])), _chunk4G2RKM2Hjs.SDK_TAG]
+  };
+}
+
+// src/mcp.ts
+var _crypto = require('crypto');
+
+var _http = require('http'); var _http2 = _interopRequireDefault(_http);
+var _mcpjs = require('@modelcontextprotocol/sdk/server/mcp.js');
+var _streamableHttpjs = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+
+function tool(name, description, inputSchemaOrHandler, handler) {
+  if (typeof inputSchemaOrHandler === "function") {
+    const actualHandler = inputSchemaOrHandler;
+    return {
+      name,
+      description,
+      handler: (input) => actualHandler(input)
+    };
+  }
+  if (!handler) {
+    throw new Error(`Missing handler for SDK MCP tool "${name}"`);
+  }
+  const inputObjectSchema = _zod.z.object(inputSchemaOrHandler);
+  return {
+    name,
+    description,
+    inputSchema: inputSchemaOrHandler,
+    handler: (input) => handler(inputObjectSchema.parse(input))
+  };
+}
+function isSdkMcpServer(server) {
+  return server instanceof SdkMcpServer;
+}
+function toCallToolResult(result) {
+  if (typeof result === "string") {
+    return {
+      content: [{ type: "text", text: result }]
+    };
+  }
+  return result;
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  if (chunks.length === 0) {
+    return void 0;
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function writeJsonError(res, statusCode, message, headers = {}) {
+  if (res.headersSent) {
+    return;
+  }
+  res.writeHead(statusCode, {
+    "content-type": "application/json",
+    ...headers
+  });
+  res.end(
+    JSON.stringify({
+      jsonrpc: _chunk4G2RKM2Hjs.JSONRPC_VERSION,
+      error: { code: -32603 /* INTERNAL_ERROR */, message },
+      id: null
+    })
+  );
+}
+function hasValidBearerToken(authorization, token) {
+  if (!authorization) {
+    return false;
+  }
+  const separator = authorization.indexOf(" ");
+  if (separator === -1 || authorization.slice(0, separator).toLowerCase() !== "bearer") {
+    return false;
+  }
+  const actual = Buffer.from(authorization.slice(separator + 1));
+  const expected = Buffer.from(token);
+  return actual.length === expected.length && _crypto.timingSafeEqual.call(void 0, actual, expected);
+}
+var SdkMcpServer = (_class4 = class {
+  
+  
+  
+  __init20() {this._httpServer = null}
+  __init21() {this._url = null}
+  __init22() {this._token = null}
+  constructor(options) {;_class4.prototype.__init20.call(this);_class4.prototype.__init21.call(this);_class4.prototype.__init22.call(this);
+    this.name = options.name;
+    this.version = _nullishCoalesce(options.version, () => ( "1.0.0"));
+    this.tools = options.tools;
+  }
+  get config() {
+    if (!this._url || !this._token) {
+      return null;
+    }
+    return {
+      type: "http" /* Http */,
+      name: this.name,
+      url: this._url,
+      oauth: false,
+      headers: [
+        {
+          name: "Authorization",
+          value: `Bearer ${this._token}`
+        }
+      ]
+    };
+  }
+  async start() {
+    if (this.config) {
+      return this.config;
+    }
+    this._token = _crypto.randomBytes.call(void 0, 32).toString("base64url");
+    this._httpServer = _http2.default.createServer((req, res) => {
+      void this.handleRequest(req, res);
+    });
+    this._httpServer.listen(0, "127.0.0.1");
+    await _events.once.call(void 0, this._httpServer, "listening");
+    const address = this._httpServer.address();
+    if (!address || typeof address === "string") {
+      throw new Error("Unable to determine SDK MCP server address");
+    }
+    this._url = `http://127.0.0.1:${address.port}/mcp`;
+    const config = this.config;
+    if (!config) {
+      throw new Error("Unable to start SDK MCP server");
+    }
+    return config;
+  }
+  async close() {
+    const server = this._httpServer;
+    this._httpServer = null;
+    this._url = null;
+    this._token = null;
+    if (!server) {
+      return;
+    }
+    _optionalChain([server, 'access', _45 => _45.closeAllConnections, 'optionalCall', _46 => _46()]);
+    server.close();
+    await _events.once.call(void 0, server, "close");
+  }
+  createMcpServer() {
+    const server = new (0, _mcpjs.McpServer)({
+      name: this.name,
+      version: this.version
+    });
+    for (const sdkTool of this.tools) {
+      server.registerTool(
+        sdkTool.name,
+        {
+          description: sdkTool.description,
+          ...sdkTool.inputSchema && {
+            inputSchema: sdkTool.inputSchema
+          }
+        },
+        async (input) => toCallToolResult(await sdkTool.handler(input))
+      );
+    }
+    return server;
+  }
+  async handleRequest(req, res) {
+    if (req.url !== "/mcp") {
+      res.writeHead(404).end();
+      return;
+    }
+    if (req.method !== "POST") {
+      res.writeHead(405).end();
+      return;
+    }
+    const token = this._token;
+    if (!token || !hasValidBearerToken(req.headers.authorization, token)) {
+      writeJsonError(res, 401, "Unauthorized", {
+        "www-authenticate": "Bearer"
+      });
+      return;
+    }
+    const server = this.createMcpServer();
+    const transport = new (0, _streamableHttpjs.StreamableHTTPServerTransport)({
+      sessionIdGenerator: void 0
+    });
+    res.on("close", () => {
+      void transport.close();
+      void server.close();
+    });
+    try {
+      const body = await readJsonBody(req);
+      await server.connect(transport);
+      await transport.handleRequest(req, res, body);
+    } catch (error) {
+      writeJsonError(
+        res,
+        500,
+        error instanceof Error ? error.message : "Internal server error"
+      );
+      await transport.close();
+      await server.close();
+    }
+  }
+}, _class4);
+function createSdkMcpServer(options) {
+  return new SdkMcpServer(options);
+}
+async function startSdkMcpServers(servers) {
+  if (!servers) {
+    return { cleanup: async () => {
+    } };
+  }
+  const startedServers = [];
+  const mcpServers = [];
+  try {
+    for (const server of servers) {
+      if (isSdkMcpServer(server)) {
+        mcpServers.push(await server.start());
+        startedServers.push(server);
+      } else {
+        mcpServers.push(server);
+      }
+    }
+  } catch (error) {
+    await Promise.all(startedServers.map((server) => server.close()));
+    throw error;
+  }
+  return {
+    mcpServers,
+    cleanup: async () => {
+      await Promise.all(startedServers.map((server) => server.close()));
+    }
+  };
+}
+
+// src/session.ts
+var DroidSession = (_class5 = class _DroidSession {
+  /** @internal */
+  constructor(client, sessionId, metadata, _runtime, cleanupCallbacks = []) {;_class5.prototype.__init23.call(this);_class5.prototype.__init24.call(this);_class5.prototype.__init25.call(this);_class5.prototype.__init26.call(this);_class5.prototype.__init27.call(this);_class5.prototype.__init28.call(this);
+    this._runtime = _runtime;
+    this._client = client;
+    this._sessionId = sessionId;
+    this._settings = metadata.settings;
+    this._cwd = metadata.cwd;
+    this._cleanupCallbacks = cleanupCallbacks;
+    this._bindMetadataNotifications();
+    this._bindAbortSignal();
+  }
+  
+  
+  
+  
+  
+  __init23() {this._settingsRevision = 0}
+  __init24() {this._status = "active"}
+  
+  __init25() {this._cleanupAbortSignal = null}
+  __init26() {this._cleanupCallbacks = []}
+  __init27() {this._activeBridges = /* @__PURE__ */ new Set()}
+  __init28() {this._notificationCleanups = /* @__PURE__ */ new Set()}
+  get id() {
+    return this._sessionId;
+  }
+  get settings() {
+    return this._settings;
+  }
+  get cwd() {
+    return this._cwd;
+  }
+  async *stream(prompt, options) {
+    this._ensureNotClosed();
+    yield* _chunk4G2RKM2Hjs.streamFromClient.call(void 0, 
+      {
+        onNotification: (handler) => this._client.onNotification((notification) => {
+          const inner = _chunk4G2RKM2Hjs.extractInnerNotification.call(void 0, notification);
+          if (inner) handler(inner);
+        }),
+        onError: (handler) => this._client.onError(handler),
+        addUserMessage: (params) => this._client.addUserMessage(params),
+        interruptSession: () => this._client.interruptSession()
+      },
+      this._sessionId,
+      this._activeBridges,
+      prompt,
+      options
+    );
+  }
+  async interrupt() {
+    this._ensureNotClosed();
+    await this._client.interruptSession();
+  }
+  async close() {
+    if (this._status === "closed" || this._status === "replaced") {
+      return;
+    }
+    this._status = "closed";
+    this._releaseHandleSubscriptions();
+    _optionalChain([this, 'access', _47 => _47._cleanupAbortSignal, 'optionalCall', _48 => _48()]);
+    this._cleanupAbortSignal = null;
+    for (const bridge of this._activeBridges) {
+      bridge.signalDone();
+      bridge.release();
+    }
+    try {
+      await this._client.closeSession({ reason: "other" }).catch(() => {
+      });
+      await this._client.close();
+    } finally {
+      const cleanups = this._cleanupCallbacks.splice(0);
+      await Promise.all(cleanups.map((cleanup) => cleanup()));
+    }
+  }
+  async updateSettings(params) {
+    this._ensureNotClosed();
+    const revision = this._settingsRevision;
+    const result = _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, 
+      await this._client.updateSessionSettings(params)
+    );
+    if (params.disabledToolIds !== void 0) {
+      this._runtime.loadParams.disabledToolIds = params.disabledToolIds;
+    }
+    if (this._settingsRevision === revision) {
+      this._settings = _chunk4G2RKM2Hjs.mergeSessionSettings.call(void 0, this._settings, params);
+    }
+    return result;
+  }
+  async enterSpecMode(params = {}) {
+    return this.updateSettings({
+      interactionMode: "spec" /* Spec */,
+      ...params
+    });
+  }
+  async exitSpecMode() {
+    return this.updateSettings({
+      interactionMode: "auto" /* Auto */
+    });
+  }
+  async addMcpServer(params) {
+    this._ensureNotClosed();
+    return _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, await this._client.addMcpServer(params));
+  }
+  async removeMcpServer(params) {
+    this._ensureNotClosed();
+    return _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, await this._client.removeMcpServer(params));
+  }
+  async toggleMcpServer(params) {
+    this._ensureNotClosed();
+    return _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, await this._client.toggleMcpServer(params));
+  }
+  async listMcpServers() {
+    this._ensureNotClosed();
+    return _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, await this._client.listMcpServers());
+  }
+  async listMcpTools() {
+    this._ensureNotClosed();
+    return _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, await this._client.listMcpTools()).tools;
+  }
+  async listTools(params = {}) {
+    this._ensureNotClosed();
+    return _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, await this._client.listTools(params)).tools.map(
+      ({ id: _protocolId, llmId, currentlyAllowed, ...tool2 }) => ({
+        ...tool2,
+        id: llmId,
+        allowed: currentlyAllowed
+      })
+    );
+  }
+  async authenticateMcpServer(params) {
+    this._ensureNotClosed();
+    return _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, 
+      await this._client.authenticateMcpServer(params)
+    );
+  }
+  async listSkills() {
+    this._ensureNotClosed();
+    return _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, await this._client.listSkills());
+  }
+  async setSkillDisabled(params) {
+    this._ensureNotClosed();
+    return _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, 
+      await this._client.setSkillDisabled(
+        params.skillName,
+        params.disabled,
+        params.settingsLevel
+      )
+    );
+  }
+  async getRewindInfo(params) {
+    this._ensureNotClosed();
+    return _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, await this._client.getRewindInfo(params));
+  }
+  async rewind(params) {
+    const { session, result } = await this._runReplacement(
+      () => this._client.executeRewind(params).then(_chunk4G2RKM2Hjs.unwrapResponseResult)
+    );
+    const { newSessionId: _newSessionId, ...metadata } = result;
+    return { session, ...metadata };
+  }
+  async compact(params) {
+    const { session, result } = await this._runReplacement(
+      () => this._client.compactSession(_nullishCoalesce(params, () => ( {}))).then(_chunk4G2RKM2Hjs.unwrapResponseResult)
+    );
+    return { session, removedCount: result.removedCount };
+  }
+  async fork(params = {}) {
+    const { session } = await this._runReplacement(
+      () => this._client.forkSession(params).then(_chunk4G2RKM2Hjs.unwrapResponseResult)
+    );
+    return session;
+  }
+  async getContextStats() {
+    this._ensureNotClosed();
+    return _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, await this._client.getContextStats());
+  }
+  async rename(params) {
+    this._ensureNotClosed();
+    _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, await this._client.renameSession(params));
+  }
+  onNotification(callback, filter) {
+    this._ensureNotClosed();
+    const unsubscribe = this._client.onNotification(callback, filter);
+    const cleanup = () => {
+      this._notificationCleanups.delete(cleanup);
+      unsubscribe();
+    };
+    this._notificationCleanups.add(cleanup);
+    return cleanup;
+  }
+  _ensureNotClosed() {
+    if (this._status === "replaced" && this._replacementSessionId) {
+      throw new (0, _chunk4G2RKM2Hjs.SessionReplacedError)(
+        this._sessionId,
+        this._replacementSessionId
+      );
+    }
+    if (this._status !== "active") {
+      throw new (0, _chunk4G2RKM2Hjs.ConnectionError)(
+        this._status === "replacing" ? "Session replacement is already in progress." : "Session has been closed. Create a new session to continue."
+      );
+    }
+  }
+  _beginReplacement() {
+    this._ensureNotClosed();
+    if (this._activeBridges.size > 0) {
+      throw new (0, _chunk4G2RKM2Hjs.ConcurrentStreamError)(this._sessionId);
+    }
+    this._status = "replacing";
+  }
+  async _runReplacement(operation) {
+    this._beginReplacement();
+    let result;
+    try {
+      result = await operation();
+    } catch (error) {
+      if (this._status === "replacing") {
+        this._status = "active";
+      }
+      throw error;
+    }
+    if (this._status !== "replacing") {
+      throw new (0, _chunk4G2RKM2Hjs.SessionReplacementError)(this._sessionId, result.newSessionId, {
+        cause: new (0, _chunk4G2RKM2Hjs.ConnectionError)(
+          "Session closed while replacement was in progress."
+        ),
+        rollbackError: new (0, _chunk4G2RKM2Hjs.ConnectionError)(
+          "The source session was already closed."
+        )
+      });
+    }
+    return {
+      session: await this._loadReplacement(result.newSessionId),
+      result
+    };
+  }
+  async _loadReplacement(replacementSessionId) {
+    try {
+      const loadResult = _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, 
+        await this._client.loadSession({
+          ...this._runtime.loadParams,
+          sessionId: replacementSessionId
+        })
+      );
+      if (this._status !== "replacing") {
+        throw new (0, _chunk4G2RKM2Hjs.ConnectionError)(
+          "Session closed while replacement was loading."
+        );
+      }
+      _optionalChain([this, 'access', _49 => _49._cleanupAbortSignal, 'optionalCall', _50 => _50()]);
+      this._cleanupAbortSignal = null;
+      this._releaseHandleSubscriptions();
+      const cleanupCallbacks = this._cleanupCallbacks;
+      this._cleanupCallbacks = [];
+      const replacement = new _DroidSession(
+        this._client,
+        replacementSessionId,
+        { settings: loadResult.settings, cwd: loadResult.cwd },
+        this._runtime,
+        cleanupCallbacks
+      );
+      this._replacementSessionId = replacementSessionId;
+      this._status = "replaced";
+      return replacement;
+    } catch (cause) {
+      if (this._status !== "replacing") {
+        throw new (0, _chunk4G2RKM2Hjs.SessionReplacementError)(
+          this._sessionId,
+          replacementSessionId,
+          {
+            cause,
+            rollbackError: new (0, _chunk4G2RKM2Hjs.ConnectionError)(
+              "The source session was closed before rollback."
+            )
+          }
+        );
+      }
+      let rollbackResult;
+      try {
+        rollbackResult = _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, 
+          await this._client.loadSession({
+            ...this._runtime.loadParams,
+            sessionId: this._sessionId
+          })
+        );
+      } catch (rollbackError) {
+        await this._disposeAfterFailedRollback();
+        throw new (0, _chunk4G2RKM2Hjs.SessionReplacementError)(
+          this._sessionId,
+          replacementSessionId,
+          { cause, rollbackError }
+        );
+      }
+      if (this._status !== "replacing") {
+        const rollbackError = new (0, _chunk4G2RKM2Hjs.ConnectionError)(
+          "Session closed while replacement rollback was loading."
+        );
+        await this._disposeAfterFailedRollback();
+        throw new (0, _chunk4G2RKM2Hjs.SessionReplacementError)(
+          this._sessionId,
+          replacementSessionId,
+          { cause, rollbackError }
+        );
+      }
+      this._settings = rollbackResult.settings;
+      this._cwd = rollbackResult.cwd;
+      this._status = "active";
+      throw new (0, _chunk4G2RKM2Hjs.SessionReplacementError)(this._sessionId, replacementSessionId, {
+        cause
+      });
+    }
+  }
+  _bindAbortSignal() {
+    this._cleanupAbortSignal = _chunk4G2RKM2Hjs.wireAbortSignal.call(void 0, 
+      this._runtime.abortSignal,
+      () => void this.close()
+    );
+  }
+  _bindMetadataNotifications() {
+    const unsubscribe = this._client.onNotification((notification) => {
+      const inner = _chunk4G2RKM2Hjs.extractInnerNotification.call(void 0, notification);
+      if (_optionalChain([inner, 'optionalAccess', _51 => _51.type]) === "settings_updated" /* SETTINGS_UPDATED */) {
+        this._settings = _chunk4G2RKM2Hjs.mergeSessionSettings.call(void 0, this._settings, inner.settings);
+        this._settingsRevision++;
+      } else if (_optionalChain([inner, 'optionalAccess', _52 => _52.type]) === "session_working_directory_changed" /* SESSION_WORKING_DIRECTORY_CHANGED */) {
+        this._cwd = inner.cwd;
+      }
+    });
+    const cleanup = () => {
+      this._notificationCleanups.delete(cleanup);
+      unsubscribe();
+    };
+    this._notificationCleanups.add(cleanup);
+  }
+  _releaseHandleSubscriptions() {
+    for (const cleanup of [...this._notificationCleanups]) cleanup();
+  }
+  async _disposeAfterFailedRollback() {
+    this._status = "closed";
+    _optionalChain([this, 'access', _53 => _53._cleanupAbortSignal, 'optionalCall', _54 => _54()]);
+    this._cleanupAbortSignal = null;
+    this._releaseHandleSubscriptions();
+    await closeQuietly(this._client);
+    const cleanups = this._cleanupCallbacks.splice(0);
+    await Promise.allSettled(
+      cleanups.map((cleanup) => Promise.resolve().then(cleanup))
+    );
+  }
+}, _class5);
+function createReplacementLoadParams(options, mcpServers) {
+  return {
+    mcpServers,
+    disabledToolIds: options.disabledToolIds,
+    autoRejectPermissionRequests: options.autoRejectPermissionRequests,
+    disableBuiltinSkills: options.disableBuiltinSkills,
+    sessionSource: options.sessionSource
+  };
+}
+async function createSession(options = {}) {
+  const { client } = await createConfiguredClient(options);
+  let cleanupInitAbortSignal = _optionalChain([options, 'access', _55 => _55.abortSignal, 'optionalAccess', _56 => _56.aborted]) ? () => {
+  } : _chunk4G2RKM2Hjs.wireAbortSignal.call(void 0, options.abortSignal, () => {
+    void closeQuietly(client);
+  });
+  let sdkMcpServers;
+  try {
+    sdkMcpServers = await startSdkMcpServers(options.mcpServers);
+    const initParams = buildInitParams({
+      ...options,
+      mcpServers: sdkMcpServers.mcpServers
+    });
+    const initResult = _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, 
+      await client.initializeSession(initParams)
+    );
+    const session = new DroidSession(
+      client,
+      initResult.sessionId,
+      {
+        settings: initResult.settings,
+        cwd: _nullishCoalesce(_optionalChain([initResult, 'access', _57 => _57.worktree, 'optionalAccess', _58 => _58.path]), () => ( initParams.cwd))
+      },
+      {
+        abortSignal: options.abortSignal,
+        loadParams: createReplacementLoadParams(
+          options,
+          sdkMcpServers.mcpServers
+        )
+      },
+      [sdkMcpServers.cleanup]
+    );
+    cleanupInitAbortSignal();
+    cleanupInitAbortSignal = () => {
+    };
+    return session;
+  } catch (error) {
+    cleanupInitAbortSignal();
+    await _optionalChain([sdkMcpServers, 'optionalAccess', _59 => _59.cleanup, 'call', _60 => _60()]);
+    await closeQuietly(client);
+    throw error;
+  }
+}
+async function resumeSession(sessionId, options = {}) {
+  const { client } = await createConfiguredClient(options);
+  let cleanupLoadAbortSignal = _optionalChain([options, 'access', _61 => _61.abortSignal, 'optionalAccess', _62 => _62.aborted]) ? () => {
+  } : _chunk4G2RKM2Hjs.wireAbortSignal.call(void 0, options.abortSignal, () => {
+    void closeQuietly(client);
+  });
+  let sdkMcpServers;
+  try {
+    sdkMcpServers = await startSdkMcpServers(options.mcpServers);
+    const replacementLoadParams = createReplacementLoadParams(
+      options,
+      sdkMcpServers.mcpServers
+    );
+    const loadResult = _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, 
+      await client.loadSession({ sessionId, ...replacementLoadParams })
+    );
+    const session = new DroidSession(
+      client,
+      sessionId,
+      { settings: loadResult.settings, cwd: loadResult.cwd },
+      {
+        abortSignal: options.abortSignal,
+        loadParams: replacementLoadParams
+      },
+      [sdkMcpServers.cleanup]
+    );
+    cleanupLoadAbortSignal();
+    cleanupLoadAbortSignal = () => {
+    };
+    return session;
+  } catch (error) {
+    cleanupLoadAbortSignal();
+    await _optionalChain([sdkMcpServers, 'optionalAccess', _63 => _63.cleanup, 'call', _64 => _64()]);
+    await closeQuietly(client);
+    throw error;
+  }
+}
+
+// src/run.ts
+async function run(prompt, options = {}) {
+  const session = await createSession(options);
+  try {
+    for await (const msg of session.stream(prompt, {
+      ...options,
+      includePartialMessages: false
+    })) {
+      if (msg.type === _chunk4G2RKM2Hjs.DroidMessageType.Result) {
+        return msg;
+      }
+    }
+    throw new Error("Stream completed without a result message");
+  } finally {
+    await session.close();
+  }
+}
+
+// src/session-discovery.ts
+
+
+
+var FAVORITES_FILE = ".favorites";
+var SESSION_EXTENSION = ".jsonl";
+var SETTINGS_SUFFIX = ".settings.json";
+var MISSION_TAG_PREFIX = "mission:";
+var MISSION_ID_METADATA_KEY = "missionId";
+var DECOMP_SESSION_TYPE_TAG = "decompSessionType";
+var DECOMP_SESSION_TYPE_METADATA_KEY = "value";
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+var TAB = 9;
+var PARSE_OVERSAMPLE = 20;
+function readFileBuffer(filePath) {
+  try {
+    return fs3.readFileSync(filePath);
+  } catch (e8) {
+    return null;
+  }
+}
+function parseJsonBuffer(buf) {
+  try {
+    return JSON.parse(buf.toString("utf-8"));
+  } catch (e9) {
+    return null;
+  }
+}
+function scanBufferForLines(buf) {
+  let nonEmptyLineCount = 0;
+  let firstLineEnd = -1;
+  let currentLineHasContent = false;
+  for (let i = 0; i < buf.length; i++) {
+    const ch = buf[i];
+    if (ch === LF) {
+      if (currentLineHasContent) nonEmptyLineCount++;
+      if (firstLineEnd === -1) firstLineEnd = i;
+      currentLineHasContent = false;
+    } else if (ch !== CR && ch !== SPACE && ch !== TAB) {
+      currentLineHasContent = true;
+    }
+  }
+  if (currentLineHasContent) nonEmptyLineCount++;
+  const end = firstLineEnd === -1 ? buf.length : firstLineEnd > 0 && buf[firstLineEnd - 1] === CR ? firstLineEnd - 1 : firstLineEnd;
+  return {
+    firstLine: buf.subarray(0, end),
+    nonEmptyLineCount
+  };
+}
+function loadFavorites(sessionsDir) {
+  const buf = readFileBuffer(path2.join(sessionsDir, FAVORITES_FILE));
+  if (!buf) return /* @__PURE__ */ new Set();
+  const parsed = parseJsonBuffer(buf);
+  if (!Array.isArray(parsed)) return /* @__PURE__ */ new Set();
+  return new Set(parsed.filter((id) => typeof id === "string"));
+}
+function loadSettingsFile(directory, sessionId) {
+  const buf = readFileBuffer(
+    path2.join(directory, `${sessionId}${SETTINGS_SUFFIX}`)
+  );
+  if (!buf) return null;
+  const parsed = parseJsonBuffer(buf);
+  if (parsed === null) return null;
+  const result = _chunk4G2RKM2Hjs.SessionSettingsFileSchema.safeParse(parsed);
+  return result.success ? result.data : null;
+}
+function getMissionMetadataFromTags(settings) {
+  if (!_optionalChain([settings, 'optionalAccess', _65 => _65.tags])) return {};
+  const missionTag = settings.tags.find(
+    (tag) => tag.name.startsWith(MISSION_TAG_PREFIX)
+  );
+  const roleTag = settings.tags.find(
+    (tag) => tag.name === DECOMP_SESSION_TYPE_TAG
+  );
+  return {
+    decompMissionId: _optionalChain([missionTag, 'optionalAccess', _66 => _66.metadata, 'optionalAccess', _67 => _67[MISSION_ID_METADATA_KEY]]),
+    decompSessionType: _optionalChain([roleTag, 'optionalAccess', _68 => _68.metadata, 'optionalAccess', _69 => _69[DECOMP_SESSION_TYPE_METADATA_KEY]])
+  };
+}
+function parseSessionFile(candidate, ctx) {
+  const buf = readFileBuffer(candidate.sessionPath);
+  if (!buf) return null;
+  const scanned = scanBufferForLines(buf);
+  const firstParsed = parseJsonBuffer(scanned.firstLine);
+  if (firstParsed === null) return null;
+  const firstResult = _chunk4G2RKM2Hjs.SessionStartEventSchema.safeParse(firstParsed);
+  if (!firstResult.success) return null;
+  const summary = firstResult.data;
+  if (ctx.requiredCwd !== void 0 && (summary.cwd === void 0 || path2.resolve(summary.cwd) !== ctx.requiredCwd)) {
+    return null;
+  }
+  const settingsName = `${candidate.sessionId}${SETTINGS_SUFFIX}`;
+  const settings = candidate.siblingNames.has(settingsName) ? loadSettingsFile(candidate.directory, candidate.sessionId) : null;
+  if (_optionalChain([settings, 'optionalAccess', _70 => _70.archivedAt])) return null;
+  const tagMeta = getMissionMetadataFromTags(settings);
+  const decompSessionType = _nullishCoalesce(summary.decompSessionType, () => ( _chunk4G2RKM2Hjs.SessionStartDecompSessionTypeSchema.safeParse(tagMeta.decompSessionType).data));
+  const messageCount = Math.max(0, scanned.nonEmptyLineCount - 1);
+  return {
+    id: candidate.sessionId,
+    title: summary.title,
+    owner: _nullishCoalesce(summary.owner, () => ( "")),
+    messageCount,
+    modifiedTime: candidate.stats.mtime,
+    createdTime: candidate.stats.birthtime || candidate.stats.ctime,
+    isFavorite: ctx.favorites.has(candidate.sessionId),
+    cwd: summary.cwd,
+    decompSessionType,
+    decompMissionId: _nullishCoalesce(tagMeta.decompMissionId, () => ( summary.decompMissionId))
+  };
+}
+function readDirEntries(directory) {
+  try {
+    return fs3.readdirSync(directory, { withFileTypes: true });
+  } catch (e10) {
+    return [];
+  }
+}
+function collectCandidates(directory, entries) {
+  const siblingNames = new Set(entries.map((e) => e.name));
+  const candidates = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) continue;
+    if (!entry.name.endsWith(SESSION_EXTENSION)) continue;
+    const sessionPath = path2.join(directory, entry.name);
+    let stats;
+    try {
+      stats = fs3.statSync(sessionPath);
+    } catch (e11) {
+      continue;
+    }
+    candidates.push({
+      sessionId: entry.name.slice(0, -SESSION_EXTENSION.length),
+      sessionPath,
+      directory,
+      siblingNames,
+      stats
+    });
+  }
+  return candidates;
+}
+function parseUpTo(candidates, ctx, limit) {
+  const out = [];
+  for (const candidate of candidates) {
+    if (limit !== void 0 && out.length >= limit) break;
+    const metadata = parseSessionFile(candidate, ctx);
+    if (metadata) out.push(metadata);
+  }
+  return out;
+}
+function sanitizePathToDirectoryName(cwd) {
+  let expandedPath = cwd;
+  if (cwd.startsWith("~/") || cwd === "~") {
+    expandedPath = path2.join(os.homedir(), cwd.slice(1));
+  }
+  const absolutePath = path2.resolve(expandedPath);
+  let canonicalPath = absolutePath;
+  try {
+    canonicalPath = fs3.realpathSync(absolutePath);
+  } catch (e12) {
+    canonicalPath = absolutePath;
+  }
+  const normalized = canonicalPath.replace(/[\\/]+$/, "");
+  if (process.platform === "win32") {
+    return `-${normalized.replace(/^([A-Z]):/i, "$1").replace(/[\\/]+/g, "-")}`;
+  }
+  return `-${normalized.replace(/^\/+/, "").replace(/\/+/g, "-")}`;
+}
+function getDefaultSessionsDir() {
+  return path2.join(os.homedir(), ".factory", "sessions");
+}
+async function listSessions(options = {}) {
+  const sessionsDir = _nullishCoalesce(options.sessionsDir, () => ( getDefaultSessionsDir()));
+  const favorites = loadFavorites(sessionsDir);
+  const rootEntries = readDirEntries(sessionsDir);
+  const legacyCandidates = collectCandidates(sessionsDir, rootEntries);
+  const projectCandidates = [];
+  let requiredCwd;
+  if (options.fetchOutsideCWD) {
+    for (const entry of rootEntries) {
+      if (!entry.isDirectory()) continue;
+      if (!entry.name.startsWith("-")) continue;
+      const dir = path2.join(sessionsDir, entry.name);
+      projectCandidates.push(...collectCandidates(dir, readDirEntries(dir)));
+    }
+  } else {
+    const normalizedCwd = path2.resolve(_nullishCoalesce(options.cwd, () => ( process.cwd())));
+    requiredCwd = normalizedCwd;
+    const projectDir = path2.join(
+      sessionsDir,
+      sanitizePathToDirectoryName(normalizedCwd)
+    );
+    projectCandidates.push(
+      ...collectCandidates(projectDir, readDirEntries(projectDir))
+    );
+  }
+  const byMtimeDesc = (a, b) => b.stats.mtime.getTime() - a.stats.mtime.getTime();
+  projectCandidates.sort(byMtimeDesc);
+  legacyCandidates.sort(byMtimeDesc);
+  const parseLimit = options.limit !== void 0 && options.limit >= 0 ? options.limit + PARSE_OVERSAMPLE : void 0;
+  const ctx = { favorites };
+  const legacyCtx = requiredCwd !== void 0 ? { favorites, requiredCwd } : ctx;
+  const projectSessions = parseUpTo(projectCandidates, ctx, parseLimit);
+  const legacySessions = parseUpTo(legacyCandidates, legacyCtx, parseLimit);
+  const byId = /* @__PURE__ */ new Map();
+  for (const session of [...projectSessions, ...legacySessions]) {
+    const existing = byId.get(session.id);
+    if (!existing || session.modifiedTime.getTime() > existing.modifiedTime.getTime()) {
+      byId.set(session.id, session);
+    }
+  }
+  const sorted = Array.from(byId.values()).sort(
+    (a, b) => b.modifiedTime.getTime() - a.modifiedTime.getTime()
+  );
+  if (options.limit !== void 0 && options.limit >= 0) {
+    return sorted.slice(0, options.limit);
+  }
+  return sorted;
+}
+
+// src/model-discovery.ts
+async function listModels(options = {}) {
+  const { includeDisabled, ...transportOptions } = options;
+  const { client } = await createConfiguredClient(transportOptions);
+  try {
+    const response = await client.listModels({
+      ...includeDisabled !== void 0 && { includeDisabled }
+    });
+    return _chunk4G2RKM2Hjs.unwrapResponseResult.call(void 0, response).models;
+  } finally {
+    await closeQuietly(client);
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AbortError = _chunk4G2RKM2Hjs.AbortError; exports.AddMcpServerRequestParamsSchema = _chunk4G2RKM2Hjs.AddMcpServerRequestParamsSchema; exports.AddMcpServerRequestSchema = _chunk4G2RKM2Hjs.AddMcpServerRequestSchema; exports.AddMcpServerResponseSchema = _chunk4G2RKM2Hjs.AddMcpServerResponseSchema; exports.AddMcpServerResultSchema = _chunk4G2RKM2Hjs.AddMcpServerResultSchema; exports.AddUserMessageRequestParamsSchema = _chunk4G2RKM2Hjs.AddUserMessageRequestParamsSchema; exports.AddUserMessageRequestSchema = _chunk4G2RKM2Hjs.AddUserMessageRequestSchema; exports.AddUserMessageResponseSchema = _chunk4G2RKM2Hjs.AddUserMessageResponseSchema; exports.AddUserMessageResultSchema = _chunk4G2RKM2Hjs.AddUserMessageResultSchema; exports.ApplyPatchToolConfirmationDetailsSchema = _chunk4G2RKM2Hjs.ApplyPatchToolConfirmationDetailsSchema; exports.AskUserCollectedAnswerSchema = _chunk4G2RKM2Hjs.AskUserCollectedAnswerSchema; exports.AskUserConfirmationDetailsSchema = _chunk4G2RKM2Hjs.AskUserConfirmationDetailsSchema; exports.AskUserQuestionSchema = _chunk4G2RKM2Hjs.AskUserQuestionSchema; exports.AskUserRequestParamsSchema = _chunk4G2RKM2Hjs.AskUserRequestParamsSchema; exports.AskUserRequestSchema = _chunk4G2RKM2Hjs.AskUserRequestSchema; exports.AskUserResponseSchema = _chunk4G2RKM2Hjs.AskUserResponseSchema; exports.AskUserResultSchema = _chunk4G2RKM2Hjs.AskUserResultSchema; exports.AssistantTextCompleteNotificationSchema = _chunk4G2RKM2Hjs.AssistantTextCompleteNotificationSchema; exports.AssistantTextDeltaNotificationSchema = _chunk4G2RKM2Hjs.AssistantTextDeltaNotificationSchema; exports.AuthenticateMcpServerRequestParamsSchema = _chunk4G2RKM2Hjs.AuthenticateMcpServerRequestParamsSchema; exports.AuthenticateMcpServerRequestSchema = _chunk4G2RKM2Hjs.AuthenticateMcpServerRequestSchema; exports.AuthenticateMcpServerResponseSchema = _chunk4G2RKM2Hjs.AuthenticateMcpServerResponseSchema; exports.AuthenticateMcpServerResultSchema = _chunk4G2RKM2Hjs.AuthenticateMcpServerResultSchema; exports.AutonomyLevel = _chunk4G2RKM2Hjs.AutonomyLevel; exports.AvailableModelConfigSchema = _chunk4G2RKM2Hjs.AvailableModelConfigSchema; exports.Base64ImageSourceSchema = _chunk4G2RKM2Hjs.Base64ImageSourceSchema; exports.BaseNotificationSchema = _chunk4G2RKM2Hjs.BaseNotificationSchema; exports.BaseRequestSchema = _chunk4G2RKM2Hjs.BaseRequestSchema; exports.BaseResponseFailureSchema = _chunk4G2RKM2Hjs.BaseResponseFailureSchema; exports.BaseResponseSuccessSchema = _chunk4G2RKM2Hjs.BaseResponseSuccessSchema; exports.CLI_JSONRPC_CHILD_SPAWN_LATENCY_METRIC = CLI_JSONRPC_CHILD_SPAWN_LATENCY_METRIC; exports.COMPACTION_TIMEOUT = _chunk4G2RKM2Hjs.COMPACTION_TIMEOUT; exports.CancelMcpAuthRequestParamsSchema = _chunk4G2RKM2Hjs.CancelMcpAuthRequestParamsSchema; exports.CancelMcpAuthRequestSchema = _chunk4G2RKM2Hjs.CancelMcpAuthRequestSchema; exports.CancelMcpAuthResponseSchema = _chunk4G2RKM2Hjs.CancelMcpAuthResponseSchema; exports.CancelMcpAuthResultSchema = _chunk4G2RKM2Hjs.CancelMcpAuthResultSchema; exports.ChangeWorkingDirectoryRequestParamsSchema = _chunk4G2RKM2Hjs.ChangeWorkingDirectoryRequestParamsSchema; exports.ChangeWorkingDirectoryRequestSchema = _chunk4G2RKM2Hjs.ChangeWorkingDirectoryRequestSchema; exports.ChangeWorkingDirectoryResponseSchema = _chunk4G2RKM2Hjs.ChangeWorkingDirectoryResponseSchema; exports.ChangeWorkingDirectoryResultSchema = _chunk4G2RKM2Hjs.ChangeWorkingDirectoryResultSchema; exports.ClearMcpAuthRequestParamsSchema = _chunk4G2RKM2Hjs.ClearMcpAuthRequestParamsSchema; exports.ClearMcpAuthRequestSchema = _chunk4G2RKM2Hjs.ClearMcpAuthRequestSchema; exports.ClearMcpAuthResponseSchema = _chunk4G2RKM2Hjs.ClearMcpAuthResponseSchema; exports.ClearMcpAuthResultSchema = _chunk4G2RKM2Hjs.ClearMcpAuthResultSchema; exports.CliRequestOrNotificationSchema = _chunk4G2RKM2Hjs.CliRequestOrNotificationSchema; exports.ClientDestroyedError = _chunk4G2RKM2Hjs.ClientDestroyedError; exports.ClientRequestSchema = _chunk4G2RKM2Hjs.ClientRequestSchema; exports.ClientUiSurface = _chunk4G2RKM2Hjs.ClientUiSurface; exports.CloseSessionRequestParamsSchema = _chunk4G2RKM2Hjs.CloseSessionRequestParamsSchema; exports.CloseSessionRequestSchema = _chunk4G2RKM2Hjs.CloseSessionRequestSchema; exports.CloseSessionResponseSchema = _chunk4G2RKM2Hjs.CloseSessionResponseSchema; exports.CloseSessionResultSchema = _chunk4G2RKM2Hjs.CloseSessionResultSchema; exports.CompactSessionRequestParamsSchema = _chunk4G2RKM2Hjs.CompactSessionRequestParamsSchema; exports.CompactSessionRequestSchema = _chunk4G2RKM2Hjs.CompactSessionRequestSchema; exports.CompactSessionResponseSchema = _chunk4G2RKM2Hjs.CompactSessionResponseSchema; exports.CompactSessionResultSchema = _chunk4G2RKM2Hjs.CompactSessionResultSchema; exports.ComputeLimitExceededError = _chunk4G2RKM2Hjs.ComputeLimitExceededError; exports.ComputerConnectAttemptTrigger = _chunk4G2RKM2Hjs.ComputerConnectAttemptTrigger; exports.ComputerConnectStartType = _chunk4G2RKM2Hjs.ComputerConnectStartType; exports.ComputerListResponseSchema = _chunk4G2RKM2Hjs.ComputerListResponseSchema; exports.ComputerMetricSchema = _chunk4G2RKM2Hjs.ComputerMetricSchema; exports.ComputerMetricsResponseSchema = _chunk4G2RKM2Hjs.ComputerMetricsResponseSchema; exports.ComputerSchema = _chunk4G2RKM2Hjs.ComputerSchema; exports.ConcurrentStreamError = _chunk4G2RKM2Hjs.ConcurrentStreamError; exports.ConnectionClosedError = _chunk4G2RKM2Hjs.ConnectionClosedError; exports.ConnectionError = _chunk4G2RKM2Hjs.ConnectionError; exports.ConnectionFailureReason = _chunk4G2RKM2Hjs.ConnectionFailureReason; exports.ContentBlockSchema = _chunk4G2RKM2Hjs.ContentBlockSchema; exports.ContextBreakdownCategorySchema = _chunk4G2RKM2Hjs.ContextBreakdownCategorySchema; exports.ContextBreakdownResultSchema = _chunk4G2RKM2Hjs.GetContextBreakdownResultSchema; exports.ContextStatsAccuracy = _chunk4G2RKM2Hjs.ContextStatsAccuracy; exports.ContextStatsSchema = _chunk4G2RKM2Hjs.ContextStatsSchema; exports.CreateMessageNotificationSchema = _chunk4G2RKM2Hjs.CreateMessageNotificationSchema; exports.CreateToolConfirmationDetailsSchema = _chunk4G2RKM2Hjs.CreateToolConfirmationDetailsSchema; exports.DEFAULT_LOCAL_DAEMON_WS_URL = _chunk4G2RKM2Hjs.DEFAULT_LOCAL_DAEMON_WS_URL; exports.DEFAULT_REQUEST_TIMEOUT = _chunk4G2RKM2Hjs.DEFAULT_REQUEST_TIMEOUT; exports.DaemonAuthenticationMode = _chunk4G2RKM2Hjs.DaemonAuthenticationMode; exports.DaemonClient = _chunk4G2RKM2Hjs.DaemonClient; exports.DaemonClientMetaError = _chunk4G2RKM2Hjs.MetaError; exports.DaemonDroidEvent = _chunk4G2RKM2Hjs.DaemonDroidEvent; exports.DaemonRequestPermissionSchema = _chunk4G2RKM2Hjs.DaemonRequestPermissionSchema; exports.DaemonSessionController = _chunk4G2RKM2Hjs.DaemonSessionController; exports.DecompSessionType = _chunk4G2RKM2Hjs.DecompSessionType; exports.DiscoveredIssueSchema = _chunk4G2RKM2Hjs.DiscoveredIssueSchema; exports.DismissalRecordSchema = _chunk4G2RKM2Hjs.DismissalRecordSchema; exports.DismissalType = _chunk4G2RKM2Hjs.DismissalType; exports.DocumentBlockSchema = _chunk4G2RKM2Hjs.DocumentBlockSchema; exports.DocumentSourceSchema = _chunk4G2RKM2Hjs.DocumentSourceSchema; exports.DroidClient = DroidClient; exports.DroidClientError = _chunk4G2RKM2Hjs.DroidClientError; exports.DroidClientEvent = DroidClientEvent; exports.DroidClientMethod = _chunk4G2RKM2Hjs.DroidClientMethod; exports.DroidErrorType = _chunk4G2RKM2Hjs.DroidErrorType; exports.DroidEvent = _chunk4G2RKM2Hjs.DroidEvent; exports.DroidHookEventSchema = _chunk4G2RKM2Hjs.DroidHookEventSchema; exports.DroidHookExecutionResultSchema = _chunk4G2RKM2Hjs.DroidHookExecutionResultSchema; exports.DroidHookOutputSchema = _chunk4G2RKM2Hjs.DroidHookOutputSchema; exports.DroidHookSpecificOutputSchema = _chunk4G2RKM2Hjs.DroidHookSpecificOutputSchema; exports.DroidInteractionMode = _chunk4G2RKM2Hjs.DroidInteractionMode; exports.DroidMessageType = _chunk4G2RKM2Hjs.DroidMessageType; exports.DroidProcessManager = DroidProcessManager; exports.DroidProcessMode = DroidProcessMode; exports.DroidServerMethod = _chunk4G2RKM2Hjs.DroidServerMethod; exports.DroidSession = DroidSession; exports.DroidWorkingState = _chunk4G2RKM2Hjs.DroidWorkingState; exports.DroidWorkingStateChangedNotificationSchema = _chunk4G2RKM2Hjs.DroidWorkingStateChangedNotificationSchema; exports.EditToolConfirmationDetailsSchema = _chunk4G2RKM2Hjs.EditToolConfirmationDetailsSchema; exports.EmptyResultSchema = _chunk4G2RKM2Hjs.EmptyResultSchema; exports.ErrorDetailSchema = _chunk4G2RKM2Hjs.ErrorDetailSchema; exports.ErrorNotificationSchema = _chunk4G2RKM2Hjs.ErrorNotificationSchema; exports.ExecToolInfoSchema = _chunk4G2RKM2Hjs.ExecToolInfoSchema; exports.ExecuteRewindRequestParamsSchema = _chunk4G2RKM2Hjs.ExecuteRewindRequestParamsSchema; exports.ExecuteRewindRequestSchema = _chunk4G2RKM2Hjs.ExecuteRewindRequestSchema; exports.ExecuteRewindResponseSchema = _chunk4G2RKM2Hjs.ExecuteRewindResponseSchema; exports.ExecuteRewindResultSchema = _chunk4G2RKM2Hjs.ExecuteRewindResultSchema; exports.ExecuteToolConfirmationDetailsSchema = _chunk4G2RKM2Hjs.ExecuteToolConfirmationDetailsSchema; exports.ExitSpecModeConfirmationDetailsSchema = _chunk4G2RKM2Hjs.ExitSpecModeConfirmationDetailsSchema; exports.FACTORY_CLIENT_HEADER = _chunk4G2RKM2Hjs.FACTORY_CLIENT_HEADER; exports.FACTORY_CLIENT_VERSION = _chunk4G2RKM2Hjs.FACTORY_CLIENT_VERSION; exports.FACTORY_PROTOCOL_VERSION = _chunk4G2RKM2Hjs.FACTORY_PROTOCOL_VERSION2; exports.FactoryDaemonTransport = _chunk4G2RKM2Hjs.FactoryDaemonTransport; exports.FactoryDroidMessageRole = _chunk4G2RKM2Hjs.FactoryDroidMessageRole; exports.FactoryDroidMessageSchema = _chunk4G2RKM2Hjs.FactoryDroidMessageSchema; exports.FeatureStatus = _chunk4G2RKM2Hjs.FeatureStatus; exports.FeatureSuccessState = _chunk4G2RKM2Hjs.FeatureSuccessState; exports.FeatureSuccessStateSchema = _chunk4G2RKM2Hjs.FeatureSuccessStateSchema; exports.ForkSessionRequestParamsSchema = _chunk4G2RKM2Hjs.ForkSessionRequestParamsSchema; exports.ForkSessionRequestSchema = _chunk4G2RKM2Hjs.ForkSessionRequestSchema; exports.ForkSessionResponseSchema = _chunk4G2RKM2Hjs.ForkSessionResponseSchema; exports.ForkSessionResultSchema = _chunk4G2RKM2Hjs.ForkSessionResultSchema; exports.GetContextStatsRequestParamsSchema = _chunk4G2RKM2Hjs.GetContextStatsRequestParamsSchema; exports.GetContextStatsRequestSchema = _chunk4G2RKM2Hjs.GetContextStatsRequestSchema; exports.GetContextStatsResponseSchema = _chunk4G2RKM2Hjs.GetContextStatsResponseSchema; exports.GetContextStatsResultSchema = _chunk4G2RKM2Hjs.ContextStatsSchema; exports.GetRewindInfoRequestParamsSchema = _chunk4G2RKM2Hjs.GetRewindInfoRequestParamsSchema; exports.GetRewindInfoRequestSchema = _chunk4G2RKM2Hjs.GetRewindInfoRequestSchema; exports.GetRewindInfoResponseSchema = _chunk4G2RKM2Hjs.GetRewindInfoResponseSchema; exports.GetRewindInfoResultSchema = _chunk4G2RKM2Hjs.GetRewindInfoResultSchema; exports.GitRepoInfoSchema = _chunk4G2RKM2Hjs.GitRepoInfoSchema; exports.HandoffItemsDismissedEntrySchema = _chunk4G2RKM2Hjs.HandoffItemsDismissedEntrySchema; exports.HandoffSchema = _chunk4G2RKM2Hjs.HandoffSchema; exports.HookCommandSchema = _chunk4G2RKM2Hjs.HookCommandSchema; exports.HookExecutionCompletedNotificationSchema = _chunk4G2RKM2Hjs.HookExecutionCompletedNotificationSchema; exports.HookExecutionStartedNotificationSchema = _chunk4G2RKM2Hjs.HookExecutionStartedNotificationSchema; exports.HookResultSchema = _chunk4G2RKM2Hjs.HookResultSchema; exports.HttpHeaderSchema = _chunk4G2RKM2Hjs.HttpHeaderSchema; exports.HttpMcpConfigSchema = _chunk4G2RKM2Hjs.HttpMcpSchema; exports.IPC_DAEMON_URL = _chunk4G2RKM2Hjs.IPC_DAEMON_URL; exports.ImageBlockSchema = _chunk4G2RKM2Hjs.ImageBlockSchema; exports.InProcessDaemonClientTransport = _chunk4G2RKM2Hjs.InProcessDaemonClientTransport; exports.InitializeSessionRequestParamsSchema = _chunk4G2RKM2Hjs.InitializeSessionRequestParamsSchema; exports.InitializeSessionRequestSchema = _chunk4G2RKM2Hjs.InitializeSessionRequestSchema; exports.InitializeSessionResponseSchema = _chunk4G2RKM2Hjs.InitializeSessionResponseSchema; exports.InitializeSessionResultSchema = _chunk4G2RKM2Hjs.InitializeSessionResultSchema2; exports.InteractiveCheckSchema = _chunk4G2RKM2Hjs.InteractiveCheckSchema; exports.InterruptSessionRequestParamsSchema = _chunk4G2RKM2Hjs.InterruptSessionRequestParamsSchema; exports.InterruptSessionRequestSchema = _chunk4G2RKM2Hjs.InterruptSessionRequestSchema; exports.InterruptSessionResponseSchema = _chunk4G2RKM2Hjs.InterruptSessionResponseSchema; exports.InterruptSessionResultSchema = _chunk4G2RKM2Hjs.InterruptSessionResultSchema; exports.InvalidSessionCwdError = _chunk4G2RKM2Hjs.InvalidSessionCwdError; exports.IpcDaemonClientTransport = _chunk4G2RKM2Hjs.IpcDaemonClientTransport; exports.IssueSeverity = _chunk4G2RKM2Hjs.IssueSeverity; exports.JSONRPC_VERSION = _chunk4G2RKM2Hjs.JSONRPC_VERSION3; exports.JsonArraySchema = _chunk4G2RKM2Hjs.JsonArraySchema; exports.JsonObjectSchema = _chunk4G2RKM2Hjs.JsonObjectSchema; exports.JsonRpcEnvelopeSchema = _chunk4G2RKM2Hjs.JsonRpcEnvelopeSchema; exports.JsonRpcErrorCode = _chunk4G2RKM2Hjs.JsonRpcErrorCode; exports.JsonRpcErrorSchema = _chunk4G2RKM2Hjs.JsonRpcErrorSchema; exports.JsonRpcMessageSchema = _chunk4G2RKM2Hjs.JsonRpcMessageSchema; exports.JsonRpcMessageType = _chunk4G2RKM2Hjs.JsonRpcMessageType; exports.JsonRpcNotificationSchema = _chunk4G2RKM2Hjs.JsonRpcNotificationSchema; exports.JsonRpcRequestError = _chunk4G2RKM2Hjs.JsonRpcRequestError; exports.JsonRpcRequestSchema = _chunk4G2RKM2Hjs.JsonRpcRequestSchema; exports.JsonRpcResponseFailureSchema = _chunk4G2RKM2Hjs.JsonRpcResponseFailureSchema; exports.JsonRpcResponseSchema = _chunk4G2RKM2Hjs.JsonRpcResponseSchema; exports.JsonRpcResponseSuccessSchema = _chunk4G2RKM2Hjs.JsonRpcResponseSuccessSchema; exports.JsonValueSchema = _chunk4G2RKM2Hjs.JsonValueSchema; exports.KillWorkerSessionRequestParamsSchema = _chunk4G2RKM2Hjs.KillWorkerSessionRequestParamsSchema; exports.KillWorkerSessionRequestSchema = _chunk4G2RKM2Hjs.KillWorkerSessionRequestSchema; exports.KillWorkerSessionResponseSchema = _chunk4G2RKM2Hjs.KillWorkerSessionResponseSchema; exports.KillWorkerSessionResultSchema = _chunk4G2RKM2Hjs.KillWorkerSessionResultSchema; exports.LEGACY_FACTORY_API_VERSION = _chunk4G2RKM2Hjs.LEGACY_FACTORY_API_VERSION2; exports.LOCAL_MACHINE_ID = _chunk4G2RKM2Hjs.LOCAL_MACHINE_ID; exports.ListMcpRegistryRequestParamsSchema = _chunk4G2RKM2Hjs.ListMcpRegistryRequestParamsSchema; exports.ListMcpRegistryRequestSchema = _chunk4G2RKM2Hjs.ListMcpRegistryRequestSchema; exports.ListMcpRegistryResponseSchema = _chunk4G2RKM2Hjs.ListMcpRegistryResponseSchema; exports.ListMcpRegistryResultSchema = _chunk4G2RKM2Hjs.ListMcpRegistryResultSchema; exports.ListMcpServersRequestParamsSchema = _chunk4G2RKM2Hjs.ListMcpServersRequestParamsSchema; exports.ListMcpServersRequestSchema = _chunk4G2RKM2Hjs.ListMcpServersRequestSchema; exports.ListMcpServersResponseSchema = _chunk4G2RKM2Hjs.ListMcpServersResponseSchema; exports.ListMcpServersResultSchema = _chunk4G2RKM2Hjs.ListMcpServersResultSchema; exports.ListMcpToolsRequestParamsSchema = _chunk4G2RKM2Hjs.ListMcpToolsRequestParamsSchema; exports.ListMcpToolsRequestSchema = _chunk4G2RKM2Hjs.ListMcpToolsRequestSchema; exports.ListMcpToolsResponseSchema = _chunk4G2RKM2Hjs.ListMcpToolsResponseSchema; exports.ListMcpToolsResultSchema = _chunk4G2RKM2Hjs.ListMcpToolsResultSchema; exports.ListModelsOptionsSchema = _chunk4G2RKM2Hjs.ListModelsOptionsSchema; exports.ListModelsResultSchema = _chunk4G2RKM2Hjs.ListModelsResultSchema; exports.ListSkillsRequestParamsSchema = _chunk4G2RKM2Hjs.ListSkillsRequestParamsSchema; exports.ListSkillsRequestSchema = _chunk4G2RKM2Hjs.ListSkillsRequestSchema; exports.ListSkillsResponseSchema = _chunk4G2RKM2Hjs.ListSkillsResponseSchema; exports.ListSkillsResultSchema = _chunk4G2RKM2Hjs.ListSkillsResultSchema; exports.ListToolsRequestParamsSchema = _chunk4G2RKM2Hjs.ListToolsRequestParamsSchema; exports.ListToolsRequestSchema = _chunk4G2RKM2Hjs.ListToolsRequestSchema; exports.ListToolsResponseSchema = _chunk4G2RKM2Hjs.ListToolsResponseSchema; exports.ListToolsResultSchema = _chunk4G2RKM2Hjs.ListToolsResultSchema; exports.LoadSessionRequestParamsSchema = _chunk4G2RKM2Hjs.LoadSessionRequestParamsSchema; exports.LoadSessionRequestSchema = _chunk4G2RKM2Hjs.LoadSessionRequestSchema; exports.LoadSessionResponseSchema = _chunk4G2RKM2Hjs.LoadSessionResponseSchema; exports.LoadSessionResultSchema = _chunk4G2RKM2Hjs.LoadSessionResultSchema; exports.MACHINE_TYPE_WEBSOCKET_OVERRIDES = _chunk4G2RKM2Hjs.MACHINE_TYPE_WEBSOCKET_OVERRIDES; exports.MANAGED_COMPUTER_MAX_RETRIES = _chunk4G2RKM2Hjs.MANAGED_COMPUTER_MAX_RETRIES; exports.MCP_AUTH_TIMEOUT = _chunk4G2RKM2Hjs.MCP_AUTH_TIMEOUT; exports.MachineTemplateBuildStatusSchema = _chunk4G2RKM2Hjs.MachineTemplateBuildStatusSchema; exports.MachineTemplateListResponseSchema = _chunk4G2RKM2Hjs.MachineTemplateListResponseSchema; exports.MachineTemplateSchema = _chunk4G2RKM2Hjs.MachineTemplateSchema; exports.MachineType = _chunk4G2RKM2Hjs.MachineType; exports.ManagedProcessImpl = ManagedProcessImpl; exports.McpAuthCompletedNotificationSchema = _chunk4G2RKM2Hjs.McpAuthCompletedNotificationSchema; exports.McpAuthOutcome = _chunk4G2RKM2Hjs.McpAuthOutcome; exports.McpAuthRequiredNotificationSchema = _chunk4G2RKM2Hjs.McpAuthRequiredNotificationSchema; exports.McpHttpServerConfigFieldsSchema = _chunk4G2RKM2Hjs.McpHttpServerConfigFieldsSchema; exports.McpRegistryServerSchema = _chunk4G2RKM2Hjs.McpRegistryServerSchema; exports.McpServerConfigSchema = _chunk4G2RKM2Hjs.McpServerConfigSchema; exports.McpServerStatus = _chunk4G2RKM2Hjs.McpServerStatus; exports.McpServerStatusInfoSchema = _chunk4G2RKM2Hjs.McpServerStatusInfoSchema; exports.McpServerType = _chunk4G2RKM2Hjs.McpServerType; exports.McpSseServerConfigFieldsSchema = _chunk4G2RKM2Hjs.McpSseServerConfigFieldsSchema; exports.McpStatus = _chunk4G2RKM2Hjs.McpStatus; exports.McpStatusChangedNotificationSchema = _chunk4G2RKM2Hjs.McpStatusChangedNotificationSchema; exports.McpStatusSummarySchema = _chunk4G2RKM2Hjs.McpStatusSummarySchema; exports.McpStdioServerConfigFieldsSchema = _chunk4G2RKM2Hjs.McpStdioServerConfigFieldsSchema; exports.McpToolConfirmationDetailsSchema = _chunk4G2RKM2Hjs.McpToolConfirmationDetailsSchema; exports.McpToolInfoSchema = _chunk4G2RKM2Hjs.McpToolInfoSchema; exports.McpToolInputSchemaSchema = _chunk4G2RKM2Hjs.McpToolInputSchemaSchema; exports.MessageVisibility = _chunk4G2RKM2Hjs.MessageVisibility; exports.Metric = _chunk4G2RKM2Hjs.Metric; exports.MilestoneValidationTriggeredEntrySchema = _chunk4G2RKM2Hjs.MilestoneValidationTriggeredEntrySchema; exports.MissionAcceptedEntrySchema = _chunk4G2RKM2Hjs.MissionAcceptedEntrySchema; exports.MissionFeatureSchema = _chunk4G2RKM2Hjs.MissionFeatureSchema; exports.MissionFeaturesChangedNotificationSchema = _chunk4G2RKM2Hjs.MissionFeaturesChangedNotificationSchema; exports.MissionHeartbeatNotificationSchema = _chunk4G2RKM2Hjs.MissionHeartbeatNotificationSchema; exports.MissionPausedEntrySchema = _chunk4G2RKM2Hjs.MissionPausedEntrySchema; exports.MissionProgressEntryNotificationSchema = _chunk4G2RKM2Hjs.MissionProgressEntryNotificationSchema; exports.MissionResumedEntrySchema = _chunk4G2RKM2Hjs.MissionResumedEntrySchema; exports.MissionRunStartedEntrySchema = _chunk4G2RKM2Hjs.MissionRunStartedEntrySchema; exports.MissionSnapshotSchema = _chunk4G2RKM2Hjs.MissionStateSchema; exports.MissionState = _chunk4G2RKM2Hjs.MissionState; exports.MissionStateChangedNotificationSchema = _chunk4G2RKM2Hjs.MissionStateChangedNotificationSchema; exports.MissionWorkerCompletedNotificationSchema = _chunk4G2RKM2Hjs.MissionWorkerCompletedNotificationSchema; exports.MissionWorkerStartedNotificationSchema = _chunk4G2RKM2Hjs.MissionWorkerStartedNotificationSchema; exports.ModelInfoSchema = _chunk4G2RKM2Hjs.ModelInfoSchema; exports.ModelMetadataSchema = _chunk4G2RKM2Hjs.ModelMetadataSchema; exports.ModelProvider = _chunk4G2RKM2Hjs.ModelProvider; exports.MultiMissionStateManager = _chunk4G2RKM2Hjs.MultiMissionStateManager; exports.MultiSessionStateManager = _chunk4G2RKM2Hjs.MultiSessionStateManager; exports.OtelTracing = _chunk4G2RKM2Hjs.OtelTracing; exports.OutputFormatSchema = _chunk4G2RKM2Hjs.OutputFormatSchema; exports.OutputFormatType = _chunk4G2RKM2Hjs.OutputFormatType; exports.PermissionResolvedNotificationSchema = _chunk4G2RKM2Hjs.PermissionResolvedNotificationSchema; exports.ProcessExitError = _chunk4G2RKM2Hjs.ProcessExitError; exports.ProcessTransport = ProcessTransport; exports.ProgressLogEntrySchema = _chunk4G2RKM2Hjs.ProgressLogEntrySchema; exports.ProgressLogEntryType = _chunk4G2RKM2Hjs.ProgressLogEntryType; exports.ProposeMissionConfirmationDetailsSchema = _chunk4G2RKM2Hjs.ProposeMissionConfirmationDetailsSchema; exports.ProtocolError = _chunk4G2RKM2Hjs.ProtocolError; exports.QueuedUserMessageDisplayGroup = _chunk4G2RKM2Hjs.QueuedUserMessageDisplayGroup; exports.QueuedUserMessageKind = _chunk4G2RKM2Hjs.QueuedUserMessageKind; exports.REWIND_TIMEOUT = _chunk4G2RKM2Hjs.REWIND_TIMEOUT; exports.ReasoningEffort = _chunk4G2RKM2Hjs.ReasoningEffort; exports.RedactedThinkingBlockSchema = _chunk4G2RKM2Hjs.RedactedThinkingBlockSchema; exports.RefreshComputerResponseSchema = _chunk4G2RKM2Hjs.RefreshComputerResponseSchema; exports.RelayConnectionError = _chunk4G2RKM2Hjs.RelayConnectionError; exports.RemoteSessionListResponseSchema = _chunk4G2RKM2Hjs.RemoteSessionListResponseSchema; exports.RemoteSessionSchema = _chunk4G2RKM2Hjs.RemoteSessionSchema; exports.RemoveMcpServerRequestParamsSchema = _chunk4G2RKM2Hjs.RemoveMcpServerRequestParamsSchema; exports.RemoveMcpServerRequestSchema = _chunk4G2RKM2Hjs.RemoveMcpServerRequestSchema; exports.RemoveMcpServerResponseSchema = _chunk4G2RKM2Hjs.RemoveMcpServerResponseSchema; exports.RemoveMcpServerResultSchema = _chunk4G2RKM2Hjs.RemoveMcpServerResultSchema; exports.RenameSessionRequestParamsSchema = _chunk4G2RKM2Hjs.RenameSessionRequestParamsSchema; exports.RenameSessionRequestSchema = _chunk4G2RKM2Hjs.RenameSessionRequestSchema; exports.RenameSessionResponseSchema = _chunk4G2RKM2Hjs.RenameSessionResponseSchema; exports.RenameSessionResultSchema = _chunk4G2RKM2Hjs.RenameSessionResultSchema; exports.RequestPermissionRequestParamsSchema = _chunk4G2RKM2Hjs.RequestPermissionRequestParamsSchema; exports.RequestPermissionRequestSchema = _chunk4G2RKM2Hjs.RequestPermissionRequestSchema; exports.RequestPermissionResponseSchema = _chunk4G2RKM2Hjs.RequestPermissionResponseSchema; exports.RequestPermissionResultSchema = _chunk4G2RKM2Hjs.RequestPermissionResultSchema; exports.RewindEvictedFileSchema = _chunk4G2RKM2Hjs.RewindEvictedFileSchema; exports.RewindFileCreationSchema = _chunk4G2RKM2Hjs.RewindFileCreationSchema; exports.RewindFileSnapshotSchema = _chunk4G2RKM2Hjs.RewindFileSnapshotSchema; exports.SDK_TAG = _chunk4G2RKM2Hjs.SDK_TAG; exports.SDK_VERSION = _chunk4G2RKM2Hjs.SDK_VERSION; exports.SESSION_INIT_TIMEOUT = _chunk4G2RKM2Hjs.SESSION_INIT_TIMEOUT; exports.SLACK_DELEGATION_MAX_RETRIES = _chunk4G2RKM2Hjs.SLACK_DELEGATION_MAX_RETRIES; exports.SdkMcpServer = SdkMcpServer; exports.ServerRequestHandlerType = _chunk4G2RKM2Hjs.ServerRequestHandlerType; exports.SessionError = _chunk4G2RKM2Hjs.SessionError; exports.SessionMetadataSchema = _chunk4G2RKM2Hjs.SessionMetadataSchema; exports.SessionNotFoundError = _chunk4G2RKM2Hjs.SessionNotFoundError; exports.SessionNotificationParamsSchema = _chunk4G2RKM2Hjs.SessionNotificationParamsSchema; exports.SessionNotificationPayloadSchema = _chunk4G2RKM2Hjs.SessionNotificationPayloadSchema; exports.SessionNotificationSchema = _chunk4G2RKM2Hjs.SessionNotificationSchema; exports.SessionNotificationSchemaList = _chunk4G2RKM2Hjs.SessionNotificationSchemaList; exports.SessionNotificationType = _chunk4G2RKM2Hjs.SessionNotificationType; exports.SessionPlatform = _chunk4G2RKM2Hjs.SessionPlatform; exports.SessionReplacedError = _chunk4G2RKM2Hjs.SessionReplacedError; exports.SessionReplacementError = _chunk4G2RKM2Hjs.SessionReplacementError; exports.SessionSettingsFileSchema = _chunk4G2RKM2Hjs.SessionSettingsFileSchema; exports.SessionSettingsSchema = _chunk4G2RKM2Hjs.SessionSettingsSchema; exports.SessionSourceSchema = _chunk4G2RKM2Hjs.SessionSourceSchema; exports.SessionStartEventSchema = _chunk4G2RKM2Hjs.SessionStartEventSchema; exports.SessionTagSchema = _chunk4G2RKM2Hjs.SessionTagSchema; exports.SessionTitleUpdatedNotificationSchema = _chunk4G2RKM2Hjs.SessionTitleUpdatedNotificationSchema; exports.SessionTokenUsageChangedNotificationSchema = _chunk4G2RKM2Hjs.SessionTokenUsageChangedNotificationSchema; exports.SetSkillDisabledRequestParamsSchema = _chunk4G2RKM2Hjs.SetSkillDisabledRequestParamsSchema; exports.SetSkillDisabledRequestSchema = _chunk4G2RKM2Hjs.SetSkillDisabledRequestSchema; exports.SetSkillDisabledResponseSchema = _chunk4G2RKM2Hjs.SetSkillDisabledResponseSchema; exports.SetSkillDisabledResultSchema = _chunk4G2RKM2Hjs.SetSkillDisabledResultSchema; exports.SettingsLevel = _chunk4G2RKM2Hjs.SettingsLevel; exports.SettingsUpdatedNotificationSchema = _chunk4G2RKM2Hjs.SettingsUpdatedNotificationSchema; exports.SettingsUpdatedPayloadSchema = _chunk4G2RKM2Hjs.SettingsUpdatedPayloadSchema; exports.SkillDeviationSchema = _chunk4G2RKM2Hjs.SkillDeviationSchema; exports.SkillFeedbackSchema = _chunk4G2RKM2Hjs.SkillFeedbackSchema; exports.SkillInfoSchema = _chunk4G2RKM2Hjs.SkillInfoSchema; exports.SkillLocation = _chunk4G2RKM2Hjs.SkillLocation; exports.SkillResourceSchema = _chunk4G2RKM2Hjs.SkillResourceSchema; exports.SpanAttribute = _chunk4G2RKM2Hjs.SpanAttribute; exports.SpanEvent = _chunk4G2RKM2Hjs.SpanEvent; exports.SpanName = _chunk4G2RKM2Hjs.SpanName; exports.SseMcpConfigSchema = _chunk4G2RKM2Hjs.SseMcpSchema; exports.StartMissionRunConfirmationDetailsSchema = _chunk4G2RKM2Hjs.StartMissionRunConfirmationDetailsSchema; exports.StdioMcpConfigSchema = _chunk4G2RKM2Hjs.StdioMcpSchema; exports.StreamStateTracker = _chunk4G2RKM2Hjs.StreamStateTracker; exports.StructuredOutputErrorSchema = _chunk4G2RKM2Hjs.StructuredOutputErrorSchema; exports.StructuredOutputNotificationSchema = _chunk4G2RKM2Hjs.StructuredOutputNotificationSchema; exports.SubmitBugReportRequestParamsSchema = _chunk4G2RKM2Hjs.SubmitBugReportRequestParamsSchema; exports.SubmitBugReportRequestSchema = _chunk4G2RKM2Hjs.SubmitBugReportRequestSchema; exports.SubmitBugReportResponseSchema = _chunk4G2RKM2Hjs.SubmitBugReportResponseSchema; exports.SubmitBugReportResultSchema = _chunk4G2RKM2Hjs.SubmitBugReportResultSchema; exports.SubmitMcpAuthCodeRequestParamsSchema = _chunk4G2RKM2Hjs.SubmitMcpAuthCodeRequestParamsSchema; exports.SubmitMcpAuthCodeRequestSchema = _chunk4G2RKM2Hjs.SubmitMcpAuthCodeRequestSchema; exports.SubmitMcpAuthCodeResponseSchema = _chunk4G2RKM2Hjs.SubmitMcpAuthCodeResponseSchema; exports.SubmitMcpAuthCodeResultSchema = _chunk4G2RKM2Hjs.SubmitMcpAuthCodeResultSchema; exports.SuccessResultSchema = _chunk4G2RKM2Hjs.SuccessResultSchema; exports.TestCaseSchema = _chunk4G2RKM2Hjs.TestCaseSchema; exports.TestFileSchema = _chunk4G2RKM2Hjs.TestFileSchema; exports.TestsSchema = _chunk4G2RKM2Hjs.TestsSchema; exports.TextBlockSchema = _chunk4G2RKM2Hjs.TextBlockSchema; exports.ThinkingBlockSchema = _chunk4G2RKM2Hjs.ThinkingBlockSchema; exports.ThinkingTextCompleteNotificationSchema = _chunk4G2RKM2Hjs.ThinkingTextCompleteNotificationSchema; exports.ThinkingTextDeltaNotificationSchema = _chunk4G2RKM2Hjs.ThinkingTextDeltaNotificationSchema; exports.TimeoutError = _chunk4G2RKM2Hjs.TimeoutError; exports.ToggleMcpServerRequestParamsSchema = _chunk4G2RKM2Hjs.ToggleMcpServerRequestParamsSchema; exports.ToggleMcpServerRequestSchema = _chunk4G2RKM2Hjs.ToggleMcpServerRequestSchema; exports.ToggleMcpServerResponseSchema = _chunk4G2RKM2Hjs.ToggleMcpServerResponseSchema; exports.ToggleMcpServerResultSchema = _chunk4G2RKM2Hjs.ToggleMcpServerResultSchema; exports.ToggleMcpToolRequestParamsSchema = _chunk4G2RKM2Hjs.ToggleMcpToolRequestParamsSchema; exports.ToggleMcpToolRequestSchema = _chunk4G2RKM2Hjs.ToggleMcpToolRequestSchema; exports.ToggleMcpToolResponseSchema = _chunk4G2RKM2Hjs.ToggleMcpToolResponseSchema; exports.ToggleMcpToolResultSchema = _chunk4G2RKM2Hjs.ToggleMcpToolResultSchema; exports.TokenUsageSchema = _chunk4G2RKM2Hjs.TokenUsageSchema; exports.ToolCallNotificationSchema = _chunk4G2RKM2Hjs.ToolCallNotificationSchema; exports.ToolConfirmationDetailsSchema = _chunk4G2RKM2Hjs.ToolConfirmationDetailsSchema; exports.ToolConfirmationInfoSchema = _chunk4G2RKM2Hjs.ToolConfirmationInfoSchema; exports.ToolConfirmationListItemSchema = _chunk4G2RKM2Hjs.ToolConfirmationListItemSchema; exports.ToolConfirmationOutcome = _chunk4G2RKM2Hjs.ToolConfirmationOutcome; exports.ToolConfirmationType = _chunk4G2RKM2Hjs.ToolConfirmationType; exports.ToolProgressUpdateNotificationSchema = _chunk4G2RKM2Hjs.ToolProgressUpdateNotificationSchema; exports.ToolProgressUpdateSchema = _chunk4G2RKM2Hjs.ToolProgressUpdateSchema; exports.ToolResultBlockSchema = _chunk4G2RKM2Hjs.ToolResultSchema; exports.ToolResultNotificationSchema = _chunk4G2RKM2Hjs.ToolResultNotificationSchema; exports.ToolSelectionOverridesSchema = _chunk4G2RKM2Hjs.ToolSelectionOverridesSchema; exports.ToolUseBlockSchema = _chunk4G2RKM2Hjs.ToolUseSchema; exports.ToolUseSchema = _chunk4G2RKM2Hjs.ToolUseSchema2; exports.TraceContextMetaSchema = _chunk4G2RKM2Hjs.TraceContextMetaSchema; exports.TransportDirection = TransportDirection; exports.TunnelConnection = _chunk4G2RKM2Hjs.TunnelConnection; exports.UpdateSessionSettingsRequestParamsSchema = _chunk4G2RKM2Hjs.UpdateSessionSettingsRequestParamsSchema; exports.UpdateSessionSettingsRequestSchema = _chunk4G2RKM2Hjs.UpdateSessionSettingsRequestSchema; exports.UpdateSessionSettingsResponseSchema = _chunk4G2RKM2Hjs.UpdateSessionSettingsResponseSchema; exports.UpdateSessionSettingsResultSchema = _chunk4G2RKM2Hjs.UpdateSessionSettingsResultSchema; exports.VerificationCommandSchema = _chunk4G2RKM2Hjs.VerificationCommandSchema; exports.VerificationSchema = _chunk4G2RKM2Hjs.VerificationSchema; exports.WINDOWS_JOB_OBJECT_ERROR_MARKER = WINDOWS_JOB_OBJECT_ERROR_MARKER; exports.WebSocketConnectionError = _chunk4G2RKM2Hjs.WebSocketConnectionError; exports.WebSocketDaemonTransport = _chunk4G2RKM2Hjs.WebSocketDaemonTransport; exports.WorkerCompletedEntrySchema = _chunk4G2RKM2Hjs.WorkerCompletedEntrySchema; exports.WorkerFailedEntrySchema = _chunk4G2RKM2Hjs.WorkerFailedEntrySchema; exports.WorkerPausedEntrySchema = _chunk4G2RKM2Hjs.WorkerPausedEntrySchema; exports.WorkerSelectedFeatureEntrySchema = _chunk4G2RKM2Hjs.WorkerSelectedFeatureEntrySchema; exports.WorkerStartedEntrySchema = _chunk4G2RKM2Hjs.WorkerStartedEntrySchema; exports.WorkerStateInfoSchema = _chunk4G2RKM2Hjs.WorkerStateInfoSchema; exports.__resetTransportLoggerForTests = __resetTransportLoggerForTests; exports.buildUserMessageContentBlocks = _chunk4G2RKM2Hjs.buildUserMessageContentBlocks; exports.configureDaemonCoreDeps = _chunk4G2RKM2Hjs.configureDaemonCoreDeps; exports.connectAndAuthenticate = _chunk4G2RKM2Hjs.connectAndAuthenticate; exports.connectToDaemon = _chunk4G2RKM2Hjs.connectToDaemon; exports.connectWithRetry = _chunk4G2RKM2Hjs.connectWithRetry; exports.convertNotificationToStreamMessage = _chunk4G2RKM2Hjs.convertNotificationToStreamMessage; exports.createComputer = _chunk4G2RKM2Hjs.createComputer; exports.createResponseSchema = _chunk4G2RKM2Hjs.createResponseSchema; exports.createSdkMcpServer = createSdkMcpServer; exports.createSession = createSession; exports.createWebSocketDaemonClient = _chunk4G2RKM2Hjs.createWebSocketDaemonClient; exports.defaultDaemonCoreDeps = _chunk4G2RKM2Hjs.defaultDaemonCoreDeps; exports.deleteComputer = _chunk4G2RKM2Hjs.deleteComputer; exports.filterMessagesForUI = _chunk4G2RKM2Hjs.filterMessagesForUI; exports.getComputer = _chunk4G2RKM2Hjs.getComputer; exports.getComputerByName = _chunk4G2RKM2Hjs.getComputerByName; exports.getComputerMetrics = _chunk4G2RKM2Hjs.getComputerMetrics; exports.getMachineTemplate = _chunk4G2RKM2Hjs.getMachineTemplate; exports.getPermissionToolInputForDisplay = _chunk4G2RKM2Hjs.getPermissionToolInputForDisplay; exports.getQueuedUserMessageDisplayGroup = _chunk4G2RKM2Hjs.getQueuedUserMessageDisplayGroup; exports.getQueuedUserMessageReviewPriority = _chunk4G2RKM2Hjs.getQueuedUserMessageReviewPriority; exports.getSubagentCallingMetadata = _chunk4G2RKM2Hjs.getSubagentCallingMetadata; exports.getToolResultBlocks = _chunk4G2RKM2Hjs.getToolResultBlocks; exports.getToolResultToolUseId = _chunk4G2RKM2Hjs.getToolResultToolUseId; exports.hasDecoupledInteractionSettings = _chunk4G2RKM2Hjs.hasDecoupledInteractionSettings; exports.hasSubagentSessionTag = _chunk4G2RKM2Hjs.hasSubagentSessionTag; exports.inspectJsonRpcEnvelope = _chunk4G2RKM2Hjs.inspectJsonRpcEnvelope; exports.isDaemonQueuedMessageKind = _chunk4G2RKM2Hjs.isDaemonQueuedMessageKind; exports.isPendingToolResultMarker = _chunk4G2RKM2Hjs.isPendingToolResultMarker; exports.isPersistedHookMessage = _chunk4G2RKM2Hjs.isPersistedHookMessage; exports.isReviewableQueuedMessageKind = _chunk4G2RKM2Hjs.isReviewableQueuedMessageKind; exports.isTransportLoggingEnabled = isTransportLoggingEnabled; exports.listComputers = _chunk4G2RKM2Hjs.listComputers; exports.listMachineTemplates = _chunk4G2RKM2Hjs.listMachineTemplates; exports.listModels = listModels; exports.listRemoteSessions = _chunk4G2RKM2Hjs.listRemoteSessions; exports.listSessions = listSessions; exports.logTransportMessage = logTransportMessage; exports.machineTypeToMachineConnectionType = _chunk4G2RKM2Hjs.machineTypeToMachineConnectionType; exports.noopLogger = noopLogger; exports.orderMessagesByParentChain = _chunk4G2RKM2Hjs.orderMessagesByParentChain; exports.recordComputerConnectSli = _chunk4G2RKM2Hjs.recordComputerConnectSli; exports.refreshComputer = _chunk4G2RKM2Hjs.refreshComputer; exports.repairParentChainCorruption = _chunk4G2RKM2Hjs.repairParentChainCorruption; exports.resolveExecCoreDeps = resolveExecCoreDeps; exports.restartComputer = _chunk4G2RKM2Hjs.restartComputer; exports.resumeSession = resumeSession; exports.retryInstallDeps = _chunk4G2RKM2Hjs.retryInstallDeps; exports.retryWithLogger = _chunk4G2RKM2Hjs.retryWithLogger; exports.run = run; exports.spawnWithWindowsJobObjectRetry = spawnWithWindowsJobObjectRetry; exports.sumTokenUsage = _chunk4G2RKM2Hjs.sumTokenUsage; exports.summarizeSessionToolUsage = _chunk4G2RKM2Hjs.summarizeSessionToolUsage; exports.toError = _chunk4G2RKM2Hjs.toError; exports.tool = tool; exports.updateComputer = _chunk4G2RKM2Hjs.updateComputer;
+//# sourceMappingURL=node.js.map