@factory/droid-sdk 0.6.0 → 0.8.0

package/dist/node.mjs

@@ -0,0 +1,4731 @@
+import {
+  AbortError,
+  AddMcpServerRequestParamsSchema,
+  AddMcpServerRequestSchema,
+  AddMcpServerResponseSchema,
+  AddMcpServerResultSchema,
+  AddUserMessageRequestParamsSchema,
+  AddUserMessageRequestSchema,
+  AddUserMessageResponseSchema,
+  AddUserMessageResultSchema,
+  AppendMessagesResponseSchema,
+  ApplyPatchToolConfirmationDetailsSchema,
+  AskUserCollectedAnswerSchema,
+  AskUserConfirmationDetailsSchema,
+  AskUserQuestionSchema,
+  AskUserRequestParamsSchema,
+  AskUserRequestSchema,
+  AskUserResponseSchema,
+  AskUserResultSchema,
+  AssistantTextCompleteNotificationSchema,
+  AssistantTextDeltaNotificationSchema,
+  AuthenticateMcpServerRequestParamsSchema,
+  AuthenticateMcpServerRequestSchema,
+  AuthenticateMcpServerResponseSchema,
+  AuthenticateMcpServerResultSchema,
+  AutonomyLevel,
+  AvailableModelConfigSchema,
+  Base64ImageSourceSchema,
+  BaseNotificationSchema,
+  BaseRequestSchema,
+  BaseResponseFailureSchema,
+  BaseResponseSuccessSchema,
+  COMPACTION_TIMEOUT,
+  CancelMcpAuthRequestParamsSchema,
+  CancelMcpAuthRequestSchema,
+  CancelMcpAuthResponseSchema,
+  CancelMcpAuthResultSchema,
+  ChangeWorkingDirectoryRequestParamsSchema,
+  ChangeWorkingDirectoryRequestSchema,
+  ChangeWorkingDirectoryResponseSchema,
+  ChangeWorkingDirectoryResultSchema,
+  ClearMcpAuthRequestParamsSchema,
+  ClearMcpAuthRequestSchema,
+  ClearMcpAuthResponseSchema,
+  ClearMcpAuthResultSchema,
+  CliRequestOrNotificationSchema,
+  ClientDestroyedError,
+  ClientRequestSchema,
+  ClientUiSurface,
+  CloseSessionRequestParamsSchema,
+  CloseSessionRequestSchema,
+  CloseSessionResponseSchema,
+  CloseSessionResultSchema,
+  CompactSessionRequestParamsSchema,
+  CompactSessionRequestSchema,
+  CompactSessionResponseSchema,
+  CompactSessionResultSchema,
+  ComputeLimitExceededError,
+  ComputerConnectAttemptTrigger,
+  ComputerConnectStartType,
+  ComputerListResponseSchema,
+  ComputerMetricSchema,
+  ComputerMetricsResponseSchema,
+  ComputerSchema,
+  ConcurrentStreamError,
+  ConnectionClosedError,
+  ConnectionError,
+  ConnectionFailureReason,
+  ContentBlockSchema,
+  ContextBreakdownCategorySchema,
+  ContextStatsAccuracy,
+  ContextStatsSchema,
+  CreateMessageNotificationSchema,
+  CreateToolConfirmationDetailsSchema,
+  DEFAULT_LOCAL_DAEMON_WS_URL,
+  DEFAULT_REQUEST_TIMEOUT,
+  DaemonAuthenticationMode,
+  DaemonClient,
+  DaemonDroidEvent,
+  DaemonRequestPermissionSchema,
+  DaemonSessionController,
+  DecompSessionType,
+  DiscoveredIssueSchema,
+  DismissalRecordSchema,
+  DismissalType,
+  DocumentBlockSchema,
+  DocumentSourceSchema,
+  DroidClientError,
+  DroidClientMethod,
+  DroidErrorType,
+  DroidEvent,
+  DroidHookEventSchema,
+  DroidHookExecutionResultSchema,
+  DroidHookOutputSchema,
+  DroidHookSpecificOutputSchema,
+  DroidInteractionMode,
+  DroidMessageType,
+  DroidServerMethod,
+  DroidWorkingState,
+  DroidWorkingStateChangedNotificationSchema,
+  EditToolConfirmationDetailsSchema,
+  EmptyResultSchema,
+  ErrorDetailSchema,
+  ErrorNotificationSchema,
+  ExecToolInfoSchema,
+  ExecuteRewindRequestParamsSchema,
+  ExecuteRewindRequestSchema,
+  ExecuteRewindResponseSchema,
+  ExecuteRewindResultSchema,
+  ExecuteToolConfirmationDetailsSchema,
+  ExitSpecModeConfirmationDetailsSchema,
+  FACTORY_CLIENT_HEADER,
+  FACTORY_CLIENT_VERSION,
+  FACTORY_PROTOCOL_VERSION,
+  FACTORY_PROTOCOL_VERSION2,
+  FactoryDaemonTransport,
+  FactoryDroidMessageRole,
+  FactoryDroidMessageSchema,
+  FeatureStatus,
+  FeatureSuccessState,
+  FeatureSuccessStateSchema,
+  ForkSessionRequestParamsSchema,
+  ForkSessionRequestSchema,
+  ForkSessionResponseSchema,
+  ForkSessionResultSchema,
+  GetContextBreakdownResponseSchema,
+  GetContextBreakdownResultSchema,
+  GetContextStatsRequestParamsSchema,
+  GetContextStatsRequestSchema,
+  GetContextStatsResponseSchema,
+  GetRewindInfoRequestParamsSchema,
+  GetRewindInfoRequestSchema,
+  GetRewindInfoResponseSchema,
+  GetRewindInfoResultSchema,
+  GitRepoInfoSchema,
+  HandoffItemsDismissedEntrySchema,
+  HandoffSchema,
+  HookCommandSchema,
+  HookExecutionCompletedNotificationSchema,
+  HookExecutionStartedNotificationSchema,
+  HookResultSchema,
+  HttpHeaderSchema,
+  HttpMcpSchema,
+  IPC_DAEMON_URL,
+  ImageBlockSchema,
+  InProcessDaemonClientTransport,
+  InitializeSessionRequestParamsSchema,
+  InitializeSessionRequestSchema,
+  InitializeSessionResponseSchema,
+  InitializeSessionResultSchema,
+  InitializeSessionResultSchema2,
+  InteractiveCheckSchema,
+  InterruptSessionRequestParamsSchema,
+  InterruptSessionRequestSchema,
+  InterruptSessionResponseSchema,
+  InterruptSessionResultSchema,
+  InvalidSessionCwdError,
+  IpcDaemonClientTransport,
+  IssueSeverity,
+  JSONRPC_VERSION,
+  JSONRPC_VERSION2,
+  JSONRPC_VERSION3,
+  JsonArraySchema,
+  JsonObjectSchema,
+  JsonRpcBaseResponseSchema,
+  JsonRpcEnvelopeSchema,
+  JsonRpcErrorCode,
+  JsonRpcErrorSchema,
+  JsonRpcMessageSchema,
+  JsonRpcMessageType,
+  JsonRpcNotificationSchema,
+  JsonRpcRequestError,
+  JsonRpcRequestSchema,
+  JsonRpcResponseFailureSchema,
+  JsonRpcResponseSchema,
+  JsonRpcResponseSuccessSchema,
+  JsonValueSchema,
+  KillWorkerSessionRequestParamsSchema,
+  KillWorkerSessionRequestSchema,
+  KillWorkerSessionResponseSchema,
+  KillWorkerSessionResultSchema,
+  LEGACY_FACTORY_API_VERSION,
+  LEGACY_FACTORY_API_VERSION2,
+  LOCAL_MACHINE_ID,
+  ListCommandsResponseSchema,
+  ListMcpRegistryRequestParamsSchema,
+  ListMcpRegistryRequestSchema,
+  ListMcpRegistryResponseSchema,
+  ListMcpRegistryResultSchema,
+  ListMcpServersRequestParamsSchema,
+  ListMcpServersRequestSchema,
+  ListMcpServersResponseSchema,
+  ListMcpServersResultSchema,
+  ListMcpToolsRequestParamsSchema,
+  ListMcpToolsRequestSchema,
+  ListMcpToolsResponseSchema,
+  ListMcpToolsResultSchema,
+  ListModelsOptionsSchema,
+  ListModelsResponseSchema,
+  ListModelsResultSchema,
+  ListSkillsRequestParamsSchema,
+  ListSkillsRequestSchema,
+  ListSkillsResponseSchema,
+  ListSkillsResultSchema,
+  ListToolsRequestParamsSchema,
+  ListToolsRequestSchema,
+  ListToolsResponseSchema,
+  ListToolsResultSchema,
+  LoadSessionRequestParamsSchema,
+  LoadSessionRequestSchema,
+  LoadSessionResponseSchema,
+  LoadSessionResultSchema,
+  MACHINE_TYPE_WEBSOCKET_OVERRIDES,
+  MANAGED_COMPUTER_MAX_RETRIES,
+  MCP_AUTH_TIMEOUT,
+  MachineTemplateBuildStatusSchema,
+  MachineTemplateListResponseSchema,
+  MachineTemplateSchema,
+  MachineType,
+  McpAuthCompletedNotificationSchema,
+  McpAuthOutcome,
+  McpAuthRequiredNotificationSchema,
+  McpHttpServerConfigFieldsSchema,
+  McpRegistryServerSchema,
+  McpServerConfigSchema,
+  McpServerStatus,
+  McpServerStatusInfoSchema,
+  McpServerType,
+  McpSseServerConfigFieldsSchema,
+  McpStatus,
+  McpStatusChangedNotificationSchema,
+  McpStatusSummarySchema,
+  McpStdioServerConfigFieldsSchema,
+  McpToolConfirmationDetailsSchema,
+  McpToolInfoSchema,
+  McpToolInputSchemaSchema,
+  MessageVisibility,
+  MetaError,
+  Metric,
+  MilestoneValidationTriggeredEntrySchema,
+  MissionAcceptedEntrySchema,
+  MissionFeatureSchema,
+  MissionFeaturesChangedNotificationSchema,
+  MissionHeartbeatNotificationSchema,
+  MissionPausedEntrySchema,
+  MissionProgressEntryNotificationSchema,
+  MissionResumedEntrySchema,
+  MissionRunStartedEntrySchema,
+  MissionState,
+  MissionStateChangedNotificationSchema,
+  MissionStateSchema,
+  MissionWorkerCompletedNotificationSchema,
+  MissionWorkerStartedNotificationSchema,
+  ModelInfoSchema,
+  ModelMetadataSchema,
+  ModelProvider,
+  MultiMissionStateManager,
+  MultiSessionStateManager,
+  OtelTracing,
+  OutputFormatSchema,
+  OutputFormatType,
+  PermissionResolvedNotificationSchema,
+  ProcessExitError,
+  ProgressLogEntrySchema,
+  ProgressLogEntryType,
+  ProposeMissionConfirmationDetailsSchema,
+  ProtocolError,
+  QueuedUserMessageDisplayGroup,
+  QueuedUserMessageKind,
+  REWIND_TIMEOUT,
+  ReasoningEffort,
+  RedactedThinkingBlockSchema,
+  RefreshComputerResponseSchema,
+  RelayConnectionError,
+  RemoteSessionListResponseSchema,
+  RemoteSessionSchema,
+  RemoveMcpServerRequestParamsSchema,
+  RemoveMcpServerRequestSchema,
+  RemoveMcpServerResponseSchema,
+  RemoveMcpServerResultSchema,
+  RenameSessionRequestParamsSchema,
+  RenameSessionRequestSchema,
+  RenameSessionResponseSchema,
+  RenameSessionResultSchema,
+  RequestPermissionRequestParamsSchema,
+  RequestPermissionRequestSchema,
+  RequestPermissionResponseSchema,
+  RequestPermissionResultSchema,
+  ResolveQueuedUserMessageResponseSchema,
+  RewindEvictedFileSchema,
+  RewindFileCreationSchema,
+  RewindFileSnapshotSchema,
+  SDK_TAG,
+  SDK_VERSION,
+  SESSION_INIT_TIMEOUT,
+  SLACK_DELEGATION_MAX_RETRIES,
+  ServerRequestHandlerType,
+  SessionError,
+  SessionMetadataSchema,
+  SessionNotFoundError,
+  SessionNotificationParamsSchema,
+  SessionNotificationPayloadSchema,
+  SessionNotificationSchema,
+  SessionNotificationSchemaList,
+  SessionNotificationType,
+  SessionPlatform,
+  SessionReplacedError,
+  SessionReplacementError,
+  SessionSettingsFileSchema,
+  SessionSettingsSchema,
+  SessionSourceSchema,
+  SessionStartDecompSessionTypeSchema,
+  SessionStartEventSchema,
+  SessionTagSchema,
+  SessionTitleUpdatedNotificationSchema,
+  SessionTokenUsageChangedNotificationSchema,
+  SetSkillDisabledRequestParamsSchema,
+  SetSkillDisabledRequestSchema,
+  SetSkillDisabledResponseSchema,
+  SetSkillDisabledResultSchema,
+  SettingsLevel,
+  SettingsUpdatedNotificationSchema,
+  SettingsUpdatedPayloadSchema,
+  SkillDeviationSchema,
+  SkillFeedbackSchema,
+  SkillInfoSchema,
+  SkillLocation,
+  SkillResourceSchema,
+  SpanAttribute,
+  SpanEvent,
+  SpanName,
+  SseMcpSchema,
+  StartMissionRunConfirmationDetailsSchema,
+  StdioMcpSchema,
+  StreamStateTracker,
+  StructuredOutputErrorSchema,
+  StructuredOutputNotificationSchema,
+  SubmitBugReportRequestParamsSchema,
+  SubmitBugReportRequestSchema,
+  SubmitBugReportResponseSchema,
+  SubmitBugReportResultSchema,
+  SubmitMcpAuthCodeRequestParamsSchema,
+  SubmitMcpAuthCodeRequestSchema,
+  SubmitMcpAuthCodeResponseSchema,
+  SubmitMcpAuthCodeResultSchema,
+  SubmitMcpAuthErrorResponseSchema,
+  SuccessResultSchema,
+  TestCaseSchema,
+  TestFileSchema,
+  TestsSchema,
+  TextBlockSchema,
+  ThinkingBlockSchema,
+  ThinkingTextCompleteNotificationSchema,
+  ThinkingTextDeltaNotificationSchema,
+  TimeoutError,
+  ToggleMcpServerRequestParamsSchema,
+  ToggleMcpServerRequestSchema,
+  ToggleMcpServerResponseSchema,
+  ToggleMcpServerResultSchema,
+  ToggleMcpToolRequestParamsSchema,
+  ToggleMcpToolRequestSchema,
+  ToggleMcpToolResponseSchema,
+  ToggleMcpToolResultSchema,
+  TokenUsageSchema,
+  ToolCallNotificationSchema,
+  ToolConfirmationDetailsSchema,
+  ToolConfirmationInfoSchema,
+  ToolConfirmationListItemSchema,
+  ToolConfirmationOutcome,
+  ToolConfirmationType,
+  ToolProgressUpdateNotificationSchema,
+  ToolProgressUpdateSchema,
+  ToolResultNotificationSchema,
+  ToolResultSchema,
+  ToolSelectionOverridesSchema,
+  ToolUseSchema,
+  ToolUseSchema2,
+  TraceContextMetaSchema,
+  TunnelConnection,
+  UpdateSessionSettingsRequestParamsSchema,
+  UpdateSessionSettingsRequestSchema,
+  UpdateSessionSettingsResponseSchema,
+  UpdateSessionSettingsResultSchema,
+  VerificationCommandSchema,
+  VerificationSchema,
+  WarmupCacheResponseSchema,
+  WebSocketConnectionError,
+  WebSocketDaemonTransport,
+  WorkerCompletedEntrySchema,
+  WorkerFailedEntrySchema,
+  WorkerPausedEntrySchema,
+  WorkerSelectedFeatureEntrySchema,
+  WorkerStartedEntrySchema,
+  WorkerStateInfoSchema,
+  buildUserMessageContentBlocks,
+  configureDaemonCoreDeps,
+  connectAndAuthenticate,
+  connectToDaemon,
+  connectWithRetry,
+  convertNotificationToStreamMessage,
+  createComputer,
+  createResponseSchema,
+  createWebSocketDaemonClient,
+  defaultDaemonCoreDeps,
+  deleteComputer,
+  extractInnerNotification,
+  filterMessagesForUI,
+  getComputer,
+  getComputerByName,
+  getComputerMetrics,
+  getMachineTemplate,
+  getPermissionToolInputForDisplay,
+  getQueuedUserMessageDisplayGroup,
+  getQueuedUserMessageReviewPriority,
+  getSubagentCallingMetadata,
+  getToolResultBlocks,
+  getToolResultToolUseId,
+  hasDecoupledInteractionSettings,
+  hasSubagentSessionTag,
+  inspectJsonRpcEnvelope,
+  isDaemonQueuedMessageKind,
+  isPendingToolResultMarker,
+  isPersistedHookMessage,
+  isReviewableQueuedMessageKind,
+  listComputers,
+  listMachineTemplates,
+  listRemoteSessions,
+  machineTypeToMachineConnectionType,
+  mergeSessionSettings,
+  orderMessagesByParentChain,
+  recordComputerConnectSli,
+  refreshComputer,
+  repairParentChainCorruption,
+  restartComputer,
+  retryInstallDeps,
+  retryWithLogger,
+  streamFromClient,
+  sumTokenUsage,
+  summarizeSessionToolUsage,
+  toError,
+  unwrapResponseResult,
+  updateComputer,
+  wireAbortSignal
+} from "./chunk-ROFAQUG4.mjs";
+
+// src/exec-core/client.ts
+import EventEmitter from "events";
+import { v4 as uuidv4 } from "uuid";
+import { z } from "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 globalThis.process?.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 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 {
+    options?.onError?.(error);
+  } catch {
+  }
+}
+function emitDroidLog(observability, event, options) {
+  const sink = observability?.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 = observability?.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 = observability?.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 redacted ?? metadata;
+}
+function createLogger(observability, fallback) {
+  const sink = observability?.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 = observability?.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 = observability?.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 = JsonRpcBaseResponseSchema.safeParse(response);
+  return parsed.success ? parsed.data.id : void 0;
+}
+var JsonRpcEnvelopePeekSchema = JsonRpcEnvelopeSchema.partial().extend({
+  type: z.nativeEnum(JsonRpcMessageType).optional(),
+  method: z.string().optional(),
+  id: 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 !== FACTORY_PROTOCOL_VERSION ? {
+      localFactoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      peerFactoryProtocolVersion: envelope.factoryProtocolVersion,
+      messageType: envelope.type,
+      method: envelope.method,
+      requestId: envelope.id
+    } : null
+  };
+}
+var DroidClient = class _DroidClient extends EventEmitter {
+  transport;
+  requestTimeout;
+  sessionInitTimeout;
+  pendingRequests = /* @__PURE__ */ new Map();
+  permissionHandlers = /* @__PURE__ */ new Map();
+  askUserHandlers = /* @__PURE__ */ new Map();
+  pendingPermissionRequests = /* @__PURE__ */ new Map();
+  pendingAskUserRequests = /* @__PURE__ */ new Map();
+  currentSessionId = null;
+  peerProtocolVersion;
+  /**
+   * Sticky error from a transport failure. Once set, all subsequent
+   * `sendRequest()` calls throw this error immediately, preventing
+   * requests from hanging on a dead transport.
+   */
+  transportError = null;
+  completedTurnObserved = false;
+  logger;
+  tracing;
+  onRequestSettled;
+  constructor(options, deps = defaultExecCoreDeps) {
+    super();
+    this.transport = options.transport;
+    const resolved = resolveExecCoreDeps(options.observability, deps);
+    this.logger = resolved.logger;
+    this.tracing = resolved.tracing;
+    this.requestTimeout = options.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT2;
+    this.sessionInitTimeout = 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 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 === FACTORY_PROTOCOL_VERSION) {
+      return;
+    }
+    throw new 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: FACTORY_PROTOCOL_VERSION,
+          peerFactoryProtocolVersion: this.peerProtocolVersion
+        }
+      }
+    );
+  }
+  validateMcpServersProtocolSupport(mcpServers) {
+    if (mcpServers?.some((server) => "oauth" in server && server.oauth === false)) {
+      this.requireMcpOAuthOptOutSupport();
+    }
+  }
+  async initializeSession(params) {
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.initialize_session" /* INITIALIZE_SESSION */,
+      params
+    };
+    const rawResponse = await this.sendRequest(
+      request,
+      this.sessionInitTimeout
+    );
+    const response = InitializeSessionResponseSchema.parse(rawResponse);
+    this.peerProtocolVersion = response.factoryProtocolVersion;
+    if (response.error) {
+      throw new 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 = InitializeSessionResultSchema.parse(response.result);
+    this.currentSessionId = result.sessionId;
+    return response;
+  }
+  async loadSession(params) {
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.load_session" /* LOAD_SESSION */,
+      params
+    };
+    const rawResponse = await this.sendRequest(
+      request,
+      this.sessionInitTimeout
+    );
+    const response = LoadSessionResponseSchema.parse(rawResponse);
+    this.peerProtocolVersion = response.factoryProtocolVersion;
+    if (response.error) {
+      const isSessionNotFound = response.error.code === -32004 /* ENTITY_NOT_FOUND */;
+      if (isSessionNotFound) {
+        throw new SessionNotFoundError(params.sessionId, {
+          requestId: request.id,
+          code: response.error.code,
+          message: response.error.message,
+          data: response.error.data
+        });
+      }
+      throw new 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 SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    this.completedTurnObserved = false;
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: requestId ?? uuidv4(),
+      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: params.queuePlacement ?? "end_of_turn" /* EndOfTurn */,
+        ...params.role && { role: params.role },
+        ...params.visibility && { visibility: params.visibility }
+      }
+    };
+    const rawResponse = await this.sendRequest(request);
+    const response = AddUserMessageResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new 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 SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: requestId ?? uuidv4(),
+      method: "droid.append_messages" /* APPEND_MESSAGES */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request);
+    const response = AppendMessagesResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new 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 SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.resolve_queued_user_message" /* RESOLVE_QUEUED_USER_MESSAGE */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = ResolveQueuedUserMessageResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new 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 SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.interrupt_session" /* INTERRUPT_SESSION */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = InterruptSessionResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new 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 SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.close_session" /* CLOSE_SESSION */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = CloseSessionResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new 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 SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.kill_worker_session" /* KILL_WORKER_SESSION */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = KillWorkerSessionResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new 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 SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: requestId ?? uuidv4(),
+      method: "droid.update_session_settings" /* UPDATE_SESSION_SETTINGS */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const responseParsed = UpdateSessionSettingsResponseSchema.safeParse(rawResponse);
+    if (!responseParsed.success) {
+      throw new 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 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 SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.change_working_directory" /* CHANGE_WORKING_DIRECTORY */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = ChangeWorkingDirectoryResponseSchema.parse(rawResponse);
+    if (response.error) {
+      throw new 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 SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      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 = ToggleMcpServerResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async authenticateMcpServer(params) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.authenticate_mcp_server" /* AUTHENTICATE_MCP_SERVER */,
+      params: {
+        serverName: params.serverName
+      }
+    };
+    const rawResponse = await this.sendRequest(request, MCP_AUTH_TIMEOUT2);
+    const response = AuthenticateMcpServerResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async cancelMcpAuth(params) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.cancel_mcp_auth" /* CANCEL_MCP_AUTH */,
+      params: {
+        serverName: params.serverName
+      }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = CancelMcpAuthResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async clearMcpAuth(params) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.clear_mcp_auth" /* CLEAR_MCP_AUTH */,
+      params: {
+        serverName: params.serverName
+      }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = ClearMcpAuthResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async addMcpServer(params) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    if (params.oauth === false) {
+      this.requireMcpOAuthOptOutSupport();
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.add_mcp_server" /* ADD_MCP_SERVER */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = AddMcpServerResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async removeMcpServer(params) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.remove_mcp_server" /* REMOVE_MCP_SERVER */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = RemoveMcpServerResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async listModels(params = {}) {
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.list_models" /* LIST_MODELS */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    return ListModelsResponseSchema.parse(rawResponse);
+  }
+  async listMcpRegistry() {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.list_mcp_registry" /* LIST_MCP_REGISTRY */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = ListMcpRegistryResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async listMcpTools() {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.list_mcp_tools" /* LIST_MCP_TOOLS */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = ListMcpToolsResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async listTools(params = {}) {
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.list_tools" /* LIST_TOOLS */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = ListToolsResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async listMcpServers() {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.list_mcp_servers" /* LIST_MCP_SERVERS */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = ListMcpServersResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async toggleMcpTool(serverName, toolName, enabled) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.toggle_mcp_tool" /* TOGGLE_MCP_TOOL */,
+      params: { serverName, toolName, enabled }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = ToggleMcpToolResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async submitMcpAuthCode(params) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.submit_mcp_auth_code" /* SUBMIT_MCP_AUTH_CODE */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = SubmitMcpAuthCodeResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async submitMcpAuthError(params) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.submit_mcp_auth_error" /* SUBMIT_MCP_AUTH_ERROR */,
+      params
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = SubmitMcpAuthErrorResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async listSkills() {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.list_skills" /* LIST_SKILLS */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = ListSkillsResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async setSkillDisabled(skillName, disabled, settingsLevel) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.set_skill_disabled" /* SET_SKILL_DISABLED */,
+      params: { skillName, disabled, settingsLevel }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    return SetSkillDisabledResponseSchema.parse(rawResponse);
+  }
+  async listCommands() {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.list_commands" /* LIST_COMMANDS */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = ListCommandsResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async getContextStats() {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.get_context_stats" /* GET_CONTEXT_STATS */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = GetContextStatsResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async getContextBreakdown() {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.get_context_breakdown" /* GET_CONTEXT_BREAKDOWN */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = GetContextBreakdownResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async submitBugReport(userComment, clientLogs, source) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.submit_bug_report" /* SUBMIT_BUG_REPORT */,
+      params: { userComment, clientLogs, source }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    const response = SubmitBugReportResponseSchema.parse(rawResponse);
+    return response;
+  }
+  async getRewindInfo(params, timeout = this.requestTimeout) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.get_rewind_info" /* GET_REWIND_INFO */,
+      params: {
+        sessionId: this.currentSessionId,
+        messageId: params.messageId
+      }
+    };
+    const rawResponse = await this.sendRequest(request, timeout);
+    return GetRewindInfoResponseSchema.parse(rawResponse);
+  }
+  async executeRewind(params) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      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 ExecuteRewindResponseSchema.parse(rawResponse);
+  }
+  async compactSession(params) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.compact_session" /* COMPACT_SESSION */,
+      params: {
+        customInstructions: params.customInstructions
+      }
+    };
+    const rawResponse = await this.sendRequest(request, COMPACTION_TIMEOUT2);
+    return CompactSessionResponseSchema.parse(rawResponse);
+  }
+  async forkSession(params) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.fork_session" /* FORK_SESSION */,
+      params: params ?? {}
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    return ForkSessionResponseSchema.parse(rawResponse);
+  }
+  async renameSession(params, requestId) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: requestId ?? uuidv4(),
+      method: "droid.rename_session" /* RENAME_SESSION */,
+      params: {
+        title: params.title
+      }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    return RenameSessionResponseSchema.parse(rawResponse);
+  }
+  async warmupCache() {
+    const response = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "response",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      result: {}
+    };
+    return WarmupCacheResponseSchema.parse(response);
+  }
+  onNotification(callback, filter) {
+    const handler = (notification) => {
+      if (filter?.type !== void 0 && filter.type !== notification.params.notification.type) {
+        return;
+      }
+      try {
+        callback(notification);
+      } catch {
+      }
+    };
+    this.on("session_notification" /* SESSION_NOTIFICATION */, handler);
+    return () => this.off("session_notification" /* SESSION_NOTIFICATION */, handler);
+  }
+  onError(callback) {
+    const handler = (error) => {
+      try {
+        callback(error);
+      } catch {
+      }
+    };
+    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 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 {
+      this.onRequestSettled?.(requestId);
+    } catch {
+    }
+  }
+  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 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 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 ProtocolError("Invalid message format", {
+          message
+        });
+      }
+    } catch {
+      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 = InitializeSessionResponseSchema.parse(response);
+              break;
+            case "droid.load_session" /* LOAD_SESSION */:
+              validatedResponse = LoadSessionResponseSchema.parse(response);
+              break;
+            case "droid.add_user_message" /* ADD_USER_MESSAGE */:
+              validatedResponse = AddUserMessageResponseSchema.parse(response);
+              break;
+            case "droid.append_messages" /* APPEND_MESSAGES */:
+              validatedResponse = AppendMessagesResponseSchema.parse(response);
+              break;
+            case "droid.resolve_queued_user_message" /* RESOLVE_QUEUED_USER_MESSAGE */:
+              validatedResponse = ResolveQueuedUserMessageResponseSchema.parse(response);
+              break;
+            case "droid.interrupt_session" /* INTERRUPT_SESSION */:
+              validatedResponse = InterruptSessionResponseSchema.parse(response);
+              break;
+            case "droid.close_session" /* CLOSE_SESSION */:
+              validatedResponse = CloseSessionResponseSchema.parse(response);
+              break;
+            case "droid.update_session_settings" /* UPDATE_SESSION_SETTINGS */:
+              validatedResponse = UpdateSessionSettingsResponseSchema.parse(response);
+              break;
+            case "droid.change_working_directory" /* CHANGE_WORKING_DIRECTORY */:
+              validatedResponse = ChangeWorkingDirectoryResponseSchema.parse(response);
+              break;
+            case "droid.toggle_mcp_server" /* TOGGLE_MCP_SERVER */:
+              validatedResponse = ToggleMcpServerResponseSchema.parse(response);
+              break;
+            case "droid.authenticate_mcp_server" /* AUTHENTICATE_MCP_SERVER */:
+              validatedResponse = AuthenticateMcpServerResponseSchema.parse(response);
+              break;
+            case "droid.cancel_mcp_auth" /* CANCEL_MCP_AUTH */:
+              validatedResponse = CancelMcpAuthResponseSchema.parse(response);
+              break;
+            case "droid.clear_mcp_auth" /* CLEAR_MCP_AUTH */:
+              validatedResponse = ClearMcpAuthResponseSchema.parse(response);
+              break;
+            case "droid.add_mcp_server" /* ADD_MCP_SERVER */:
+              validatedResponse = AddMcpServerResponseSchema.parse(response);
+              break;
+            case "droid.remove_mcp_server" /* REMOVE_MCP_SERVER */:
+              validatedResponse = RemoveMcpServerResponseSchema.parse(response);
+              break;
+            case "droid.list_models" /* LIST_MODELS */:
+              validatedResponse = ListModelsResponseSchema.parse(response);
+              break;
+            case "droid.list_mcp_registry" /* LIST_MCP_REGISTRY */:
+              validatedResponse = ListMcpRegistryResponseSchema.parse(response);
+              break;
+            case "droid.list_mcp_tools" /* LIST_MCP_TOOLS */:
+              validatedResponse = ListMcpToolsResponseSchema.parse(response);
+              break;
+            case "droid.list_tools" /* LIST_TOOLS */:
+              validatedResponse = ListToolsResponseSchema.parse(response);
+              break;
+            case "droid.toggle_mcp_tool" /* TOGGLE_MCP_TOOL */:
+              validatedResponse = ToggleMcpToolResponseSchema.parse(response);
+              break;
+            case "droid.submit_mcp_auth_code" /* SUBMIT_MCP_AUTH_CODE */:
+              validatedResponse = SubmitMcpAuthCodeResponseSchema.parse(response);
+              break;
+            case "droid.submit_mcp_auth_error" /* SUBMIT_MCP_AUTH_ERROR */:
+              validatedResponse = SubmitMcpAuthErrorResponseSchema.parse(response);
+              break;
+            case "droid.kill_worker_session" /* KILL_WORKER_SESSION */:
+              validatedResponse = KillWorkerSessionResponseSchema.parse(response);
+              break;
+            case "droid.list_skills" /* LIST_SKILLS */:
+              validatedResponse = ListSkillsResponseSchema.parse(response);
+              break;
+            case "droid.set_skill_disabled" /* SET_SKILL_DISABLED */:
+              validatedResponse = SetSkillDisabledResponseSchema.parse(response);
+              break;
+            case "droid.list_commands" /* LIST_COMMANDS */:
+              validatedResponse = ListCommandsResponseSchema.parse(response);
+              break;
+            case "droid.submit_bug_report" /* SUBMIT_BUG_REPORT */:
+              validatedResponse = SubmitBugReportResponseSchema.parse(response);
+              break;
+            case "droid.list_mcp_servers" /* LIST_MCP_SERVERS */:
+              validatedResponse = ListMcpServersResponseSchema.parse(response);
+              break;
+            case "droid.get_rewind_info" /* GET_REWIND_INFO */:
+              validatedResponse = GetRewindInfoResponseSchema.parse(response);
+              break;
+            case "droid.execute_rewind" /* EXECUTE_REWIND */:
+              validatedResponse = ExecuteRewindResponseSchema.parse(response);
+              break;
+            case "droid.compact_session" /* COMPACT_SESSION */:
+              validatedResponse = CompactSessionResponseSchema.parse(response);
+              break;
+            case "droid.fork_session" /* FORK_SESSION */:
+              validatedResponse = ForkSessionResponseSchema.parse(response);
+              break;
+            case "droid.rename_session" /* RENAME_SESSION */:
+              validatedResponse = RenameSessionResponseSchema.parse(response);
+              break;
+            case "droid.get_context_stats" /* GET_CONTEXT_STATS */:
+              validatedResponse = GetContextStatsResponseSchema.parse(response);
+              break;
+            case "droid.get_context_breakdown" /* GET_CONTEXT_BREAKDOWN */:
+              validatedResponse = GetContextBreakdownResponseSchema.parse(response);
+              break;
+            case "droid.warmup_cache" /* WARMUP_CACHE */:
+              validatedResponse = WarmupCacheResponseSchema.parse(response);
+              break;
+            default: {
+              const exhaustiveCheck = pending.method;
+              throw new DroidClientError(
+                "Unsupported method in response handler",
+                {
+                  method: exhaustiveCheck
+                }
+              );
+            }
+          }
+          if (pending.timeoutId) {
+            clearTimeout(pending.timeoutId);
+          }
+          this.settleRequest(responseId);
+          pending.resolve(validatedResponse);
+        } else {
+          const validatedResponse = JsonRpcBaseResponseSchema.parse(response);
+          this.logger.info(
+            "[DroidClient] Received response for request not in pending map",
+            {
+              requestId: 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 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: pending?.method,
+        requestId: responseId ?? void 0,
+        zodIssues
+      });
+      const err = error instanceof Error ? error : new Error(String(error));
+      const code = error instanceof 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: JSONRPC_VERSION2,
+        type: "response",
+        factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+        factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+        id: responseId,
+        error: {
+          code,
+          message,
+          data: err.message
+        }
+      };
+      pending.resolve(syntheticFailure);
+    }
+  }
+  async handleEvent(event) {
+    try {
+      const validatedEvent = 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 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: JSONRPC_VERSION2,
+      type: "response",
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: 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 = this.currentSessionId ?? _DroidClient.getNestedString(event, ["params", "sessionId"]);
+    const meta = {
+      value: {
+        method: method ?? void 0,
+        notificationType: notificationType ?? void 0,
+        protocolVersionMismatch: protocolVersionMismatch ?? void 0,
+        sessionId: 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 DroidClientError(
+            "Permission handler returned proceed_edit without editedSpecContent"
+          );
+        }
+        const parsedHandlerResult = 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 DroidClientError(
+            "Permission handler returned invalid result",
+            {
+              cause: parsedHandlerResult.error
+            }
+          );
+        }
+        if (!event.params.options.some(
+          (option) => option.value === selectedOption
+        )) {
+          throw new 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: JSONRPC_VERSION2,
+          factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+          factoryProtocolVersion: 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: JSONRPC_VERSION2,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: 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 = AskUserResultSchema.safeParse(
+          await handlerPromise
+        );
+        if (!parsedResult.success) {
+          throw new DroidClientError(
+            "AskUser handler returned invalid result",
+            {
+              cause: parsedResult.error
+            }
+          );
+        }
+        result = parsedResult.data;
+        this.logger.info("[DroidClient] Ask-user handler resolved", {
+          requestId: event.id,
+          cancelled: 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: JSONRPC_VERSION2,
+          factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+          factoryProtocolVersion: 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: JSONRPC_VERSION2,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      id: event.id,
+      result
+    };
+    this.logger.info("[DroidClient] Sending ask-user response back to CLI", {
+      requestId: event.id,
+      cancelled: result.cancelled ?? false
+    });
+    await this.transport.send(JSON.stringify(response));
+  }
+  static getErrorType(error) {
+    switch (error.constructor) {
+      case ConnectionError:
+        return "ConnectionError" /* CONNECTION_ERROR */;
+      case ProtocolError:
+        return "ProtocolError" /* PROTOCOL_ERROR */;
+      case SessionError:
+        return "SessionError" /* SESSION_ERROR */;
+      case TimeoutError:
+        return "TimeoutError" /* TIMEOUT_ERROR */;
+      case ProcessExitError:
+        return "ProcessExitError" /* PROCESS_EXIT_ERROR */;
+      case 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 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: JSONRPC_VERSION2,
+      type: "notification",
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      method: "droid.session_notification" /* SESSION_NOTIFICATION */,
+      params: { notification }
+    };
+  }
+};
+
+// src/exec-core/managed-process.ts
+import { spawnSync } from "child_process";
+import fs2 from "fs";
+import * as readline from "readline";
+
+// src/exec-core/runtime-utils.ts
+import { homedir } from "os";
+import { join } from "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 homedir();
+  }
+  if (filepath.startsWith("~/") || filepath.startsWith("~\\")) {
+    return join(homedir(), filepath.slice(2));
+  }
+  return filepath;
+}
+
+// src/exec-core/transport-logger.ts
+import fs from "fs";
+import path from "path";
+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(
+    deps.environmentResolver.resolveTransportLogEnvValue() ?? ""
+  );
+  return enabledCache;
+}
+function looksLikePath(value) {
+  return path.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 ? path.join(home, rest) : home;
+    }
+    return envValue;
+  }
+  return path.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 = path.dirname(logPath);
+    const logsDirExisted = fs.existsSync(logsDir);
+    if (!logsDirExisted) {
+      fs.mkdirSync(logsDir, { recursive: true, mode: LOG_DIR_MODE });
+    }
+    if (process.platform !== "win32" && !logsDirExisted) {
+      try {
+        fs.chmodSync(logsDir, LOG_DIR_MODE);
+      } catch (chmodError) {
+        logWarn(
+          deps.logger,
+          "[droid-sdk transport-logger] failed to chmod logs dir",
+          {
+            cause: chmodError
+          }
+        );
+      }
+    }
+    const stream = fs.createWriteStream(logPath, {
+      flags: "a",
+      encoding: "utf8",
+      mode: LOG_FILE_MODE
+    });
+    if (process.platform !== "win32") {
+      try {
+        fs.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=${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 = state?.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 (context?.cwd && !fs2.existsSync(context.cwd)) {
+      return `Failed to start Droid: working directory does not exist (${context.cwd})`;
+    }
+    return `Failed to start Droid: executable not found${context?.execPath ? ` (${context.execPath})` : ""}`;
+  }
+  if (error.code === "EACCES") {
+    return `Failed to start Droid: permission denied${context?.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 = class {
+  constructor(childProcess, logPrefix, spawnContext, deps, transportLoggerDeps = deps) {
+    this.logPrefix = logPrefix;
+    this.spawnContext = spawnContext;
+    this.transportLoggerDeps = transportLoggerDeps;
+    this._childProcess = childProcess;
+    this.logger = deps.logger;
+    this.setupHandlers();
+  }
+  logPrefix;
+  spawnContext;
+  transportLoggerDeps;
+  _childProcess;
+  messageHandler = null;
+  errorHandler = null;
+  readlineInterface = null;
+  isClosing = false;
+  /** Latch so exit teardown/classification runs exactly once per process. */
+  exitFinalized = false;
+  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.
+   */
+  processError = null;
+  queuedSendPromise = Promise.resolve();
+  logger;
+  get childProcess() {
+    if (!this._childProcess) {
+      throw new ConnectionError("Process not connected");
+    }
+    return this._childProcess;
+  }
+  setupHandlers() {
+    if (!this.childProcess.stdout) {
+      throw new 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,
+            this._childProcess?.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 ConnectionError(
+        describeSpawnError(error, this.spawnContext),
+        {
+          error,
+          cwd: this.spawnContext?.cwd,
+          execPath: this.spawnContext?.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);
+      this.exitDrainTimer.unref?.();
+    });
+    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 ProcessExitError(
+        describeExitError(code, signal),
+        {
+          exitCode: code ?? void 0,
+          signal: 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 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 ConnectionError("Process disconnected before write");
+      }
+      await new Promise((resolve2, reject) => {
+        try {
+          if (!this._childProcess || !this._childProcess.stdin) {
+            reject(new ConnectionError("Process stdin unavailable"));
+            return;
+          }
+          const stdin = this._childProcess.stdin;
+          if ("writable" in stdin && !stdin.writable) {
+            reject(new ConnectionError("Process stdin is not writable"));
+            return;
+          }
+          const childPid = this._childProcess?.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 ConnectionError("Process stdin closed during write", {
+                    error
+                  })
+                );
+              } else {
+                reject(
+                  new 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 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 = spawnSync(
+      "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);
+  }
+};
+
+// src/exec-core/process-manager.ts
+import { spawn } from "child_process";
+
+// 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;
+  };
+  childProcess.stderr?.on("data", stderrListener);
+  childProcess.once("exit", exitListener);
+  childProcess.once("error", errorListener);
+  const cleanup = () => {
+    childProcess.stderr?.off("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 = options.enabled ?? process.platform === "win32";
+  if (!enabled) {
+    return spawnFactory();
+  }
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const backoff = options.backoffMs ?? DEFAULT_BACKOFF_MS;
+  const gracePeriodMs = options.gracePeriodMs ?? DEFAULT_GRACE_PERIOD_MS;
+  const sleep = options.sleep ?? defaultSleep;
+  const logPrefix = options.logPrefix ?? "[spawnWithWindowsJobObjectRetry]";
+  const logger = 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 options.disposeEarlyExited?.(child);
+    } catch (disposeErr) {
+      logWarn(logger, "spawnWithWindowsJobObjectRetry: dispose error", {
+        cause: disposeErr instanceof Error ? disposeErr : new Error(String(disposeErr)),
+        name: logPrefix
+      });
+    }
+    await sleep(backoff[attempt] ?? backoff[backoff.length - 1] ?? 400);
+  }
+  if (lastChild) return lastChild;
+  throw new 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 {
+  deps;
+  transportLoggerDeps;
+  logger;
+  commandResolver;
+  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 {
+            child.stdin?.end();
+          } 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 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(
+      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: config.enableIpc ?? false,
+      stdio: config.stdio
+    };
+  }
+  invokeNodeSpawn(planned) {
+    const options = {
+      cwd: planned.expandedCwd,
+      env: planned.env,
+      stdio: planned.stdio ?? (planned.enableIpc ? ["pipe", "pipe", "pipe", "ipc"] : ["pipe", "pipe", "pipe"])
+    };
+    if (planned.enableIpc) {
+      options.serialization = "json";
+    }
+    return spawn(planned.execPath, planned.args, options);
+  }
+  spawnChildProcess(config) {
+    const planned = this.prepareSpawn(config);
+    const childProcess = this.invokeNodeSpawn(planned);
+    if (!childProcess.stdout || !childProcess.stdin) {
+      throw new 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 = class {
+  managedProcess = null;
+  processManager;
+  options;
+  // Store handlers that may be registered before connect() is called
+  messageHandler = null;
+  errorHandler = null;
+  metrics;
+  constructor(options = {}, deps = defaultExecCoreDeps) {
+    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 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 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 this.managedProcess?.isConnected ?? false;
+  }
+  getManagedProcess() {
+    return this.managedProcess;
+  }
+};
+
+// src/helpers.ts
+function resolveApiKey(apiKey) {
+  const resolved = apiKey ?? process.env.FACTORY_API_KEY;
+  if (!resolved) {
+    throw new 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 {
+  }
+}
+function buildInitParams(options) {
+  return {
+    machineId: options.machineId ?? "default",
+    cwd: 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: [...options.tags ?? [], SDK_TAG]
+  };
+}
+
+// src/mcp.ts
+import { randomBytes, timingSafeEqual } from "crypto";
+import { once } from "events";
+import http from "http";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z as z2 } from "zod";
+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 = z2.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: 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 && timingSafeEqual(actual, expected);
+}
+var SdkMcpServer = class {
+  name;
+  version;
+  tools;
+  _httpServer = null;
+  _url = null;
+  _token = null;
+  constructor(options) {
+    this.name = options.name;
+    this.version = 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 = randomBytes(32).toString("base64url");
+    this._httpServer = http.createServer((req, res) => {
+      void this.handleRequest(req, res);
+    });
+    this._httpServer.listen(0, "127.0.0.1");
+    await once(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;
+    }
+    server.closeAllConnections?.();
+    server.close();
+    await once(server, "close");
+  }
+  createMcpServer() {
+    const server = new 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 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();
+    }
+  }
+};
+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 = class _DroidSession {
+  /** @internal */
+  constructor(client, sessionId, metadata, _runtime, cleanupCallbacks = []) {
+    this._runtime = _runtime;
+    this._client = client;
+    this._sessionId = sessionId;
+    this._settings = metadata.settings;
+    this._cwd = metadata.cwd;
+    this._cleanupCallbacks = cleanupCallbacks;
+    this._bindMetadataNotifications();
+    this._bindAbortSignal();
+  }
+  _runtime;
+  _client;
+  _sessionId;
+  _settings;
+  _cwd;
+  _settingsRevision = 0;
+  _status = "active";
+  _replacementSessionId;
+  _cleanupAbortSignal = null;
+  _cleanupCallbacks = [];
+  _activeBridges = /* @__PURE__ */ new Set();
+  _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* streamFromClient(
+      {
+        onNotification: (handler) => this._client.onNotification((notification) => {
+          const inner = extractInnerNotification(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();
+    this._cleanupAbortSignal?.();
+    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 = unwrapResponseResult(
+      await this._client.updateSessionSettings(params)
+    );
+    if (params.disabledToolIds !== void 0) {
+      this._runtime.loadParams.disabledToolIds = params.disabledToolIds;
+    }
+    if (this._settingsRevision === revision) {
+      this._settings = mergeSessionSettings(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 unwrapResponseResult(await this._client.addMcpServer(params));
+  }
+  async removeMcpServer(params) {
+    this._ensureNotClosed();
+    return unwrapResponseResult(await this._client.removeMcpServer(params));
+  }
+  async toggleMcpServer(params) {
+    this._ensureNotClosed();
+    return unwrapResponseResult(await this._client.toggleMcpServer(params));
+  }
+  async listMcpServers() {
+    this._ensureNotClosed();
+    return unwrapResponseResult(await this._client.listMcpServers());
+  }
+  async listMcpTools() {
+    this._ensureNotClosed();
+    return unwrapResponseResult(await this._client.listMcpTools()).tools;
+  }
+  async listTools(params = {}) {
+    this._ensureNotClosed();
+    return unwrapResponseResult(await this._client.listTools(params)).tools.map(
+      ({ id: _protocolId, llmId, currentlyAllowed, ...tool2 }) => ({
+        ...tool2,
+        id: llmId,
+        allowed: currentlyAllowed
+      })
+    );
+  }
+  async authenticateMcpServer(params) {
+    this._ensureNotClosed();
+    return unwrapResponseResult(
+      await this._client.authenticateMcpServer(params)
+    );
+  }
+  async listSkills() {
+    this._ensureNotClosed();
+    return unwrapResponseResult(await this._client.listSkills());
+  }
+  async setSkillDisabled(params) {
+    this._ensureNotClosed();
+    return unwrapResponseResult(
+      await this._client.setSkillDisabled(
+        params.skillName,
+        params.disabled,
+        params.settingsLevel
+      )
+    );
+  }
+  async getRewindInfo(params) {
+    this._ensureNotClosed();
+    return unwrapResponseResult(await this._client.getRewindInfo(params));
+  }
+  async rewind(params) {
+    const { session, result } = await this._runReplacement(
+      () => this._client.executeRewind(params).then(unwrapResponseResult)
+    );
+    const { newSessionId: _newSessionId, ...metadata } = result;
+    return { session, ...metadata };
+  }
+  async compact(params) {
+    const { session, result } = await this._runReplacement(
+      () => this._client.compactSession(params ?? {}).then(unwrapResponseResult)
+    );
+    return { session, removedCount: result.removedCount };
+  }
+  async fork(params = {}) {
+    const { session } = await this._runReplacement(
+      () => this._client.forkSession(params).then(unwrapResponseResult)
+    );
+    return session;
+  }
+  async getContextStats() {
+    this._ensureNotClosed();
+    return unwrapResponseResult(await this._client.getContextStats());
+  }
+  async rename(params) {
+    this._ensureNotClosed();
+    unwrapResponseResult(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 SessionReplacedError(
+        this._sessionId,
+        this._replacementSessionId
+      );
+    }
+    if (this._status !== "active") {
+      throw new 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 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 SessionReplacementError(this._sessionId, result.newSessionId, {
+        cause: new ConnectionError(
+          "Session closed while replacement was in progress."
+        ),
+        rollbackError: new ConnectionError(
+          "The source session was already closed."
+        )
+      });
+    }
+    return {
+      session: await this._loadReplacement(result.newSessionId),
+      result
+    };
+  }
+  async _loadReplacement(replacementSessionId) {
+    try {
+      const loadResult = unwrapResponseResult(
+        await this._client.loadSession({
+          ...this._runtime.loadParams,
+          sessionId: replacementSessionId
+        })
+      );
+      if (this._status !== "replacing") {
+        throw new ConnectionError(
+          "Session closed while replacement was loading."
+        );
+      }
+      this._cleanupAbortSignal?.();
+      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 SessionReplacementError(
+          this._sessionId,
+          replacementSessionId,
+          {
+            cause,
+            rollbackError: new ConnectionError(
+              "The source session was closed before rollback."
+            )
+          }
+        );
+      }
+      let rollbackResult;
+      try {
+        rollbackResult = unwrapResponseResult(
+          await this._client.loadSession({
+            ...this._runtime.loadParams,
+            sessionId: this._sessionId
+          })
+        );
+      } catch (rollbackError) {
+        await this._disposeAfterFailedRollback();
+        throw new SessionReplacementError(
+          this._sessionId,
+          replacementSessionId,
+          { cause, rollbackError }
+        );
+      }
+      if (this._status !== "replacing") {
+        const rollbackError = new ConnectionError(
+          "Session closed while replacement rollback was loading."
+        );
+        await this._disposeAfterFailedRollback();
+        throw new SessionReplacementError(
+          this._sessionId,
+          replacementSessionId,
+          { cause, rollbackError }
+        );
+      }
+      this._settings = rollbackResult.settings;
+      this._cwd = rollbackResult.cwd;
+      this._status = "active";
+      throw new SessionReplacementError(this._sessionId, replacementSessionId, {
+        cause
+      });
+    }
+  }
+  _bindAbortSignal() {
+    this._cleanupAbortSignal = wireAbortSignal(
+      this._runtime.abortSignal,
+      () => void this.close()
+    );
+  }
+  _bindMetadataNotifications() {
+    const unsubscribe = this._client.onNotification((notification) => {
+      const inner = extractInnerNotification(notification);
+      if (inner?.type === "settings_updated" /* SETTINGS_UPDATED */) {
+        this._settings = mergeSessionSettings(this._settings, inner.settings);
+        this._settingsRevision++;
+      } else if (inner?.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";
+    this._cleanupAbortSignal?.();
+    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))
+    );
+  }
+};
+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 = options.abortSignal?.aborted ? () => {
+  } : wireAbortSignal(options.abortSignal, () => {
+    void closeQuietly(client);
+  });
+  let sdkMcpServers;
+  try {
+    sdkMcpServers = await startSdkMcpServers(options.mcpServers);
+    const initParams = buildInitParams({
+      ...options,
+      mcpServers: sdkMcpServers.mcpServers
+    });
+    const initResult = unwrapResponseResult(
+      await client.initializeSession(initParams)
+    );
+    const session = new DroidSession(
+      client,
+      initResult.sessionId,
+      {
+        settings: initResult.settings,
+        cwd: initResult.worktree?.path ?? initParams.cwd
+      },
+      {
+        abortSignal: options.abortSignal,
+        loadParams: createReplacementLoadParams(
+          options,
+          sdkMcpServers.mcpServers
+        )
+      },
+      [sdkMcpServers.cleanup]
+    );
+    cleanupInitAbortSignal();
+    cleanupInitAbortSignal = () => {
+    };
+    return session;
+  } catch (error) {
+    cleanupInitAbortSignal();
+    await sdkMcpServers?.cleanup();
+    await closeQuietly(client);
+    throw error;
+  }
+}
+async function resumeSession(sessionId, options = {}) {
+  const { client } = await createConfiguredClient(options);
+  let cleanupLoadAbortSignal = options.abortSignal?.aborted ? () => {
+  } : wireAbortSignal(options.abortSignal, () => {
+    void closeQuietly(client);
+  });
+  let sdkMcpServers;
+  try {
+    sdkMcpServers = await startSdkMcpServers(options.mcpServers);
+    const replacementLoadParams = createReplacementLoadParams(
+      options,
+      sdkMcpServers.mcpServers
+    );
+    const loadResult = unwrapResponseResult(
+      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 sdkMcpServers?.cleanup();
+    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 === DroidMessageType.Result) {
+        return msg;
+      }
+    }
+    throw new Error("Stream completed without a result message");
+  } finally {
+    await session.close();
+  }
+}
+
+// src/session-discovery.ts
+import * as fs3 from "fs";
+import * as os from "os";
+import * as path2 from "path";
+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 {
+    return null;
+  }
+}
+function parseJsonBuffer(buf) {
+  try {
+    return JSON.parse(buf.toString("utf-8"));
+  } catch {
+    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 = SessionSettingsFileSchema.safeParse(parsed);
+  return result.success ? result.data : null;
+}
+function getMissionMetadataFromTags(settings) {
+  if (!settings?.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: missionTag?.metadata?.[MISSION_ID_METADATA_KEY],
+    decompSessionType: roleTag?.metadata?.[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 = 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 (settings?.archivedAt) return null;
+  const tagMeta = getMissionMetadataFromTags(settings);
+  const decompSessionType = summary.decompSessionType ?? SessionStartDecompSessionTypeSchema.safeParse(tagMeta.decompSessionType).data;
+  const messageCount = Math.max(0, scanned.nonEmptyLineCount - 1);
+  return {
+    id: candidate.sessionId,
+    title: summary.title,
+    owner: 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: tagMeta.decompMissionId ?? summary.decompMissionId
+  };
+}
+function readDirEntries(directory) {
+  try {
+    return fs3.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    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 {
+      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 {
+    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 = 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(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 unwrapResponseResult(response).models;
+  } finally {
+    await closeQuietly(client);
+  }
+}
+export {
+  AbortError,
+  AddMcpServerRequestParamsSchema,
+  AddMcpServerRequestSchema,
+  AddMcpServerResponseSchema,
+  AddMcpServerResultSchema,
+  AddUserMessageRequestParamsSchema,
+  AddUserMessageRequestSchema,
+  AddUserMessageResponseSchema,
+  AddUserMessageResultSchema,
+  ApplyPatchToolConfirmationDetailsSchema,
+  AskUserCollectedAnswerSchema,
+  AskUserConfirmationDetailsSchema,
+  AskUserQuestionSchema,
+  AskUserRequestParamsSchema,
+  AskUserRequestSchema,
+  AskUserResponseSchema,
+  AskUserResultSchema,
+  AssistantTextCompleteNotificationSchema,
+  AssistantTextDeltaNotificationSchema,
+  AuthenticateMcpServerRequestParamsSchema,
+  AuthenticateMcpServerRequestSchema,
+  AuthenticateMcpServerResponseSchema,
+  AuthenticateMcpServerResultSchema,
+  AutonomyLevel,
+  AvailableModelConfigSchema,
+  Base64ImageSourceSchema,
+  BaseNotificationSchema,
+  BaseRequestSchema,
+  BaseResponseFailureSchema,
+  BaseResponseSuccessSchema,
+  CLI_JSONRPC_CHILD_SPAWN_LATENCY_METRIC,
+  COMPACTION_TIMEOUT,
+  CancelMcpAuthRequestParamsSchema,
+  CancelMcpAuthRequestSchema,
+  CancelMcpAuthResponseSchema,
+  CancelMcpAuthResultSchema,
+  ChangeWorkingDirectoryRequestParamsSchema,
+  ChangeWorkingDirectoryRequestSchema,
+  ChangeWorkingDirectoryResponseSchema,
+  ChangeWorkingDirectoryResultSchema,
+  ClearMcpAuthRequestParamsSchema,
+  ClearMcpAuthRequestSchema,
+  ClearMcpAuthResponseSchema,
+  ClearMcpAuthResultSchema,
+  CliRequestOrNotificationSchema,
+  ClientDestroyedError,
+  ClientRequestSchema,
+  ClientUiSurface,
+  CloseSessionRequestParamsSchema,
+  CloseSessionRequestSchema,
+  CloseSessionResponseSchema,
+  CloseSessionResultSchema,
+  CompactSessionRequestParamsSchema,
+  CompactSessionRequestSchema,
+  CompactSessionResponseSchema,
+  CompactSessionResultSchema,
+  ComputeLimitExceededError,
+  ComputerConnectAttemptTrigger,
+  ComputerConnectStartType,
+  ComputerListResponseSchema,
+  ComputerMetricSchema,
+  ComputerMetricsResponseSchema,
+  ComputerSchema,
+  ConcurrentStreamError,
+  ConnectionClosedError,
+  ConnectionError,
+  ConnectionFailureReason,
+  ContentBlockSchema,
+  ContextBreakdownCategorySchema,
+  GetContextBreakdownResultSchema as ContextBreakdownResultSchema,
+  ContextStatsAccuracy,
+  ContextStatsSchema,
+  CreateMessageNotificationSchema,
+  CreateToolConfirmationDetailsSchema,
+  DEFAULT_LOCAL_DAEMON_WS_URL,
+  DEFAULT_REQUEST_TIMEOUT,
+  DaemonAuthenticationMode,
+  DaemonClient,
+  MetaError as DaemonClientMetaError,
+  DaemonDroidEvent,
+  DaemonRequestPermissionSchema,
+  DaemonSessionController,
+  DecompSessionType,
+  DiscoveredIssueSchema,
+  DismissalRecordSchema,
+  DismissalType,
+  DocumentBlockSchema,
+  DocumentSourceSchema,
+  DroidClient,
+  DroidClientError,
+  DroidClientEvent,
+  DroidClientMethod,
+  DroidErrorType,
+  DroidEvent,
+  DroidHookEventSchema,
+  DroidHookExecutionResultSchema,
+  DroidHookOutputSchema,
+  DroidHookSpecificOutputSchema,
+  DroidInteractionMode,
+  DroidMessageType,
+  DroidProcessManager,
+  DroidProcessMode,
+  DroidServerMethod,
+  DroidSession,
+  DroidWorkingState,
+  DroidWorkingStateChangedNotificationSchema,
+  EditToolConfirmationDetailsSchema,
+  EmptyResultSchema,
+  ErrorDetailSchema,
+  ErrorNotificationSchema,
+  ExecToolInfoSchema,
+  ExecuteRewindRequestParamsSchema,
+  ExecuteRewindRequestSchema,
+  ExecuteRewindResponseSchema,
+  ExecuteRewindResultSchema,
+  ExecuteToolConfirmationDetailsSchema,
+  ExitSpecModeConfirmationDetailsSchema,
+  FACTORY_CLIENT_HEADER,
+  FACTORY_CLIENT_VERSION,
+  FACTORY_PROTOCOL_VERSION2 as FACTORY_PROTOCOL_VERSION,
+  FactoryDaemonTransport,
+  FactoryDroidMessageRole,
+  FactoryDroidMessageSchema,
+  FeatureStatus,
+  FeatureSuccessState,
+  FeatureSuccessStateSchema,
+  ForkSessionRequestParamsSchema,
+  ForkSessionRequestSchema,
+  ForkSessionResponseSchema,
+  ForkSessionResultSchema,
+  GetContextStatsRequestParamsSchema,
+  GetContextStatsRequestSchema,
+  GetContextStatsResponseSchema,
+  ContextStatsSchema as GetContextStatsResultSchema,
+  GetRewindInfoRequestParamsSchema,
+  GetRewindInfoRequestSchema,
+  GetRewindInfoResponseSchema,
+  GetRewindInfoResultSchema,
+  GitRepoInfoSchema,
+  HandoffItemsDismissedEntrySchema,
+  HandoffSchema,
+  HookCommandSchema,
+  HookExecutionCompletedNotificationSchema,
+  HookExecutionStartedNotificationSchema,
+  HookResultSchema,
+  HttpHeaderSchema,
+  HttpMcpSchema as HttpMcpConfigSchema,
+  IPC_DAEMON_URL,
+  ImageBlockSchema,
+  InProcessDaemonClientTransport,
+  InitializeSessionRequestParamsSchema,
+  InitializeSessionRequestSchema,
+  InitializeSessionResponseSchema,
+  InitializeSessionResultSchema2 as InitializeSessionResultSchema,
+  InteractiveCheckSchema,
+  InterruptSessionRequestParamsSchema,
+  InterruptSessionRequestSchema,
+  InterruptSessionResponseSchema,
+  InterruptSessionResultSchema,
+  InvalidSessionCwdError,
+  IpcDaemonClientTransport,
+  IssueSeverity,
+  JSONRPC_VERSION3 as JSONRPC_VERSION,
+  JsonArraySchema,
+  JsonObjectSchema,
+  JsonRpcEnvelopeSchema,
+  JsonRpcErrorCode,
+  JsonRpcErrorSchema,
+  JsonRpcMessageSchema,
+  JsonRpcMessageType,
+  JsonRpcNotificationSchema,
+  JsonRpcRequestError,
+  JsonRpcRequestSchema,
+  JsonRpcResponseFailureSchema,
+  JsonRpcResponseSchema,
+  JsonRpcResponseSuccessSchema,
+  JsonValueSchema,
+  KillWorkerSessionRequestParamsSchema,
+  KillWorkerSessionRequestSchema,
+  KillWorkerSessionResponseSchema,
+  KillWorkerSessionResultSchema,
+  LEGACY_FACTORY_API_VERSION2 as LEGACY_FACTORY_API_VERSION,
+  LOCAL_MACHINE_ID,
+  ListMcpRegistryRequestParamsSchema,
+  ListMcpRegistryRequestSchema,
+  ListMcpRegistryResponseSchema,
+  ListMcpRegistryResultSchema,
+  ListMcpServersRequestParamsSchema,
+  ListMcpServersRequestSchema,
+  ListMcpServersResponseSchema,
+  ListMcpServersResultSchema,
+  ListMcpToolsRequestParamsSchema,
+  ListMcpToolsRequestSchema,
+  ListMcpToolsResponseSchema,
+  ListMcpToolsResultSchema,
+  ListModelsOptionsSchema,
+  ListModelsResultSchema,
+  ListSkillsRequestParamsSchema,
+  ListSkillsRequestSchema,
+  ListSkillsResponseSchema,
+  ListSkillsResultSchema,
+  ListToolsRequestParamsSchema,
+  ListToolsRequestSchema,
+  ListToolsResponseSchema,
+  ListToolsResultSchema,
+  LoadSessionRequestParamsSchema,
+  LoadSessionRequestSchema,
+  LoadSessionResponseSchema,
+  LoadSessionResultSchema,
+  MACHINE_TYPE_WEBSOCKET_OVERRIDES,
+  MANAGED_COMPUTER_MAX_RETRIES,
+  MCP_AUTH_TIMEOUT,
+  MachineTemplateBuildStatusSchema,
+  MachineTemplateListResponseSchema,
+  MachineTemplateSchema,
+  MachineType,
+  ManagedProcessImpl,
+  McpAuthCompletedNotificationSchema,
+  McpAuthOutcome,
+  McpAuthRequiredNotificationSchema,
+  McpHttpServerConfigFieldsSchema,
+  McpRegistryServerSchema,
+  McpServerConfigSchema,
+  McpServerStatus,
+  McpServerStatusInfoSchema,
+  McpServerType,
+  McpSseServerConfigFieldsSchema,
+  McpStatus,
+  McpStatusChangedNotificationSchema,
+  McpStatusSummarySchema,
+  McpStdioServerConfigFieldsSchema,
+  McpToolConfirmationDetailsSchema,
+  McpToolInfoSchema,
+  McpToolInputSchemaSchema,
+  MessageVisibility,
+  Metric,
+  MilestoneValidationTriggeredEntrySchema,
+  MissionAcceptedEntrySchema,
+  MissionFeatureSchema,
+  MissionFeaturesChangedNotificationSchema,
+  MissionHeartbeatNotificationSchema,
+  MissionPausedEntrySchema,
+  MissionProgressEntryNotificationSchema,
+  MissionResumedEntrySchema,
+  MissionRunStartedEntrySchema,
+  MissionStateSchema as MissionSnapshotSchema,
+  MissionState,
+  MissionStateChangedNotificationSchema,
+  MissionWorkerCompletedNotificationSchema,
+  MissionWorkerStartedNotificationSchema,
+  ModelInfoSchema,
+  ModelMetadataSchema,
+  ModelProvider,
+  MultiMissionStateManager,
+  MultiSessionStateManager,
+  OtelTracing,
+  OutputFormatSchema,
+  OutputFormatType,
+  PermissionResolvedNotificationSchema,
+  ProcessExitError,
+  ProcessTransport,
+  ProgressLogEntrySchema,
+  ProgressLogEntryType,
+  ProposeMissionConfirmationDetailsSchema,
+  ProtocolError,
+  QueuedUserMessageDisplayGroup,
+  QueuedUserMessageKind,
+  REWIND_TIMEOUT,
+  ReasoningEffort,
+  RedactedThinkingBlockSchema,
+  RefreshComputerResponseSchema,
+  RelayConnectionError,
+  RemoteSessionListResponseSchema,
+  RemoteSessionSchema,
+  RemoveMcpServerRequestParamsSchema,
+  RemoveMcpServerRequestSchema,
+  RemoveMcpServerResponseSchema,
+  RemoveMcpServerResultSchema,
+  RenameSessionRequestParamsSchema,
+  RenameSessionRequestSchema,
+  RenameSessionResponseSchema,
+  RenameSessionResultSchema,
+  RequestPermissionRequestParamsSchema,
+  RequestPermissionRequestSchema,
+  RequestPermissionResponseSchema,
+  RequestPermissionResultSchema,
+  RewindEvictedFileSchema,
+  RewindFileCreationSchema,
+  RewindFileSnapshotSchema,
+  SDK_TAG,
+  SDK_VERSION,
+  SESSION_INIT_TIMEOUT,
+  SLACK_DELEGATION_MAX_RETRIES,
+  SdkMcpServer,
+  ServerRequestHandlerType,
+  SessionError,
+  SessionMetadataSchema,
+  SessionNotFoundError,
+  SessionNotificationParamsSchema,
+  SessionNotificationPayloadSchema,
+  SessionNotificationSchema,
+  SessionNotificationSchemaList,
+  SessionNotificationType,
+  SessionPlatform,
+  SessionReplacedError,
+  SessionReplacementError,
+  SessionSettingsFileSchema,
+  SessionSettingsSchema,
+  SessionSourceSchema,
+  SessionStartEventSchema,
+  SessionTagSchema,
+  SessionTitleUpdatedNotificationSchema,
+  SessionTokenUsageChangedNotificationSchema,
+  SetSkillDisabledRequestParamsSchema,
+  SetSkillDisabledRequestSchema,
+  SetSkillDisabledResponseSchema,
+  SetSkillDisabledResultSchema,
+  SettingsLevel,
+  SettingsUpdatedNotificationSchema,
+  SettingsUpdatedPayloadSchema,
+  SkillDeviationSchema,
+  SkillFeedbackSchema,
+  SkillInfoSchema,
+  SkillLocation,
+  SkillResourceSchema,
+  SpanAttribute,
+  SpanEvent,
+  SpanName,
+  SseMcpSchema as SseMcpConfigSchema,
+  StartMissionRunConfirmationDetailsSchema,
+  StdioMcpSchema as StdioMcpConfigSchema,
+  StreamStateTracker,
+  StructuredOutputErrorSchema,
+  StructuredOutputNotificationSchema,
+  SubmitBugReportRequestParamsSchema,
+  SubmitBugReportRequestSchema,
+  SubmitBugReportResponseSchema,
+  SubmitBugReportResultSchema,
+  SubmitMcpAuthCodeRequestParamsSchema,
+  SubmitMcpAuthCodeRequestSchema,
+  SubmitMcpAuthCodeResponseSchema,
+  SubmitMcpAuthCodeResultSchema,
+  SuccessResultSchema,
+  TestCaseSchema,
+  TestFileSchema,
+  TestsSchema,
+  TextBlockSchema,
+  ThinkingBlockSchema,
+  ThinkingTextCompleteNotificationSchema,
+  ThinkingTextDeltaNotificationSchema,
+  TimeoutError,
+  ToggleMcpServerRequestParamsSchema,
+  ToggleMcpServerRequestSchema,
+  ToggleMcpServerResponseSchema,
+  ToggleMcpServerResultSchema,
+  ToggleMcpToolRequestParamsSchema,
+  ToggleMcpToolRequestSchema,
+  ToggleMcpToolResponseSchema,
+  ToggleMcpToolResultSchema,
+  TokenUsageSchema,
+  ToolCallNotificationSchema,
+  ToolConfirmationDetailsSchema,
+  ToolConfirmationInfoSchema,
+  ToolConfirmationListItemSchema,
+  ToolConfirmationOutcome,
+  ToolConfirmationType,
+  ToolProgressUpdateNotificationSchema,
+  ToolProgressUpdateSchema,
+  ToolResultSchema as ToolResultBlockSchema,
+  ToolResultNotificationSchema,
+  ToolSelectionOverridesSchema,
+  ToolUseSchema as ToolUseBlockSchema,
+  ToolUseSchema2 as ToolUseSchema,
+  TraceContextMetaSchema,
+  TransportDirection,
+  TunnelConnection,
+  UpdateSessionSettingsRequestParamsSchema,
+  UpdateSessionSettingsRequestSchema,
+  UpdateSessionSettingsResponseSchema,
+  UpdateSessionSettingsResultSchema,
+  VerificationCommandSchema,
+  VerificationSchema,
+  WINDOWS_JOB_OBJECT_ERROR_MARKER,
+  WebSocketConnectionError,
+  WebSocketDaemonTransport,
+  WorkerCompletedEntrySchema,
+  WorkerFailedEntrySchema,
+  WorkerPausedEntrySchema,
+  WorkerSelectedFeatureEntrySchema,
+  WorkerStartedEntrySchema,
+  WorkerStateInfoSchema,
+  __resetTransportLoggerForTests,
+  buildUserMessageContentBlocks,
+  configureDaemonCoreDeps,
+  connectAndAuthenticate,
+  connectToDaemon,
+  connectWithRetry,
+  convertNotificationToStreamMessage,
+  createComputer,
+  createResponseSchema,
+  createSdkMcpServer,
+  createSession,
+  createWebSocketDaemonClient,
+  defaultDaemonCoreDeps,
+  deleteComputer,
+  filterMessagesForUI,
+  getComputer,
+  getComputerByName,
+  getComputerMetrics,
+  getMachineTemplate,
+  getPermissionToolInputForDisplay,
+  getQueuedUserMessageDisplayGroup,
+  getQueuedUserMessageReviewPriority,
+  getSubagentCallingMetadata,
+  getToolResultBlocks,
+  getToolResultToolUseId,
+  hasDecoupledInteractionSettings,
+  hasSubagentSessionTag,
+  inspectJsonRpcEnvelope,
+  isDaemonQueuedMessageKind,
+  isPendingToolResultMarker,
+  isPersistedHookMessage,
+  isReviewableQueuedMessageKind,
+  isTransportLoggingEnabled,
+  listComputers,
+  listMachineTemplates,
+  listModels,
+  listRemoteSessions,
+  listSessions,
+  logTransportMessage,
+  machineTypeToMachineConnectionType,
+  noopLogger,
+  orderMessagesByParentChain,
+  recordComputerConnectSli,
+  refreshComputer,
+  repairParentChainCorruption,
+  resolveExecCoreDeps,
+  restartComputer,
+  resumeSession,
+  retryInstallDeps,
+  retryWithLogger,
+  run,
+  spawnWithWindowsJobObjectRetry,
+  sumTokenUsage,
+  summarizeSessionToolUsage,
+  toError,
+  tool,
+  updateComputer
+};
+//# sourceMappingURL=node.mjs.map