@factory/droid-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,3546 @@
+// src/schemas/enums.ts
+var DroidServerMethod = /* @__PURE__ */ ((DroidServerMethod2) => {
+  DroidServerMethod2["INITIALIZE_SESSION"] = "droid.initialize_session";
+  DroidServerMethod2["LOAD_SESSION"] = "droid.load_session";
+  DroidServerMethod2["ADD_USER_MESSAGE"] = "droid.add_user_message";
+  DroidServerMethod2["INTERRUPT_SESSION"] = "droid.interrupt_session";
+  DroidServerMethod2["KILL_WORKER_SESSION"] = "droid.kill_worker_session";
+  DroidServerMethod2["UPDATE_SESSION_SETTINGS"] = "droid.update_session_settings";
+  DroidServerMethod2["TOGGLE_MCP_SERVER"] = "droid.toggle_mcp_server";
+  DroidServerMethod2["AUTHENTICATE_MCP_SERVER"] = "droid.authenticate_mcp_server";
+  DroidServerMethod2["CANCEL_MCP_AUTH"] = "droid.cancel_mcp_auth";
+  DroidServerMethod2["CLEAR_MCP_AUTH"] = "droid.clear_mcp_auth";
+  DroidServerMethod2["ADD_MCP_SERVER"] = "droid.add_mcp_server";
+  DroidServerMethod2["REMOVE_MCP_SERVER"] = "droid.remove_mcp_server";
+  DroidServerMethod2["LIST_MCP_REGISTRY"] = "droid.list_mcp_registry";
+  DroidServerMethod2["LIST_MCP_TOOLS"] = "droid.list_mcp_tools";
+  DroidServerMethod2["LIST_MCP_SERVERS"] = "droid.list_mcp_servers";
+  DroidServerMethod2["TOGGLE_MCP_TOOL"] = "droid.toggle_mcp_tool";
+  DroidServerMethod2["SUBMIT_MCP_AUTH_CODE"] = "droid.submit_mcp_auth_code";
+  DroidServerMethod2["LIST_SKILLS"] = "droid.list_skills";
+  DroidServerMethod2["SUBMIT_BUG_REPORT"] = "droid.submit_bug_report";
+  return DroidServerMethod2;
+})(DroidServerMethod || {});
+var DroidClientMethod = /* @__PURE__ */ ((DroidClientMethod2) => {
+  DroidClientMethod2["SESSION_NOTIFICATION"] = "droid.session_notification";
+  DroidClientMethod2["REQUEST_PERMISSION"] = "droid.request_permission";
+  DroidClientMethod2["ASK_USER"] = "droid.ask_user";
+  return DroidClientMethod2;
+})(DroidClientMethod || {});
+var SessionNotificationType = /* @__PURE__ */ ((SessionNotificationType2) => {
+  SessionNotificationType2["TOOL_RESULT"] = "tool_result";
+  SessionNotificationType2["TOOL_PROGRESS_UPDATE"] = "tool_progress_update";
+  SessionNotificationType2["CREATE_MESSAGE"] = "create_message";
+  SessionNotificationType2["ERROR"] = "error";
+  SessionNotificationType2["DROID_WORKING_STATE_CHANGED"] = "droid_working_state_changed";
+  SessionNotificationType2["PERMISSION_RESOLVED"] = "permission_resolved";
+  SessionNotificationType2["SETTINGS_UPDATED"] = "settings_updated";
+  SessionNotificationType2["SESSION_TITLE_UPDATED"] = "session_title_updated";
+  SessionNotificationType2["MCP_STATUS_CHANGED"] = "mcp_status_changed";
+  SessionNotificationType2["ASSISTANT_TEXT_DELTA"] = "assistant_text_delta";
+  SessionNotificationType2["THINKING_TEXT_DELTA"] = "thinking_text_delta";
+  SessionNotificationType2["SESSION_TOKEN_USAGE_CHANGED"] = "session_token_usage_changed";
+  SessionNotificationType2["MISSION_STATE_CHANGED"] = "mission_state_changed";
+  SessionNotificationType2["MISSION_FEATURES_CHANGED"] = "mission_features_changed";
+  SessionNotificationType2["MISSION_PROGRESS_ENTRY"] = "mission_progress_entry";
+  SessionNotificationType2["MISSION_HEARTBEAT"] = "mission_heartbeat";
+  SessionNotificationType2["MISSION_WORKER_STARTED"] = "mission_worker_started";
+  SessionNotificationType2["MISSION_WORKER_COMPLETED"] = "mission_worker_completed";
+  SessionNotificationType2["MCP_AUTH_REQUIRED"] = "mcp_auth_required";
+  SessionNotificationType2["MCP_AUTH_COMPLETED"] = "mcp_auth_completed";
+  return SessionNotificationType2;
+})(SessionNotificationType || {});
+var ToolConfirmationOutcome = /* @__PURE__ */ ((ToolConfirmationOutcome3) => {
+  ToolConfirmationOutcome3["ProceedOnce"] = "proceed_once";
+  ToolConfirmationOutcome3["ProceedAlways"] = "proceed_always";
+  ToolConfirmationOutcome3["ProceedAutoRun"] = "proceed_auto_run";
+  ToolConfirmationOutcome3["ProceedAutoRunLow"] = "proceed_auto_run_low";
+  ToolConfirmationOutcome3["ProceedAutoRunMedium"] = "proceed_auto_run_medium";
+  ToolConfirmationOutcome3["ProceedAutoRunHigh"] = "proceed_auto_run_high";
+  ToolConfirmationOutcome3["ProceedEdit"] = "proceed_edit";
+  ToolConfirmationOutcome3["Cancel"] = "cancel";
+  return ToolConfirmationOutcome3;
+})(ToolConfirmationOutcome || {});
+var ToolConfirmationType = /* @__PURE__ */ ((ToolConfirmationType2) => {
+  ToolConfirmationType2["Edit"] = "edit";
+  ToolConfirmationType2["Execute"] = "exec";
+  ToolConfirmationType2["Create"] = "create";
+  ToolConfirmationType2["AskUser"] = "ask_user";
+  ToolConfirmationType2["ExitSpecMode"] = "exit_spec_mode";
+  ToolConfirmationType2["ProposeMission"] = "propose_mission";
+  ToolConfirmationType2["StartMissionRun"] = "start_mission_run";
+  ToolConfirmationType2["ApplyPatch"] = "apply_patch";
+  ToolConfirmationType2["McpTool"] = "mcp_tool";
+  return ToolConfirmationType2;
+})(ToolConfirmationType || {});
+var DroidWorkingState = /* @__PURE__ */ ((DroidWorkingState2) => {
+  DroidWorkingState2["Idle"] = "idle";
+  DroidWorkingState2["StreamingAssistantMessage"] = "streaming_assistant_message";
+  DroidWorkingState2["WaitingForToolConfirmation"] = "waiting_for_tool_confirmation";
+  DroidWorkingState2["ExecutingTool"] = "executing_tool";
+  DroidWorkingState2["CompactingConversation"] = "compacting_conversation";
+  return DroidWorkingState2;
+})(DroidWorkingState || {});
+var DroidErrorType = /* @__PURE__ */ ((DroidErrorType2) => {
+  DroidErrorType2["CONNECTION_ERROR"] = "ConnectionError";
+  DroidErrorType2["PROTOCOL_ERROR"] = "ProtocolError";
+  DroidErrorType2["SESSION_ERROR"] = "SessionError";
+  DroidErrorType2["TIMEOUT_ERROR"] = "TimeoutError";
+  DroidErrorType2["DROID_CLIENT_ERROR"] = "DroidClientError";
+  DroidErrorType2["PROCESS_EXIT_ERROR"] = "ProcessExitError";
+  DroidErrorType2["ERROR"] = "Error";
+  return DroidErrorType2;
+})(DroidErrorType || {});
+var McpServerStatus = /* @__PURE__ */ ((McpServerStatus2) => {
+  McpServerStatus2["Connecting"] = "connecting";
+  McpServerStatus2["Connected"] = "connected";
+  McpServerStatus2["Disconnected"] = "disconnected";
+  McpServerStatus2["Failed"] = "failed";
+  McpServerStatus2["Disabled"] = "disabled";
+  return McpServerStatus2;
+})(McpServerStatus || {});
+var McpServerType = /* @__PURE__ */ ((McpServerType2) => {
+  McpServerType2["Stdio"] = "stdio";
+  McpServerType2["Http"] = "http";
+  McpServerType2["Sse"] = "sse";
+  return McpServerType2;
+})(McpServerType || {});
+var McpStatus = /* @__PURE__ */ ((McpStatus2) => {
+  McpStatus2["NotInitialized"] = "not-initialized";
+  McpStatus2["Initializing"] = "initializing";
+  McpStatus2["Ready"] = "ready";
+  McpStatus2["NoServers"] = "no-servers";
+  McpStatus2["Failed"] = "failed";
+  return McpStatus2;
+})(McpStatus || {});
+var McpAuthOutcome = /* @__PURE__ */ ((McpAuthOutcome3) => {
+  McpAuthOutcome3["Success"] = "success";
+  McpAuthOutcome3["Cancelled"] = "cancelled";
+  McpAuthOutcome3["Failed"] = "failed";
+  return McpAuthOutcome3;
+})(McpAuthOutcome || {});
+var DecompSessionType = /* @__PURE__ */ ((DecompSessionType2) => {
+  DecompSessionType2["Orchestrator"] = "orchestrator";
+  DecompSessionType2["Worker"] = "worker";
+  return DecompSessionType2;
+})(DecompSessionType || {});
+var MissionState = /* @__PURE__ */ ((MissionState3) => {
+  MissionState3["AwaitingInput"] = "awaiting_input";
+  MissionState3["Initializing"] = "initializing";
+  MissionState3["Running"] = "running";
+  MissionState3["Paused"] = "paused";
+  MissionState3["OrchestratorTurn"] = "orchestrator_turn";
+  MissionState3["Completed"] = "completed";
+  return MissionState3;
+})(MissionState || {});
+var FeatureStatus = /* @__PURE__ */ ((FeatureStatus2) => {
+  FeatureStatus2["Pending"] = "pending";
+  FeatureStatus2["InProgress"] = "in_progress";
+  FeatureStatus2["Completed"] = "completed";
+  FeatureStatus2["Cancelled"] = "cancelled";
+  return FeatureStatus2;
+})(FeatureStatus || {});
+var FeatureSuccessState = /* @__PURE__ */ ((FeatureSuccessState2) => {
+  FeatureSuccessState2["Success"] = "success";
+  FeatureSuccessState2["Partial"] = "partial";
+  FeatureSuccessState2["Failure"] = "failure";
+  return FeatureSuccessState2;
+})(FeatureSuccessState || {});
+var IssueSeverity = /* @__PURE__ */ ((IssueSeverity2) => {
+  IssueSeverity2["Blocking"] = "blocking";
+  IssueSeverity2["NonBlocking"] = "non_blocking";
+  IssueSeverity2["Suggestion"] = "suggestion";
+  return IssueSeverity2;
+})(IssueSeverity || {});
+var DismissalType = /* @__PURE__ */ ((DismissalType2) => {
+  DismissalType2["DiscoveredIssue"] = "discovered_issue";
+  DismissalType2["CriticalContext"] = "critical_context";
+  DismissalType2["IncompleteWork"] = "incomplete_work";
+  return DismissalType2;
+})(DismissalType || {});
+var ProgressLogEntryType = /* @__PURE__ */ ((ProgressLogEntryType2) => {
+  ProgressLogEntryType2["MissionAccepted"] = "mission_accepted";
+  ProgressLogEntryType2["MissionPaused"] = "mission_paused";
+  ProgressLogEntryType2["MissionResumed"] = "mission_resumed";
+  ProgressLogEntryType2["MissionRunStarted"] = "mission_run_started";
+  ProgressLogEntryType2["WorkerStarted"] = "worker_started";
+  ProgressLogEntryType2["WorkerSelectedFeature"] = "worker_selected_feature";
+  ProgressLogEntryType2["WorkerCompleted"] = "worker_completed";
+  ProgressLogEntryType2["WorkerFailed"] = "worker_failed";
+  ProgressLogEntryType2["WorkerPaused"] = "worker_paused";
+  ProgressLogEntryType2["HandoffItemsDismissed"] = "handoff_items_dismissed";
+  ProgressLogEntryType2["MilestoneValidationTriggered"] = "milestone_validation_triggered";
+  return ProgressLogEntryType2;
+})(ProgressLogEntryType || {});
+var DroidInteractionMode = /* @__PURE__ */ ((DroidInteractionMode2) => {
+  DroidInteractionMode2["Auto"] = "auto";
+  DroidInteractionMode2["Spec"] = "spec";
+  DroidInteractionMode2["AGI"] = "agi";
+  return DroidInteractionMode2;
+})(DroidInteractionMode || {});
+var AutonomyLevel = /* @__PURE__ */ ((AutonomyLevel2) => {
+  AutonomyLevel2["Off"] = "off";
+  AutonomyLevel2["Low"] = "low";
+  AutonomyLevel2["Medium"] = "medium";
+  AutonomyLevel2["High"] = "high";
+  return AutonomyLevel2;
+})(AutonomyLevel || {});
+var AutonomyMode = /* @__PURE__ */ ((AutonomyMode2) => {
+  AutonomyMode2["Normal"] = "normal";
+  AutonomyMode2["Spec"] = "spec";
+  AutonomyMode2["AutoLow"] = "auto-low";
+  AutonomyMode2["AutoMedium"] = "auto-medium";
+  AutonomyMode2["AutoHigh"] = "auto-high";
+  return AutonomyMode2;
+})(AutonomyMode || {});
+var ReasoningEffort = /* @__PURE__ */ ((ReasoningEffort2) => {
+  ReasoningEffort2["None"] = "none";
+  ReasoningEffort2["Dynamic"] = "dynamic";
+  ReasoningEffort2["Off"] = "off";
+  ReasoningEffort2["Minimal"] = "minimal";
+  ReasoningEffort2["Low"] = "low";
+  ReasoningEffort2["Medium"] = "medium";
+  ReasoningEffort2["High"] = "high";
+  ReasoningEffort2["ExtraHigh"] = "xhigh";
+  ReasoningEffort2["Max"] = "max";
+  return ReasoningEffort2;
+})(ReasoningEffort || {});
+var ModelProvider = /* @__PURE__ */ ((ModelProvider2) => {
+  ModelProvider2["ANTHROPIC"] = "anthropic";
+  ModelProvider2["OPENAI"] = "openai";
+  ModelProvider2["GENERIC_CHAT_COMPLETION_API"] = "generic-chat-completion-api";
+  ModelProvider2["FACTORY"] = "factory";
+  ModelProvider2["GOOGLE"] = "google";
+  ModelProvider2["XAI"] = "xai";
+  ModelProvider2["VOYAGE"] = "voyage";
+  return ModelProvider2;
+})(ModelProvider || {});
+var JsonRpcErrorCode = /* @__PURE__ */ ((JsonRpcErrorCode2) => {
+  JsonRpcErrorCode2[JsonRpcErrorCode2["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["AUTHENTICATION_ERROR"] = -32001] = "AUTHENTICATION_ERROR";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["ENTITY_NOT_FOUND"] = -32004] = "ENTITY_NOT_FOUND";
+  JsonRpcErrorCode2[JsonRpcErrorCode2["SESSION_DISCONNECTED"] = -32005] = "SESSION_DISCONNECTED";
+  return JsonRpcErrorCode2;
+})(JsonRpcErrorCode || {});
+var JsonRpcMessageType = /* @__PURE__ */ ((JsonRpcMessageType2) => {
+  JsonRpcMessageType2["Request"] = "request";
+  JsonRpcMessageType2["Response"] = "response";
+  JsonRpcMessageType2["Notification"] = "notification";
+  return JsonRpcMessageType2;
+})(JsonRpcMessageType || {});
+var SettingsLevel = /* @__PURE__ */ ((SettingsLevel2) => {
+  SettingsLevel2["Org"] = "org";
+  SettingsLevel2["Runtime"] = "runtime";
+  SettingsLevel2["User"] = "user";
+  SettingsLevel2["Project"] = "project";
+  SettingsLevel2["Folder"] = "folder";
+  SettingsLevel2["Dynamic"] = "dynamic";
+  SettingsLevel2["BuiltIn"] = "builtin";
+  return SettingsLevel2;
+})(SettingsLevel || {});
+var SkillLocation = /* @__PURE__ */ ((SkillLocation2) => {
+  SkillLocation2["Project"] = "project";
+  SkillLocation2["Personal"] = "personal";
+  SkillLocation2["Builtin"] = "builtin";
+  return SkillLocation2;
+})(SkillLocation || {});
+
+// src/schemas/constants.ts
+var JSONRPC_VERSION = "2.0";
+var LEGACY_FACTORY_API_VERSION = "1.0.0";
+var FACTORY_PROTOCOL_VERSION = "1.2.0";
+var FACTORY_CLIENT_HEADER = "X-Factory-Client";
+var FACTORY_CLIENT_VERSION = "X-Client-Version";
+var DEFAULT_REQUEST_TIMEOUT = 3e4;
+var SESSION_INIT_TIMEOUT = 6e4;
+var MCP_AUTH_TIMEOUT = 3e5;
+
+// src/schemas/shared.ts
+import { z } from "zod";
+var TraceContextMetaSchema = z.object({
+  traceparent: z.string().optional(),
+  tracestate: z.string().optional()
+});
+var JsonRpcEnvelopeSchema = z.object({
+  jsonrpc: z.literal(JSONRPC_VERSION),
+  factoryApiVersion: z.literal(LEGACY_FACTORY_API_VERSION),
+  factoryProtocolVersion: z.string().optional(),
+  _meta: TraceContextMetaSchema.optional()
+});
+var JsonRpcErrorSchema = z.object({
+  code: z.nativeEnum(JsonRpcErrorCode),
+  message: z.string(),
+  data: z.unknown().optional()
+});
+var BaseRequestSchema = z.object({
+  type: z.literal("request"),
+  id: z.string(),
+  method: z.string(),
+  params: z.unknown().optional()
+});
+var BaseResponseSuccessSchema = z.object({
+  type: z.literal("response"),
+  id: z.string(),
+  result: z.unknown()
+});
+var BaseResponseFailureSchema = z.object({
+  type: z.literal("response"),
+  id: z.string().nullable(),
+  error: JsonRpcErrorSchema
+});
+var BaseNotificationSchema = z.object({
+  type: z.literal("notification"),
+  method: z.string(),
+  params: z.unknown().optional()
+});
+var JsonRpcRequestSchema = JsonRpcEnvelopeSchema.extend(
+  BaseRequestSchema.shape
+);
+var JsonRpcResponseSuccessSchema = JsonRpcEnvelopeSchema.extend(
+  BaseResponseSuccessSchema.shape
+);
+var JsonRpcResponseFailureSchema = JsonRpcEnvelopeSchema.extend(
+  BaseResponseFailureSchema.shape
+);
+var JsonRpcNotificationSchema = JsonRpcEnvelopeSchema.extend(
+  BaseNotificationSchema.shape
+);
+var JsonRpcResponseSchema = z.union([
+  JsonRpcResponseFailureSchema,
+  JsonRpcResponseSuccessSchema
+]);
+var JsonRpcMessageSchema = z.discriminatedUnion("type", [
+  JsonRpcRequestSchema,
+  JsonRpcEnvelopeSchema.extend({
+    type: z.literal("response"),
+    id: z.string().nullable(),
+    result: z.unknown().optional(),
+    error: JsonRpcErrorSchema.optional()
+  }),
+  JsonRpcNotificationSchema
+]);
+
+// src/schemas/messages.ts
+import { z as z2 } from "zod";
+var TextBlockSchema = z2.object({
+  type: z2.literal("text"),
+  text: z2.string(),
+  id: z2.string().optional()
+}).passthrough();
+var Base64ImageSourceSchema = z2.object({
+  type: z2.literal("base64"),
+  data: z2.string(),
+  mediaType: z2.enum(["image/jpeg", "image/png", "image/gif", "image/webp"])
+}).passthrough();
+var ImageBlockSchema = z2.object({
+  type: z2.literal("image"),
+  source: Base64ImageSourceSchema,
+  id: z2.string().optional()
+}).passthrough();
+var ThinkingBlockSchema = z2.object({
+  type: z2.literal("thinking"),
+  signature: z2.string(),
+  thinking: z2.string(),
+  id: z2.string().optional(),
+  signatureProvider: z2.string().optional()
+}).passthrough();
+var RedactedThinkingBlockSchema = z2.object({
+  type: z2.literal("redacted_thinking"),
+  data: z2.string(),
+  id: z2.string().optional()
+}).passthrough();
+var ToolUseBlockSchema = z2.object({
+  type: z2.literal("tool_use"),
+  id: z2.string(),
+  input: z2.record(z2.unknown()),
+  name: z2.string(),
+  thoughtSignature: z2.string().optional()
+}).passthrough();
+var ToolResultBlockSchema = z2.object({
+  type: z2.literal("tool_result"),
+  toolUseId: z2.string(),
+  content: z2.union([z2.string(), z2.array(z2.unknown())]).optional(),
+  isError: z2.boolean().optional(),
+  id: z2.string().optional()
+}).passthrough();
+var DocumentBlockSchema = z2.object({
+  type: z2.literal("document"),
+  source: z2.record(z2.unknown()),
+  id: z2.string().optional()
+}).passthrough();
+var ContentBlockSchema = z2.discriminatedUnion("type", [
+  TextBlockSchema,
+  ImageBlockSchema,
+  ThinkingBlockSchema,
+  RedactedThinkingBlockSchema,
+  ToolUseBlockSchema,
+  ToolResultBlockSchema,
+  DocumentBlockSchema
+]);
+var FactoryDroidMessageSchema = z2.object({
+  id: z2.string(),
+  role: z2.enum(["user", "assistant", "tool", "system"]),
+  content: z2.array(ContentBlockSchema),
+  createdAt: z2.number(),
+  updatedAt: z2.number(),
+  parentId: z2.string().optional(),
+  visibility: z2.enum(["both", "llm_only", "user_only"]).optional(),
+  isError: z2.boolean().optional()
+}).passthrough();
+var DocumentSourceSchema = z2.object({
+  type: z2.string(),
+  mediaType: z2.string(),
+  data: z2.string(),
+  name: z2.string().optional(),
+  mime: z2.string().optional()
+}).strict();
+
+// src/schemas/mcp.ts
+import { z as z3 } from "zod";
+var McpStdioServerConfigFieldsSchema = z3.object({
+  command: z3.string().optional(),
+  args: z3.array(z3.string()).optional()
+});
+var McpHttpServerConfigFieldsSchema = z3.object({
+  url: z3.string().optional()
+});
+var McpSseServerConfigFieldsSchema = z3.object({
+  url: z3.string(),
+  headers: z3.record(z3.string()).optional()
+});
+var McpServerStatusInfoSchema = z3.object({
+  name: z3.string(),
+  status: z3.nativeEnum(McpServerStatus),
+  source: z3.nativeEnum(SettingsLevel),
+  isManaged: z3.boolean(),
+  error: z3.string().optional(),
+  toolCount: z3.number().optional(),
+  serverType: z3.nativeEnum(McpServerType).optional(),
+  hasAuthTokens: z3.boolean().optional()
+}).passthrough();
+var McpStatusSummarySchema = z3.object({
+  total: z3.number(),
+  connected: z3.number(),
+  connecting: z3.number(),
+  failed: z3.number(),
+  disabled: z3.number().optional()
+}).passthrough();
+var McpRegistryServerSchema = z3.object({
+  name: z3.string(),
+  description: z3.string(),
+  type: z3.nativeEnum(McpServerType),
+  // Stdio config fields
+  command: z3.string().optional(),
+  args: z3.array(z3.string()).optional(),
+  // HTTP config fields
+  url: z3.string().optional(),
+  // Additional metadata
+  note: z3.string().optional(),
+  logoUrl: z3.string().optional()
+}).passthrough();
+var McpToolInputSchemaSchema = z3.object({
+  type: z3.string().optional(),
+  properties: z3.record(z3.unknown()).optional(),
+  required: z3.array(z3.string()).optional()
+}).passthrough();
+var McpToolInfoSchema = z3.object({
+  serverName: z3.string(),
+  name: z3.string(),
+  description: z3.string().optional(),
+  isEnabled: z3.boolean(),
+  isReadOnly: z3.boolean().optional(),
+  inputSchema: McpToolInputSchemaSchema.optional()
+}).passthrough();
+var ToolConfirmationListItemSchema = z3.object({
+  label: z3.string(),
+  value: z3.nativeEnum(ToolConfirmationOutcome)
+}).passthrough();
+
+// src/schemas/mission.ts
+import { z as z4 } from "zod";
+var MissionFeatureSchema = z4.object({
+  id: z4.string(),
+  description: z4.string(),
+  status: z4.nativeEnum(FeatureStatus),
+  skillName: z4.string(),
+  preconditions: z4.array(z4.string()),
+  expectedBehavior: z4.array(z4.string()),
+  verificationSteps: z4.array(z4.string()),
+  fulfills: z4.array(z4.string()).optional(),
+  milestone: z4.string().optional(),
+  workerSessionIds: z4.array(z4.string()).optional(),
+  currentWorkerSessionId: z4.string().nullable().optional(),
+  completedWorkerSessionId: z4.string().nullable().optional()
+}).passthrough();
+var FeatureSuccessStateSchema = z4.nativeEnum(FeatureSuccessState);
+var DiscoveredIssueSchema = z4.object({
+  severity: z4.nativeEnum(IssueSeverity),
+  description: z4.string(),
+  suggestedFix: z4.string().optional()
+}).passthrough();
+var VerificationCommandSchema = z4.object({
+  command: z4.string(),
+  exitCode: z4.number(),
+  observation: z4.string()
+}).passthrough();
+var InteractiveCheckSchema = z4.object({
+  action: z4.string(),
+  observed: z4.string()
+}).passthrough();
+var VerificationSchema = z4.object({
+  commandsRun: z4.array(VerificationCommandSchema),
+  interactiveChecks: z4.array(InteractiveCheckSchema).optional()
+}).passthrough();
+var TestCaseSchema = z4.object({
+  name: z4.string(),
+  verifies: z4.string()
+}).passthrough();
+var TestFileSchema = z4.object({
+  file: z4.string(),
+  cases: z4.array(TestCaseSchema)
+}).passthrough();
+var TestsSchema = z4.object({
+  added: z4.array(TestFileSchema),
+  updated: z4.array(z4.string()).optional(),
+  coverage: z4.string()
+}).passthrough();
+var SkillDeviationSchema = z4.object({
+  step: z4.string(),
+  whatIDidInstead: z4.string(),
+  why: z4.string()
+}).passthrough();
+var SkillFeedbackSchema = z4.object({
+  followedProcedure: z4.boolean(),
+  deviations: z4.array(SkillDeviationSchema),
+  suggestedChanges: z4.array(z4.string()).optional()
+}).passthrough();
+var HandoffSchema = z4.object({
+  salientSummary: z4.string().optional(),
+  whatWasImplemented: z4.string(),
+  whatWasLeftUndone: z4.string(),
+  verification: VerificationSchema,
+  tests: TestsSchema,
+  discoveredIssues: z4.array(DiscoveredIssueSchema),
+  skillFeedback: SkillFeedbackSchema.optional()
+}).passthrough();
+var DismissalRecordSchema = z4.object({
+  type: z4.nativeEnum(DismissalType),
+  sourceFeatureId: z4.string(),
+  summary: z4.string(),
+  justification: z4.string()
+}).passthrough();
+var BaseProgressLogEntrySchema = z4.object({
+  timestamp: z4.string()
+});
+var MissionAcceptedEntrySchema = BaseProgressLogEntrySchema.extend({
+  type: z4.literal("mission_accepted" /* MissionAccepted */),
+  title: z4.string()
+}).passthrough();
+var MissionPausedEntrySchema = BaseProgressLogEntrySchema.extend({
+  type: z4.literal("mission_paused" /* MissionPaused */)
+}).passthrough();
+var MissionResumedEntrySchema = BaseProgressLogEntrySchema.extend({
+  type: z4.literal("mission_resumed" /* MissionResumed */)
+}).passthrough();
+var MissionRunStartedEntrySchema = BaseProgressLogEntrySchema.extend({
+  type: z4.literal("mission_run_started" /* MissionRunStarted */),
+  message: z4.string().optional()
+}).passthrough();
+var WorkerStartedEntrySchema = BaseProgressLogEntrySchema.extend({
+  type: z4.literal("worker_started" /* WorkerStarted */),
+  workerSessionId: z4.string(),
+  spawnId: z4.string(),
+  featureId: z4.string().optional()
+}).passthrough();
+var WorkerSelectedFeatureEntrySchema = BaseProgressLogEntrySchema.extend({
+  type: z4.literal("worker_selected_feature" /* WorkerSelectedFeature */),
+  workerSessionId: z4.string(),
+  featureId: z4.string()
+}).passthrough();
+var WorkerCompletedEntrySchema = BaseProgressLogEntrySchema.extend({
+  type: z4.literal("worker_completed" /* WorkerCompleted */),
+  workerSessionId: z4.string(),
+  featureId: z4.string(),
+  successState: FeatureSuccessStateSchema,
+  returnToOrchestrator: z4.boolean(),
+  commitId: z4.string().optional(),
+  exitCode: z4.number(),
+  validatorsPassed: z4.boolean().optional(),
+  handoff: HandoffSchema.optional()
+}).passthrough();
+var WorkerFailedEntrySchema = BaseProgressLogEntrySchema.extend({
+  type: z4.literal("worker_failed" /* WorkerFailed */),
+  workerSessionId: z4.string().optional(),
+  spawnId: z4.string(),
+  exitCode: z4.number().optional(),
+  reason: z4.string()
+}).passthrough();
+var WorkerPausedEntrySchema = BaseProgressLogEntrySchema.extend({
+  type: z4.literal("worker_paused" /* WorkerPaused */),
+  workerSessionId: z4.string(),
+  featureId: z4.string().optional()
+}).passthrough();
+var HandoffItemsDismissedEntrySchema = BaseProgressLogEntrySchema.extend({
+  type: z4.literal("handoff_items_dismissed" /* HandoffItemsDismissed */),
+  dismissals: z4.array(DismissalRecordSchema).optional()
+}).passthrough();
+var MilestoneValidationTriggeredEntrySchema = BaseProgressLogEntrySchema.extend({
+  type: z4.literal("milestone_validation_triggered" /* MilestoneValidationTriggered */),
+  milestone: z4.string(),
+  featureId: z4.string()
+}).passthrough();
+var ProgressLogEntrySchema = z4.discriminatedUnion("type", [
+  MissionAcceptedEntrySchema,
+  MissionPausedEntrySchema,
+  MissionResumedEntrySchema,
+  MissionRunStartedEntrySchema,
+  WorkerStartedEntrySchema,
+  WorkerSelectedFeatureEntrySchema,
+  WorkerCompletedEntrySchema,
+  WorkerFailedEntrySchema,
+  WorkerPausedEntrySchema,
+  HandoffItemsDismissedEntrySchema,
+  MilestoneValidationTriggeredEntrySchema
+]);
+
+// src/schemas/client.ts
+import { z as z5 } from "zod";
+var SessionTagSchema = z5.object({
+  name: z5.string(),
+  metadata: z5.record(z5.string()).optional()
+}).strict();
+var SessionSourceSchema = z5.object({
+  platform: z5.string()
+}).passthrough();
+var StdioMcpConfigSchema = z5.object({
+  name: z5.string(),
+  command: z5.string(),
+  args: z5.array(z5.string()).default([]),
+  env: z5.record(z5.string()).optional().default({})
+}).strict();
+var HttpHeaderSchema = z5.object({
+  name: z5.string(),
+  value: z5.string()
+}).strict();
+var HttpMcpConfigSchema = z5.object({
+  type: z5.literal("http"),
+  name: z5.string(),
+  url: z5.string().url(),
+  headers: HttpHeaderSchema.array().default([])
+}).strict();
+var SseMcpConfigSchema = z5.object({
+  type: z5.literal("sse"),
+  name: z5.string(),
+  url: z5.string().url(),
+  headers: HttpHeaderSchema.array().default([])
+}).strict();
+var McpServerConfigSchema = z5.union([
+  StdioMcpConfigSchema,
+  HttpMcpConfigSchema,
+  SseMcpConfigSchema
+]);
+var SessionSettingsSchema = z5.object({
+  modelId: z5.string(),
+  reasoningEffort: z5.nativeEnum(ReasoningEffort),
+  autonomyMode: z5.nativeEnum(AutonomyMode).optional(),
+  interactionMode: z5.nativeEnum(DroidInteractionMode).optional().catch(void 0),
+  autonomyLevel: z5.nativeEnum(AutonomyLevel).optional().catch(void 0),
+  specModeModelId: z5.string().optional(),
+  specModeReasoningEffort: z5.nativeEnum(ReasoningEffort).optional()
+}).passthrough();
+var GitRepoInfoSchema = z5.object({
+  owner: z5.string().optional(),
+  repoName: z5.string()
+}).passthrough();
+var AvailableModelConfigSchema = z5.object({
+  id: z5.string(),
+  modelId: z5.string().optional(),
+  displayName: z5.string(),
+  shortDisplayName: z5.string(),
+  modelProvider: z5.nativeEnum(ModelProvider),
+  supportedReasoningEfforts: z5.array(z5.nativeEnum(ReasoningEffort)),
+  defaultReasoningEffort: z5.nativeEnum(ReasoningEffort),
+  isCustom: z5.boolean().default(false),
+  noImageSupport: z5.boolean().optional(),
+  supportsPDFs: z5.boolean().optional(),
+  tier: z5.string().optional(),
+  tokenMultiplier: z5.number().optional(),
+  promoLabel: z5.string().optional(),
+  featureFlag: z5.record(z5.unknown()).optional(),
+  usesUSBasedInference: z5.boolean().optional()
+}).passthrough();
+var TokenUsageSchema = z5.object({
+  inputTokens: z5.number(),
+  outputTokens: z5.number(),
+  cacheCreationTokens: z5.number(),
+  cacheReadTokens: z5.number(),
+  thinkingTokens: z5.number()
+}).passthrough();
+var WorkerStateInfoSchema = z5.object({
+  startedAt: z5.string(),
+  completedAt: z5.string().optional(),
+  exitCode: z5.number().optional()
+}).passthrough();
+var SkillResourceSchema = z5.object({
+  name: z5.string(),
+  path: z5.string(),
+  type: z5.enum(["reference", "asset"])
+}).passthrough();
+var SkillInfoSchema = z5.object({
+  name: z5.string(),
+  description: z5.string().optional(),
+  location: z5.nativeEnum(SkillLocation),
+  filePath: z5.string(),
+  enabled: z5.boolean().optional(),
+  userInvocable: z5.boolean().optional(),
+  version: z5.string().optional(),
+  content: z5.string().optional(),
+  resources: z5.array(SkillResourceSchema).optional()
+}).passthrough();
+var InitializeSessionRequestParamsSchema = z5.object({
+  machineId: z5.string(),
+  cwd: z5.string(),
+  workspaceId: z5.string().optional(),
+  sessionId: z5.string().optional(),
+  mcpServers: z5.array(McpServerConfigSchema).optional(),
+  autonomyMode: z5.nativeEnum(AutonomyMode).optional(),
+  interactionMode: z5.nativeEnum(DroidInteractionMode).optional().catch(void 0),
+  autonomyLevel: z5.nativeEnum(AutonomyLevel).optional().catch(void 0),
+  modelId: z5.string().optional(),
+  reasoningEffort: z5.nativeEnum(ReasoningEffort).optional(),
+  specModeModelId: z5.string().optional(),
+  specModeReasoningEffort: z5.nativeEnum(ReasoningEffort).optional(),
+  decompSessionType: z5.nativeEnum(DecompSessionType).optional(),
+  decompMissionId: z5.string().optional(),
+  skipPermissionsUnsafe: z5.boolean().optional(),
+  enabledToolIds: z5.array(z5.string()).optional(),
+  sessionLocation: z5.string().optional(),
+  sessionSource: SessionSourceSchema.optional(),
+  tags: z5.array(SessionTagSchema).optional(),
+  mcpOAuthCallbackUri: z5.string().optional()
+}).strict();
+var LoadSessionRequestParamsSchema = z5.object({
+  sessionId: z5.string(),
+  mcpServers: z5.array(McpServerConfigSchema).optional(),
+  mcpOAuthCallbackUri: z5.string().optional()
+}).strict();
+var AddUserMessageRequestParamsSchema = z5.object({
+  messageId: z5.string().optional(),
+  text: z5.string(),
+  images: z5.array(Base64ImageSourceSchema).optional(),
+  files: z5.array(DocumentSourceSchema).optional()
+}).strict();
+var InterruptSessionRequestParamsSchema = z5.object({}).strict();
+var KillWorkerSessionRequestParamsSchema = z5.object({
+  workerSessionId: z5.string()
+}).strict();
+var UpdateSessionSettingsRequestParamsSchema = z5.object({
+  modelId: z5.string().optional(),
+  reasoningEffort: z5.nativeEnum(ReasoningEffort).optional(),
+  autonomyMode: z5.nativeEnum(AutonomyMode).optional(),
+  interactionMode: z5.nativeEnum(DroidInteractionMode).optional().catch(void 0),
+  autonomyLevel: z5.nativeEnum(AutonomyLevel).optional().catch(void 0),
+  specModeModelId: z5.string().nullable().optional(),
+  specModeReasoningEffort: z5.nativeEnum(ReasoningEffort).nullable().optional()
+}).strict();
+var ToggleMcpServerRequestParamsSchema = z5.object({
+  serverName: z5.string(),
+  enabled: z5.boolean(),
+  settingsLevel: z5.literal("user" /* User */)
+}).strict();
+var AuthenticateMcpServerRequestParamsSchema = z5.object({
+  serverName: z5.string()
+}).strict();
+var CancelMcpAuthRequestParamsSchema = z5.object({
+  serverName: z5.string()
+}).strict();
+var ClearMcpAuthRequestParamsSchema = z5.object({
+  serverName: z5.string()
+}).strict();
+var SubmitMcpAuthCodeRequestParamsSchema = z5.object({
+  serverName: z5.string(),
+  code: z5.string(),
+  state: z5.string()
+}).strict();
+var AddMcpServerRequestParamsSchema = z5.object({
+  name: z5.string(),
+  type: z5.nativeEnum(McpServerType),
+  url: z5.string().optional(),
+  headers: z5.record(z5.string()).optional(),
+  command: z5.string().optional(),
+  args: z5.array(z5.string()).optional(),
+  env: z5.record(z5.string()).optional()
+}).strict();
+var RemoveMcpServerRequestParamsSchema = z5.object({
+  serverName: z5.string(),
+  settingsLevel: z5.literal("user" /* User */)
+}).strict();
+var ListMcpRegistryRequestParamsSchema = z5.object({}).strict();
+var ListMcpToolsRequestParamsSchema = z5.object({}).strict();
+var ListMcpServersRequestParamsSchema = z5.object({}).strict();
+var ToggleMcpToolRequestParamsSchema = z5.object({
+  serverName: z5.string(),
+  toolName: z5.string(),
+  enabled: z5.boolean()
+}).strict();
+var ListSkillsRequestParamsSchema = z5.object({}).strict();
+var SubmitBugReportRequestParamsSchema = z5.object({
+  userComment: z5.string(),
+  clientLogs: z5.string().optional()
+}).strict();
+var InitializeSessionRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.initialize_session" /* INITIALIZE_SESSION */),
+  params: InitializeSessionRequestParamsSchema
+});
+var LoadSessionRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.load_session" /* LOAD_SESSION */),
+  params: LoadSessionRequestParamsSchema
+});
+var AddUserMessageRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.add_user_message" /* ADD_USER_MESSAGE */),
+  params: AddUserMessageRequestParamsSchema
+});
+var InterruptSessionRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.interrupt_session" /* INTERRUPT_SESSION */),
+  params: InterruptSessionRequestParamsSchema
+});
+var KillWorkerSessionRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.kill_worker_session" /* KILL_WORKER_SESSION */),
+  params: KillWorkerSessionRequestParamsSchema
+});
+var UpdateSessionSettingsRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.update_session_settings" /* UPDATE_SESSION_SETTINGS */),
+  params: UpdateSessionSettingsRequestParamsSchema
+});
+var ToggleMcpServerRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.toggle_mcp_server" /* TOGGLE_MCP_SERVER */),
+  params: ToggleMcpServerRequestParamsSchema
+});
+var AuthenticateMcpServerRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.authenticate_mcp_server" /* AUTHENTICATE_MCP_SERVER */),
+  params: AuthenticateMcpServerRequestParamsSchema
+});
+var CancelMcpAuthRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.cancel_mcp_auth" /* CANCEL_MCP_AUTH */),
+  params: CancelMcpAuthRequestParamsSchema
+});
+var ClearMcpAuthRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.clear_mcp_auth" /* CLEAR_MCP_AUTH */),
+  params: ClearMcpAuthRequestParamsSchema
+});
+var SubmitMcpAuthCodeRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.submit_mcp_auth_code" /* SUBMIT_MCP_AUTH_CODE */),
+  params: SubmitMcpAuthCodeRequestParamsSchema
+});
+var AddMcpServerRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.add_mcp_server" /* ADD_MCP_SERVER */),
+  params: AddMcpServerRequestParamsSchema
+});
+var RemoveMcpServerRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.remove_mcp_server" /* REMOVE_MCP_SERVER */),
+  params: RemoveMcpServerRequestParamsSchema
+});
+var ListMcpRegistryRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.list_mcp_registry" /* LIST_MCP_REGISTRY */),
+  params: ListMcpRegistryRequestParamsSchema
+});
+var ListMcpToolsRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.list_mcp_tools" /* LIST_MCP_TOOLS */),
+  params: ListMcpToolsRequestParamsSchema
+});
+var ListMcpServersRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.list_mcp_servers" /* LIST_MCP_SERVERS */),
+  params: ListMcpServersRequestParamsSchema
+});
+var ToggleMcpToolRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.toggle_mcp_tool" /* TOGGLE_MCP_TOOL */),
+  params: ToggleMcpToolRequestParamsSchema
+});
+var ListSkillsRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.list_skills" /* LIST_SKILLS */),
+  params: ListSkillsRequestParamsSchema
+});
+var SubmitBugReportRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.submit_bug_report" /* SUBMIT_BUG_REPORT */),
+  params: SubmitBugReportRequestParamsSchema
+});
+var ClientRequestSchema = z5.discriminatedUnion("method", [
+  InitializeSessionRequestSchema,
+  LoadSessionRequestSchema,
+  AddUserMessageRequestSchema,
+  InterruptSessionRequestSchema,
+  KillWorkerSessionRequestSchema,
+  UpdateSessionSettingsRequestSchema,
+  ToggleMcpServerRequestSchema,
+  AuthenticateMcpServerRequestSchema,
+  CancelMcpAuthRequestSchema,
+  ClearMcpAuthRequestSchema,
+  SubmitMcpAuthCodeRequestSchema,
+  AddMcpServerRequestSchema,
+  RemoveMcpServerRequestSchema,
+  ListMcpRegistryRequestSchema,
+  ListMcpToolsRequestSchema,
+  ListMcpServersRequestSchema,
+  ToggleMcpToolRequestSchema,
+  ListSkillsRequestSchema,
+  SubmitBugReportRequestSchema
+]);
+var MissionSnapshotSchema = z5.object({
+  state: z5.nativeEnum(MissionState),
+  features: z5.array(MissionFeatureSchema),
+  progressLog: z5.array(ProgressLogEntrySchema),
+  workerSessionIds: z5.array(z5.string()),
+  workerStates: z5.record(WorkerStateInfoSchema).optional(),
+  tokenUsage: TokenUsageSchema.optional(),
+  tokenUsageBySessionId: z5.record(TokenUsageSchema).optional()
+}).passthrough();
+var InitializeSessionResultSchema = z5.object({
+  sessionId: z5.string(),
+  session: z5.record(z5.unknown()),
+  mcpServers: z5.array(McpServerConfigSchema).optional(),
+  settings: SessionSettingsSchema,
+  gitRepo: GitRepoInfoSchema.optional(),
+  availableModels: z5.array(AvailableModelConfigSchema).optional()
+}).passthrough();
+var LoadSessionResultSchema = z5.object({
+  session: z5.record(z5.unknown()),
+  mcpServers: z5.array(McpServerConfigSchema).optional(),
+  pendingPermissions: z5.array(z5.record(z5.unknown())).optional(),
+  pendingAskUserRequests: z5.array(z5.record(z5.unknown())).optional(),
+  settings: SessionSettingsSchema,
+  isAgentLoopInProgress: z5.boolean().optional(),
+  queuedMessages: z5.array(z5.record(z5.unknown())).optional(),
+  gitRepo: GitRepoInfoSchema.optional(),
+  cwd: z5.string().optional(),
+  callingSessionId: z5.string().optional(),
+  callingToolUseId: z5.string().optional(),
+  availableModels: z5.array(AvailableModelConfigSchema).optional(),
+  tokenUsage: TokenUsageSchema.optional(),
+  mission: MissionSnapshotSchema.optional(),
+  decompSessionType: z5.nativeEnum(DecompSessionType).optional()
+}).passthrough();
+var AddUserMessageResultSchema = z5.object({}).passthrough();
+var InterruptSessionResultSchema = z5.object({}).passthrough();
+var KillWorkerSessionResultSchema = z5.object({}).passthrough();
+var UpdateSessionSettingsResultSchema = z5.object({}).passthrough();
+var ToggleMcpServerResultSchema = z5.object({ success: z5.boolean() }).passthrough();
+var AuthenticateMcpServerResultSchema = z5.object({ success: z5.boolean() }).passthrough();
+var CancelMcpAuthResultSchema = z5.object({ success: z5.boolean() }).passthrough();
+var ClearMcpAuthResultSchema = z5.object({ success: z5.boolean() }).passthrough();
+var SubmitMcpAuthCodeResultSchema = z5.object({ success: z5.boolean() }).passthrough();
+var AddMcpServerResultSchema = z5.object({ success: z5.boolean() }).passthrough();
+var RemoveMcpServerResultSchema = z5.object({ success: z5.boolean() }).passthrough();
+var ListMcpRegistryResultSchema = z5.object({ servers: z5.array(McpRegistryServerSchema) }).passthrough();
+var ListMcpToolsResultSchema = z5.object({ tools: z5.array(McpToolInfoSchema) }).passthrough();
+var ListMcpServersResultSchema = z5.object({
+  servers: z5.array(McpServerStatusInfoSchema),
+  summary: McpStatusSummarySchema
+}).passthrough();
+var ToggleMcpToolResultSchema = z5.object({ success: z5.boolean() }).passthrough();
+var ListSkillsResultSchema = z5.object({ skills: z5.array(SkillInfoSchema) }).passthrough();
+var SubmitBugReportResultSchema = z5.object({ bugReportId: z5.string() }).passthrough();
+var InitializeSessionResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({
+    result: InitializeSessionResultSchema
+  }),
+  JsonRpcResponseFailureSchema
+]);
+var _LoadSessionResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({ result: LoadSessionResultSchema }),
+  JsonRpcResponseFailureSchema
+]);
+var LoadSessionResponseSchema = _LoadSessionResponseSchema;
+var AddUserMessageResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({ result: AddUserMessageResultSchema }),
+  JsonRpcResponseFailureSchema
+]);
+var InterruptSessionResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({
+    result: InterruptSessionResultSchema
+  }),
+  JsonRpcResponseFailureSchema
+]);
+var KillWorkerSessionResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({
+    result: KillWorkerSessionResultSchema
+  }),
+  JsonRpcResponseFailureSchema
+]);
+var UpdateSessionSettingsResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({
+    result: UpdateSessionSettingsResultSchema
+  }),
+  JsonRpcResponseFailureSchema
+]);
+var ToggleMcpServerResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({
+    result: ToggleMcpServerResultSchema
+  }),
+  JsonRpcResponseFailureSchema
+]);
+var AuthenticateMcpServerResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({
+    result: AuthenticateMcpServerResultSchema
+  }),
+  JsonRpcResponseFailureSchema
+]);
+var CancelMcpAuthResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({ result: CancelMcpAuthResultSchema }),
+  JsonRpcResponseFailureSchema
+]);
+var ClearMcpAuthResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({ result: ClearMcpAuthResultSchema }),
+  JsonRpcResponseFailureSchema
+]);
+var SubmitMcpAuthCodeResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({
+    result: SubmitMcpAuthCodeResultSchema
+  }),
+  JsonRpcResponseFailureSchema
+]);
+var AddMcpServerResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({ result: AddMcpServerResultSchema }),
+  JsonRpcResponseFailureSchema
+]);
+var RemoveMcpServerResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({ result: RemoveMcpServerResultSchema }),
+  JsonRpcResponseFailureSchema
+]);
+var ListMcpRegistryResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({
+    result: ListMcpRegistryResultSchema
+  }),
+  JsonRpcResponseFailureSchema
+]);
+var ListMcpToolsResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({ result: ListMcpToolsResultSchema }),
+  JsonRpcResponseFailureSchema
+]);
+var ListMcpServersResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({ result: ListMcpServersResultSchema }),
+  JsonRpcResponseFailureSchema
+]);
+var ToggleMcpToolResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({ result: ToggleMcpToolResultSchema }),
+  JsonRpcResponseFailureSchema
+]);
+var ListSkillsResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({ result: ListSkillsResultSchema }),
+  JsonRpcResponseFailureSchema
+]);
+var SubmitBugReportResponseSchema = z5.union([
+  JsonRpcResponseSuccessSchema.extend({ result: SubmitBugReportResultSchema }),
+  JsonRpcResponseFailureSchema
+]);
+
+// src/schemas/server.ts
+import { z as z6 } from "zod";
+var ToolUseSchema = z6.object({
+  type: z6.literal("tool_use"),
+  id: z6.string(),
+  input: z6.record(z6.unknown()),
+  name: z6.string(),
+  thoughtSignature: z6.string().optional()
+}).passthrough();
+var ErrorDetailSchema = z6.object({
+  name: z6.string(),
+  message: z6.string()
+}).passthrough();
+var ToolProgressUpdateSchema = z6.object({
+  type: z6.enum(["tool_call", "tool_result", "error", "status", "message"]),
+  toolName: z6.string().optional(),
+  status: z6.string().optional(),
+  details: z6.string().optional(),
+  text: z6.string().optional(),
+  error: z6.string().optional(),
+  timestamp: z6.number().optional(),
+  parameters: z6.record(z6.unknown()).optional(),
+  valueSnippet: z6.string().optional(),
+  subagentSessionId: z6.string().optional()
+}).passthrough();
+var SettingsUpdatedPayloadSchema = z6.object({
+  autonomyMode: z6.nativeEnum(AutonomyMode).optional(),
+  interactionMode: z6.nativeEnum(DroidInteractionMode).optional().catch(void 0),
+  autonomyLevel: z6.nativeEnum(AutonomyLevel).optional().catch(void 0),
+  modelId: z6.string().optional(),
+  reasoningEffort: z6.nativeEnum(ReasoningEffort).optional(),
+  specModeModelId: z6.string().optional(),
+  specModeReasoningEffort: z6.nativeEnum(ReasoningEffort).optional()
+}).passthrough();
+var ToolResultNotificationSchema = z6.object({
+  type: z6.literal("tool_result" /* TOOL_RESULT */),
+  messageId: z6.string(),
+  toolUseId: z6.string(),
+  content: z6.unknown().optional(),
+  isError: z6.boolean().optional(),
+  id: z6.string().optional()
+}).passthrough();
+var ToolProgressUpdateNotificationSchema = z6.object({
+  type: z6.literal("tool_progress_update" /* TOOL_PROGRESS_UPDATE */),
+  toolUseId: z6.string(),
+  toolName: z6.string(),
+  update: ToolProgressUpdateSchema
+}).passthrough();
+var CreateMessageNotificationSchema = z6.object({
+  type: z6.literal("create_message" /* CREATE_MESSAGE */),
+  message: FactoryDroidMessageSchema,
+  parentId: z6.string().optional(),
+  requestId: z6.string().optional()
+}).passthrough();
+var ErrorNotificationSchema = z6.object({
+  type: z6.literal("error" /* ERROR */),
+  message: z6.string(),
+  errorType: z6.nativeEnum(DroidErrorType),
+  timestamp: z6.string(),
+  error: ErrorDetailSchema.optional()
+}).passthrough();
+var DroidWorkingStateChangedNotificationSchema = z6.object({
+  type: z6.literal("droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */),
+  newState: z6.nativeEnum(DroidWorkingState)
+}).passthrough();
+var PermissionResolvedNotificationSchema = z6.object({
+  type: z6.literal("permission_resolved" /* PERMISSION_RESOLVED */),
+  requestId: z6.string(),
+  toolUseIds: z6.array(z6.string()),
+  selectedOption: z6.nativeEnum(ToolConfirmationOutcome)
+}).passthrough();
+var SettingsUpdatedNotificationSchema = z6.object({
+  type: z6.literal("settings_updated" /* SETTINGS_UPDATED */),
+  settings: SettingsUpdatedPayloadSchema
+}).passthrough();
+var SessionTitleUpdatedNotificationSchema = z6.object({
+  type: z6.literal("session_title_updated" /* SESSION_TITLE_UPDATED */),
+  title: z6.string()
+}).passthrough();
+var McpStatusChangedNotificationSchema = z6.object({
+  type: z6.literal("mcp_status_changed" /* MCP_STATUS_CHANGED */),
+  servers: z6.array(McpServerStatusInfoSchema),
+  summary: McpStatusSummarySchema
+}).passthrough();
+var AssistantTextDeltaNotificationSchema = z6.object({
+  type: z6.literal("assistant_text_delta" /* ASSISTANT_TEXT_DELTA */),
+  messageId: z6.string(),
+  blockIndex: z6.number(),
+  textDelta: z6.string()
+}).passthrough();
+var ThinkingTextDeltaNotificationSchema = z6.object({
+  type: z6.literal("thinking_text_delta" /* THINKING_TEXT_DELTA */),
+  messageId: z6.string(),
+  blockIndex: z6.number(),
+  textDelta: z6.string()
+}).passthrough();
+var SessionTokenUsageChangedNotificationSchema = z6.object({
+  type: z6.literal("session_token_usage_changed" /* SESSION_TOKEN_USAGE_CHANGED */),
+  sessionId: z6.string(),
+  tokenUsage: TokenUsageSchema
+}).passthrough();
+var MissionStateChangedNotificationSchema = z6.object({
+  type: z6.literal("mission_state_changed" /* MISSION_STATE_CHANGED */),
+  state: z6.nativeEnum(MissionState)
+}).passthrough();
+var MissionFeaturesChangedNotificationSchema = z6.object({
+  type: z6.literal("mission_features_changed" /* MISSION_FEATURES_CHANGED */),
+  features: z6.array(MissionFeatureSchema)
+}).passthrough();
+var MissionProgressEntryNotificationSchema = z6.object({
+  type: z6.literal("mission_progress_entry" /* MISSION_PROGRESS_ENTRY */),
+  progressLog: z6.array(ProgressLogEntrySchema)
+}).passthrough();
+var MissionHeartbeatNotificationSchema = z6.object({
+  type: z6.literal("mission_heartbeat" /* MISSION_HEARTBEAT */),
+  timestamp: z6.string()
+}).passthrough();
+var MissionWorkerStartedNotificationSchema = z6.object({
+  type: z6.literal("mission_worker_started" /* MISSION_WORKER_STARTED */),
+  workerSessionId: z6.string()
+}).passthrough();
+var MissionWorkerCompletedNotificationSchema = z6.object({
+  type: z6.literal("mission_worker_completed" /* MISSION_WORKER_COMPLETED */),
+  workerSessionId: z6.string(),
+  exitCode: z6.number()
+}).passthrough();
+var McpAuthRequiredNotificationSchema = z6.object({
+  type: z6.literal("mcp_auth_required" /* MCP_AUTH_REQUIRED */),
+  serverName: z6.string(),
+  authUrl: z6.string(),
+  message: z6.string(),
+  state: z6.string()
+}).passthrough();
+var McpAuthCompletedNotificationSchema = z6.object({
+  type: z6.literal("mcp_auth_completed" /* MCP_AUTH_COMPLETED */),
+  serverName: z6.string(),
+  outcome: z6.nativeEnum(McpAuthOutcome),
+  message: z6.string()
+}).passthrough();
+var SessionNotificationSchemaList = [
+  ToolResultNotificationSchema,
+  ToolProgressUpdateNotificationSchema,
+  CreateMessageNotificationSchema,
+  ErrorNotificationSchema,
+  DroidWorkingStateChangedNotificationSchema,
+  PermissionResolvedNotificationSchema,
+  SettingsUpdatedNotificationSchema,
+  SessionTitleUpdatedNotificationSchema,
+  McpStatusChangedNotificationSchema,
+  AssistantTextDeltaNotificationSchema,
+  ThinkingTextDeltaNotificationSchema,
+  SessionTokenUsageChangedNotificationSchema,
+  MissionStateChangedNotificationSchema,
+  MissionFeaturesChangedNotificationSchema,
+  MissionProgressEntryNotificationSchema,
+  MissionHeartbeatNotificationSchema,
+  MissionWorkerStartedNotificationSchema,
+  MissionWorkerCompletedNotificationSchema,
+  McpAuthRequiredNotificationSchema,
+  McpAuthCompletedNotificationSchema
+];
+var SessionNotificationPayloadSchema = z6.discriminatedUnion(
+  "type",
+  SessionNotificationSchemaList
+);
+var SessionNotificationParamsSchema = z6.object({
+  notification: SessionNotificationPayloadSchema
+}).passthrough();
+var SessionNotificationSchema = JsonRpcNotificationSchema.extend({
+  method: z6.literal("droid.session_notification" /* SESSION_NOTIFICATION */),
+  params: SessionNotificationParamsSchema
+});
+var EditToolConfirmationDetailsSchema = z6.object({
+  type: z6.literal("edit" /* Edit */),
+  filePath: z6.string(),
+  fileName: z6.string(),
+  oldContent: z6.string().optional(),
+  newContent: z6.string().optional()
+}).passthrough();
+var ExecuteToolConfirmationDetailsSchema = z6.object({
+  type: z6.literal("exec" /* Execute */),
+  fullCommand: z6.string(),
+  command: z6.string(),
+  extractedCommands: z6.array(z6.string()).optional(),
+  impactLevel: z6.string().optional()
+}).passthrough();
+var CreateToolConfirmationDetailsSchema = z6.object({
+  type: z6.literal("create" /* Create */),
+  filePath: z6.string(),
+  fileName: z6.string(),
+  content: z6.string()
+}).passthrough();
+var AskUserQuestionSchema = z6.object({
+  index: z6.number(),
+  topic: z6.string(),
+  question: z6.string(),
+  options: z6.array(z6.string())
+}).passthrough();
+var AskUserConfirmationDetailsSchema = z6.object({
+  type: z6.literal("ask_user" /* AskUser */),
+  questionnaire: z6.string(),
+  parsed: z6.object({
+    questions: z6.array(AskUserQuestionSchema)
+  }).optional(),
+  parseError: z6.object({
+    message: z6.string(),
+    line: z6.number().optional()
+  }).optional()
+}).passthrough();
+var ExitSpecModeConfirmationDetailsSchema = z6.object({
+  type: z6.literal("exit_spec_mode" /* ExitSpecMode */),
+  plan: z6.string(),
+  title: z6.string().optional(),
+  optionNames: z6.array(z6.string()).optional()
+}).passthrough();
+var ProposeMissionConfirmationDetailsSchema = z6.object({
+  type: z6.literal("propose_mission" /* ProposeMission */),
+  proposal: z6.string(),
+  title: z6.string().optional()
+}).passthrough();
+var StartMissionRunConfirmationDetailsSchema = z6.object({
+  type: z6.literal("start_mission_run" /* StartMissionRun */),
+  runningMissionCount: z6.number(),
+  runningMissionSessionIds: z6.array(z6.string())
+}).passthrough();
+var ApplyPatchToolConfirmationDetailsSchema = z6.object({
+  type: z6.literal("apply_patch" /* ApplyPatch */),
+  filePath: z6.string(),
+  fileName: z6.string(),
+  patchContent: z6.string(),
+  oldContent: z6.string().optional(),
+  newContent: z6.string().optional()
+}).passthrough();
+var McpToolConfirmationDetailsSchema = z6.object({
+  type: z6.literal("mcp_tool" /* McpTool */),
+  toolName: z6.string(),
+  impactLevel: z6.string()
+}).passthrough();
+var ToolConfirmationDetailsSchema = z6.discriminatedUnion("type", [
+  EditToolConfirmationDetailsSchema,
+  ExecuteToolConfirmationDetailsSchema,
+  CreateToolConfirmationDetailsSchema,
+  AskUserConfirmationDetailsSchema,
+  ExitSpecModeConfirmationDetailsSchema,
+  ProposeMissionConfirmationDetailsSchema,
+  StartMissionRunConfirmationDetailsSchema,
+  ApplyPatchToolConfirmationDetailsSchema,
+  McpToolConfirmationDetailsSchema
+]);
+var ToolConfirmationInfoSchema = z6.object({
+  toolUse: ToolUseSchema,
+  confirmationType: z6.nativeEnum(ToolConfirmationType),
+  details: ToolConfirmationDetailsSchema
+}).passthrough();
+var RequestPermissionRequestParamsSchema = z6.object({
+  toolUses: z6.array(ToolConfirmationInfoSchema),
+  options: z6.array(ToolConfirmationListItemSchema)
+}).passthrough();
+var RequestPermissionRequestSchema = JsonRpcRequestSchema.extend({
+  method: z6.literal("droid.request_permission" /* REQUEST_PERMISSION */),
+  params: RequestPermissionRequestParamsSchema
+});
+var RequestPermissionResultSchema = z6.object({
+  selectedOption: z6.nativeEnum(ToolConfirmationOutcome)
+}).strict();
+var RequestPermissionResponseSchema = z6.union([
+  JsonRpcResponseSuccessSchema.extend({
+    result: RequestPermissionResultSchema
+  }),
+  JsonRpcResponseFailureSchema
+]);
+var AskUserRequestParamsSchema = z6.object({
+  toolCallId: z6.string(),
+  questions: z6.array(AskUserQuestionSchema)
+}).passthrough();
+var AskUserRequestSchema = JsonRpcRequestSchema.extend({
+  method: z6.literal("droid.ask_user" /* ASK_USER */),
+  params: AskUserRequestParamsSchema
+});
+var AskUserCollectedAnswerSchema = z6.object({
+  index: z6.number(),
+  question: z6.string(),
+  answer: z6.string()
+}).strict();
+var AskUserResultSchema = z6.object({
+  cancelled: z6.boolean().optional(),
+  answers: z6.array(AskUserCollectedAnswerSchema)
+}).strict();
+var AskUserResponseSchema = z6.union([
+  JsonRpcResponseSuccessSchema.extend({ result: AskUserResultSchema }),
+  JsonRpcResponseFailureSchema
+]);
+var CliRequestOrNotificationSchema = z6.union([
+  SessionNotificationSchema,
+  RequestPermissionRequestSchema,
+  AskUserRequestSchema
+]);
+
+// src/errors.ts
+var ConnectionError = class _ConnectionError extends Error {
+  /** The working directory used when spawning the process. */
+  cwd;
+  /** The executable path used when spawning the process. */
+  execPath;
+  constructor(message, options) {
+    super(message);
+    this.name = "ConnectionError";
+    this.cwd = options?.cwd ?? "";
+    this.execPath = options?.execPath ?? "";
+    Object.setPrototypeOf(this, _ConnectionError.prototype);
+  }
+};
+var ProtocolError = class _ProtocolError extends Error {
+  /** The JSON-RPC error code, if available. */
+  code;
+  /** Additional error data from the JSON-RPC response. */
+  data;
+  constructor(message, options) {
+    super(message);
+    this.name = "ProtocolError";
+    this.code = options?.code;
+    this.data = options?.data;
+    Object.setPrototypeOf(this, _ProtocolError.prototype);
+  }
+};
+var SessionError = class _SessionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SessionError";
+    Object.setPrototypeOf(this, _SessionError.prototype);
+  }
+};
+var SessionNotFoundError = class _SessionNotFoundError extends SessionError {
+  /** The ID of the session that was not found. */
+  sessionId;
+  constructor(sessionId) {
+    super(`Session not found: ${sessionId}`);
+    this.name = "SessionNotFoundError";
+    this.sessionId = sessionId;
+    Object.setPrototypeOf(this, _SessionNotFoundError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+var ProcessExitError = class _ProcessExitError extends Error {
+  /** The exit code of the process, or null if terminated by signal. */
+  exitCode;
+  /** The signal that terminated the process, or null if exited normally. */
+  signal;
+  constructor(message, options) {
+    super(message);
+    this.name = "ProcessExitError";
+    this.exitCode = options?.exitCode ?? null;
+    this.signal = options?.signal ?? null;
+    Object.setPrototypeOf(this, _ProcessExitError.prototype);
+  }
+};
+
+// src/transport.ts
+import { spawn } from "child_process";
+import * as readline from "readline";
+var DEFAULT_EXEC_ARGS = [
+  "exec",
+  "--input-format",
+  "stream-jsonrpc",
+  "--output-format",
+  "stream-jsonrpc"
+];
+var DEFAULT_GRACE_PERIOD_MS = 5e3;
+var ProcessTransport = class {
+  execPath;
+  execArgs;
+  cwd;
+  env;
+  gracePeriodMs;
+  childProcess = null;
+  readlineInterface = null;
+  messageHandler = null;
+  errorHandler = null;
+  /**
+   * Sticky error from a process error or unexpected exit. Once set,
+   * all subsequent `send()` calls throw immediately.
+   */
+  processError = null;
+  /** Promise-chain serializer for stdin writes. */
+  writeChain = Promise.resolve();
+  _isConnected = false;
+  isClosing = false;
+  constructor(options = {}) {
+    this.execPath = options.execPath ?? "droid";
+    this.execArgs = options.execArgs ? [...options.execArgs] : [...DEFAULT_EXEC_ARGS];
+    this.cwd = options.cwd;
+    this.env = options.env;
+    this.gracePeriodMs = (options.gracePeriod ?? DEFAULT_GRACE_PERIOD_MS / 1e3) * 1e3;
+  }
+  // -----------------------------------------------------------------------
+  // DroidClientTransport interface
+  // -----------------------------------------------------------------------
+  get isConnected() {
+    return this._isConnected;
+  }
+  async connect() {
+    if (this._isConnected) {
+      throw new ConnectionError("Transport already connected", {
+        execPath: this.execPath
+      });
+    }
+    this.processError = null;
+    this.isClosing = false;
+    this.writeChain = Promise.resolve();
+    const mergedEnv = this.env ? { ...process.env, ...this.env } : void 0;
+    try {
+      this.childProcess = spawn(this.execPath, this.execArgs, {
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: this.cwd,
+        env: mergedEnv
+      });
+    } catch (err) {
+      const message = err instanceof Error ? `Failed to start droid process: ${err.message}` : "Failed to start droid process";
+      throw new ConnectionError(message, {
+        execPath: this.execPath,
+        cwd: this.cwd
+      });
+    }
+    this._isConnected = true;
+    this.setupHandlers();
+  }
+  send(message) {
+    if (this.processError) {
+      throw this.processError;
+    }
+    if (!this._isConnected || !this.childProcess || !this.childProcess.stdin) {
+      throw new ConnectionError("Transport not connected", {
+        execPath: this.execPath
+      });
+    }
+    const line = JSON.stringify(message) + "\n";
+    const previousChain = this.writeChain;
+    this.writeChain = (async () => {
+      await previousChain.catch(() => {
+      });
+      if (!this.childProcess || !this.childProcess.stdin || this.childProcess.killed || this.isClosing) {
+        throw new ConnectionError("Process disconnected before write", {
+          execPath: this.execPath
+        });
+      }
+      if (this.processError) {
+        throw this.processError;
+      }
+      await new Promise((resolve, reject) => {
+        if (!this.childProcess || !this.childProcess.stdin) {
+          reject(
+            new ConnectionError("Process stdin unavailable", {
+              execPath: this.execPath
+            })
+          );
+          return;
+        }
+        const stdin = this.childProcess.stdin;
+        if ("writable" in stdin && !stdin.writable) {
+          reject(
+            new ConnectionError("Process stdin is not writable", {
+              execPath: this.execPath
+            })
+          );
+          return;
+        }
+        stdin.write(line, (error) => {
+          if (error) {
+            const msg = error.message || String(error);
+            if (msg.includes("EPIPE") || msg.includes("ECONNRESET")) {
+              reject(
+                new ConnectionError("Process stdin closed during write", {
+                  execPath: this.execPath
+                })
+              );
+            } else {
+              reject(
+                new ConnectionError(
+                  `Failed to write to process stdin: ${msg}`,
+                  { execPath: this.execPath }
+                )
+              );
+            }
+          } else {
+            resolve();
+          }
+        });
+      });
+    })();
+  }
+  onMessage(callback) {
+    this.messageHandler = callback;
+  }
+  onError(callback) {
+    this.errorHandler = callback;
+  }
+  async close() {
+    if (this.isClosing) {
+      return;
+    }
+    this.isClosing = true;
+    this._isConnected = false;
+    const proc = this.childProcess;
+    this.childProcess = null;
+    if (this.readlineInterface) {
+      this.readlineInterface.close();
+      this.readlineInterface = null;
+    }
+    if (proc && proc.exitCode === null && !proc.killed) {
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          if (proc.exitCode === null && !proc.killed) {
+            try {
+              proc.kill("SIGKILL");
+            } catch {
+            }
+          }
+        }, this.gracePeriodMs);
+        proc.once("exit", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+        if (proc.stdin) {
+          try {
+            proc.stdin.end();
+          } catch {
+          }
+        }
+        try {
+          proc.kill("SIGTERM");
+        } catch {
+          clearTimeout(timeout);
+          resolve();
+        }
+      });
+    }
+    this.isClosing = false;
+  }
+  // -----------------------------------------------------------------------
+  // Private helpers
+  // -----------------------------------------------------------------------
+  setupHandlers() {
+    const proc = this.childProcess;
+    if (!proc || !proc.stdout) {
+      return;
+    }
+    this.readlineInterface = readline.createInterface({
+      input: proc.stdout,
+      crlfDelay: Infinity
+    });
+    this.readlineInterface.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        return;
+      }
+      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+          const parsed = JSON.parse(trimmed);
+          if (this.messageHandler && typeof parsed === "object" && parsed !== null) {
+            this.messageHandler(parsed);
+          }
+        } catch {
+        }
+      }
+    });
+    proc.on("error", (error) => {
+      this.processError = new ConnectionError(
+        `Failed to start droid process: ${error.message}`,
+        {
+          execPath: this.execPath,
+          cwd: this.cwd
+        }
+      );
+      this._isConnected = false;
+      if (!this.isClosing && this.errorHandler) {
+        this.errorHandler(this.processError);
+      }
+    });
+    proc.on("exit", (code, signal) => {
+      if (this.readlineInterface) {
+        this.readlineInterface.close();
+        this.readlineInterface = null;
+      }
+      this._isConnected = false;
+      if (!this.isClosing) {
+        const exitCode = code ?? null;
+        const exitSignal = signal ?? null;
+        let message;
+        if (exitSignal) {
+          message = `Droid process was killed (${exitSignal})`;
+        } else if (exitCode !== null && exitCode !== 0) {
+          message = `Droid process exited unexpectedly (exit code ${exitCode})`;
+        } else if (exitCode === 0) {
+          message = "Droid process exited normally";
+        } else {
+          message = "Droid process exited unexpectedly";
+        }
+        this.processError = new ProcessExitError(message, {
+          exitCode,
+          signal: exitSignal
+        });
+        if (this.errorHandler) {
+          this.errorHandler(this.processError);
+        }
+      }
+    });
+  }
+};
+
+// src/protocol.ts
+import { v4 as uuidv4 } from "uuid";
+var ProtocolEngine = class {
+  _transport;
+  _defaultTimeout;
+  /** Pending requests keyed by UUID string. */
+  _pendingRequests = /* @__PURE__ */ new Map();
+  /** Notification listener registry. */
+  _notificationListeners = /* @__PURE__ */ new Set();
+  /** Server→client request handlers. */
+  _permissionHandler = null;
+  _askUserHandler = null;
+  /** Sticky transport error — once set, all requests fail immediately. */
+  _transportError = null;
+  /** Closed flag — once true, new requests are rejected. */
+  _closed = false;
+  /**
+   * Create a new ProtocolEngine.
+   *
+   * @param options.transport - A connected DroidClientTransport implementation.
+   * @param options.defaultTimeout - Default timeout in ms for sendRequest (default 30 000).
+   */
+  constructor(options) {
+    this._transport = options.transport;
+    this._defaultTimeout = options.defaultTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+    this._transport.onMessage((message) => {
+      this._handleMessage(message);
+    });
+    this._transport.onError((error) => {
+      this._handleTransportError(error);
+    });
+  }
+  // ------------------------------------------------------------------
+  // Public API: Sending requests
+  // ------------------------------------------------------------------
+  /**
+   * Send a JSON-RPC request and wait for the response.
+   *
+   * Constructs the full envelope, registers a pending promise, sends
+   * via transport, and returns the parsed response `result` field.
+   *
+   * @param method - The RPC method name (e.g. `"droid.list_skills"`).
+   * @param params - Method parameters object.
+   * @param timeout - Timeout in ms. Defaults to `defaultTimeout`.
+   * @returns The `result` field from the JSON-RPC success response.
+   * @throws {ConnectionError} If the engine is closed.
+   * @throws {ConnectionError} If the transport has a sticky error.
+   * @throws {TimeoutError} If no response arrives within the timeout.
+   * @throws {ProtocolError} If the response contains a protocol error.
+   * @throws {SessionNotFoundError} If error code is ENTITY_NOT_FOUND.
+   */
+  async sendRequest(method, params, timeout) {
+    if (this._closed) {
+      throw new ConnectionError("Protocol engine is closed");
+    }
+    if (this._transportError !== null) {
+      throw new ConnectionError(
+        `Transport error: ${this._transportError.message}`
+      );
+    }
+    const effectiveTimeout = timeout ?? this._defaultTimeout;
+    const requestId = uuidv4();
+    const envelope = {
+      jsonrpc: JSONRPC_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      id: requestId,
+      method,
+      params
+    };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._pendingRequests.delete(requestId);
+        reject(
+          new TimeoutError(
+            `Request ${method} timed out after ${effectiveTimeout}ms`
+          )
+        );
+      }, effectiveTimeout);
+      const pending = {
+        method,
+        requestId,
+        params,
+        resolve,
+        reject,
+        timer
+      };
+      this._pendingRequests.set(requestId, pending);
+      try {
+        this._transport.send(envelope);
+      } catch (sendError) {
+        clearTimeout(timer);
+        this._pendingRequests.delete(requestId);
+        if (sendError instanceof Error) {
+          reject(
+            new ConnectionError(`Failed to send request: ${sendError.message}`)
+          );
+        } else {
+          reject(new ConnectionError("Failed to send request"));
+        }
+      }
+    });
+  }
+  // ------------------------------------------------------------------
+  // Public API: Notification listeners
+  // ------------------------------------------------------------------
+  /**
+   * Register a callback for incoming notification messages.
+   *
+   * Multiple listeners can be registered. Each receives the full
+   * parsed notification object.
+   *
+   * @param callback - Invoked with the notification object.
+   * @param filter - Optional filter to only receive specific notification types.
+   * @returns An unsubscribe function. Calling it again is safe (no-op).
+   */
+  onNotification(callback, filter) {
+    const listener = { callback, filter };
+    this._notificationListeners.add(listener);
+    let unsubscribed = false;
+    return () => {
+      if (!unsubscribed) {
+        unsubscribed = true;
+        this._notificationListeners.delete(listener);
+      }
+    };
+  }
+  // ------------------------------------------------------------------
+  // Public API: Server→client request handlers
+  // ------------------------------------------------------------------
+  /**
+   * Register a handler for server→client permission requests.
+   *
+   * The handler receives the request params and should return a
+   * ToolConfirmationOutcome string value.
+   *
+   * Replaces any previously registered handler.
+   */
+  setPermissionHandler(handler) {
+    this._permissionHandler = handler;
+  }
+  /**
+   * Remove the permission request handler (restores default Cancel).
+   */
+  clearPermissionHandler() {
+    this._permissionHandler = null;
+  }
+  /**
+   * Register a handler for server→client ask-user requests.
+   *
+   * The handler receives the request params and should return
+   * a result object with `cancelled` and `answers` keys.
+   *
+   * Replaces any previously registered handler.
+   */
+  setAskUserHandler(handler) {
+    this._askUserHandler = handler;
+  }
+  /**
+   * Remove the ask-user request handler (restores default cancelled=true).
+   */
+  clearAskUserHandler() {
+    this._askUserHandler = null;
+  }
+  // ------------------------------------------------------------------
+  // Public API: Health check
+  // ------------------------------------------------------------------
+  /**
+   * Whether the engine is in a healthy state — not closed and no
+   * sticky transport error.
+   */
+  get isHealthy() {
+    return !this._closed && this._transportError === null;
+  }
+  // ------------------------------------------------------------------
+  // Public API: Close
+  // ------------------------------------------------------------------
+  /**
+   * Close the protocol engine.
+   *
+   * Rejects all pending requests, closes the transport, and prevents
+   * new requests. Idempotent — safe to call multiple times.
+   */
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    const error = new ConnectionError(
+      "Protocol engine closed: pending requests cancelled"
+    );
+    this._rejectAllPending(error);
+    this._permissionHandler = null;
+    this._askUserHandler = null;
+    this._notificationListeners.clear();
+    await this._transport.close();
+  }
+  // ------------------------------------------------------------------
+  // Internal: Message handling
+  // ------------------------------------------------------------------
+  /**
+   * Handle an incoming parsed message from the transport.
+   * Dispatches to response handler, notification handler, or
+   * server→client request handler based on message type.
+   */
+  _handleMessage(parsed) {
+    const msgType = parsed["type"];
+    if (msgType === "response") {
+      this._handleResponse(parsed);
+    } else if (msgType === "notification") {
+      this._handleNotification(parsed);
+    } else if (msgType === "request") {
+      void this._handleServerRequest(parsed);
+    } else {
+      if ("result" in parsed || "error" in parsed) {
+        this._handleResponse(parsed);
+      } else if ("method" in parsed && !("id" in parsed)) {
+        this._handleNotification(parsed);
+      } else if ("method" in parsed && "id" in parsed) {
+        void this._handleServerRequest(parsed);
+      }
+    }
+  }
+  /**
+   * Handle an incoming response message.
+   * Matches by ID to resolve the correct pending Promise.
+   */
+  _handleResponse(response) {
+    const responseId = response["id"];
+    if (responseId == null) {
+      return;
+    }
+    const pending = this._pendingRequests.get(responseId);
+    if (pending == null) {
+      return;
+    }
+    this._pendingRequests.delete(responseId);
+    clearTimeout(pending.timer);
+    const errorObj = response["error"];
+    if (errorObj != null && typeof errorObj === "object") {
+      const error = errorObj;
+      const code = error["code"];
+      const message = error["message"] ?? "Unknown error";
+      const data = error["data"];
+      if (code === -32004 /* ENTITY_NOT_FOUND */) {
+        const sessionId = String(
+          pending.params["sessionId"] ?? pending.requestId
+        );
+        pending.reject(new SessionNotFoundError(sessionId));
+        return;
+      }
+      pending.reject(new ProtocolError(message, { code, data }));
+      return;
+    }
+    pending.resolve(response);
+  }
+  /**
+   * Handle an incoming notification message.
+   * Dispatches to all registered notification listeners that match.
+   */
+  _handleNotification(notification) {
+    const params = notification["params"];
+    const innerNotification = params?.["notification"];
+    const notificationType = innerNotification?.["type"];
+    for (const listener of this._notificationListeners) {
+      if (listener.filter?.type != null && listener.filter.type !== notificationType) {
+        continue;
+      }
+      try {
+        listener.callback(notification);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Handle an incoming server→client request.
+   * Dispatches to the appropriate handler based on the method field.
+   */
+  async _handleServerRequest(request) {
+    const method = request["method"];
+    const requestId = request["id"];
+    const params = request["params"] ?? {};
+    if (method === "droid.request_permission" /* REQUEST_PERMISSION */) {
+      await this._handlePermissionRequest(requestId, params);
+    } else if (method === "droid.ask_user" /* ASK_USER */) {
+      await this._handleAskUserRequest(requestId, params);
+    }
+  }
+  /**
+   * Handle droid.request_permission server→client request.
+   */
+  async _handlePermissionRequest(requestId, params) {
+    const handler = this._permissionHandler;
+    if (handler == null) {
+      this._sendResponse(requestId, { selectedOption: "cancel" });
+      return;
+    }
+    try {
+      const selectedOption = await Promise.resolve(handler(params));
+      this._sendResponse(requestId, { selectedOption });
+    } catch (exc) {
+      const errorMessage = exc instanceof Error ? exc.message : String(exc);
+      this._sendErrorResponse(
+        requestId,
+        -32603 /* INTERNAL_ERROR */,
+        "Failed to handle permission request",
+        errorMessage
+      );
+    }
+  }
+  /**
+   * Handle droid.ask_user server→client request.
+   */
+  async _handleAskUserRequest(requestId, params) {
+    const handler = this._askUserHandler;
+    if (handler == null) {
+      this._sendResponse(requestId, { cancelled: true, answers: [] });
+      return;
+    }
+    try {
+      const result = await Promise.resolve(handler(params));
+      this._sendResponse(requestId, result);
+    } catch (exc) {
+      const errorMessage = exc instanceof Error ? exc.message : String(exc);
+      this._sendErrorResponse(
+        requestId,
+        -32603 /* INTERNAL_ERROR */,
+        "Failed to handle ask-user request",
+        errorMessage
+      );
+    }
+  }
+  // ------------------------------------------------------------------
+  // Internal: Transport error handling
+  // ------------------------------------------------------------------
+  /**
+   * Handle a transport error.
+   * Sets the sticky transport error and rejects all pending requests.
+   * The original error is preserved as `cause` on the ConnectionError.
+   */
+  _handleTransportError(error) {
+    this._transportError = error;
+    const connectionError = new ConnectionError(
+      `Transport error: ${error.message}`
+    );
+    connectionError.cause = error;
+    this._rejectAllPending(connectionError);
+  }
+  // ------------------------------------------------------------------
+  // Internal: Response helpers
+  // ------------------------------------------------------------------
+  /**
+   * Send a JSON-RPC success response back to the server.
+   */
+  _sendResponse(requestId, result) {
+    const response = {
+      jsonrpc: JSONRPC_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "response",
+      id: requestId,
+      result
+    };
+    try {
+      this._transport.send(response);
+    } catch {
+    }
+  }
+  /**
+   * Send a JSON-RPC error response back to the server.
+   */
+  _sendErrorResponse(requestId, code, message, data) {
+    const errorObj = { code, message };
+    if (data !== void 0) {
+      errorObj["data"] = data;
+    }
+    const response = {
+      jsonrpc: JSONRPC_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "response",
+      id: requestId,
+      error: errorObj
+    };
+    try {
+      this._transport.send(response);
+    } catch {
+    }
+  }
+  /**
+   * Reject all pending requests with the given error.
+   */
+  _rejectAllPending(error) {
+    const pending = new Map(this._pendingRequests);
+    this._pendingRequests.clear();
+    for (const req of pending.values()) {
+      clearTimeout(req.timer);
+      req.reject(error);
+    }
+  }
+};
+
+// src/client.ts
+var DroidClient = class {
+  _engine;
+  _sessionId = null;
+  _closed = false;
+  /**
+   * Client-level notification listeners.
+   * Each entry is [callback, optional type filter string].
+   */
+  _notificationListeners = [];
+  /** Client-level permission handler. */
+  _permissionHandler = null;
+  /** Client-level ask-user handler. */
+  _askUserHandler = null;
+  constructor(options) {
+    this._engine = new ProtocolEngine({
+      transport: options.transport,
+      defaultTimeout: options.defaultTimeout
+    });
+    this._engine.onNotification((notification) => {
+      this._dispatchNotification(notification);
+    });
+    this._engine.setPermissionHandler(
+      (params) => this._dispatchPermissionRequest(params)
+    );
+    this._engine.setAskUserHandler(
+      (params) => this._dispatchAskUserRequest(params)
+    );
+  }
+  // ------------------------------------------------------------------
+  // Properties
+  // ------------------------------------------------------------------
+  /**
+   * Current session ID, or `null` if no session is active.
+   */
+  get sessionId() {
+    return this._sessionId;
+  }
+  /**
+   * Whether the client is in a healthy state — not closed and no
+   * transport errors have occurred. Returns false after transport
+   * disconnect/error.
+   */
+  get isConnected() {
+    return !this._closed && this._engine.isHealthy;
+  }
+  // ------------------------------------------------------------------
+  // Session lifecycle methods
+  // ------------------------------------------------------------------
+  /**
+   * Initialize a new session.
+   *
+   * Sends `droid.initialize_session` with extended timeout. On success,
+   * stores the session ID internally and returns the typed result.
+   */
+  async initializeSession(params) {
+    this._ensureNotClosed();
+    const response = await this._engine.sendRequest(
+      "droid.initialize_session" /* INITIALIZE_SESSION */,
+      params,
+      SESSION_INIT_TIMEOUT
+    );
+    const result = response["result"];
+    if (result) {
+      this._sessionId = result.sessionId;
+      return result;
+    }
+    if ("sessionId" in response) {
+      this._sessionId = response["sessionId"];
+      return response;
+    }
+    return response;
+  }
+  /**
+   * Load an existing session.
+   *
+   * Sends `droid.load_session`. SessionNotFoundError is thrown for
+   * non-existent sessions (mapped from ENTITY_NOT_FOUND by the protocol engine).
+   */
+  async loadSession(params) {
+    this._ensureNotClosed();
+    const response = await this._engine.sendRequest(
+      "droid.load_session" /* LOAD_SESSION */,
+      params,
+      SESSION_INIT_TIMEOUT
+    );
+    const result = response["result"];
+    if (result) {
+      this._sessionId = params.sessionId;
+      return result;
+    }
+    this._sessionId = params.sessionId;
+    return response;
+  }
+  /**
+   * Add a user message to the active session.
+   *
+   * Sends `droid.add_user_message` with text and optional images/files.
+   */
+  async addUserMessage(params) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.add_user_message" /* ADD_USER_MESSAGE */,
+      params
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * Interrupt the current session.
+   *
+   * Sends `droid.interrupt_session` with empty params.
+   */
+  async interruptSession() {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.interrupt_session" /* INTERRUPT_SESSION */,
+      {}
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * Kill a worker session.
+   *
+   * Sends `droid.kill_worker_session`.
+   */
+  async killWorkerSession(params) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.kill_worker_session" /* KILL_WORKER_SESSION */,
+      params
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * Update session settings.
+   *
+   * Sends `droid.update_session_settings` with the provided partial settings.
+   */
+  async updateSessionSettings(params) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.update_session_settings" /* UPDATE_SESSION_SETTINGS */,
+      params
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  // ------------------------------------------------------------------
+  // MCP methods
+  // ------------------------------------------------------------------
+  /**
+   * Toggle an MCP server on or off.
+   */
+  async toggleMcpServer(params) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.toggle_mcp_server" /* TOGGLE_MCP_SERVER */,
+      params
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * Authenticate an MCP server (OAuth flow).
+   * Uses extended timeout (300s) since OAuth requires user interaction.
+   */
+  async authenticateMcpServer(params) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.authenticate_mcp_server" /* AUTHENTICATE_MCP_SERVER */,
+      params,
+      MCP_AUTH_TIMEOUT
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * Cancel an in-progress MCP authentication.
+   */
+  async cancelMcpAuth(params) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.cancel_mcp_auth" /* CANCEL_MCP_AUTH */,
+      params
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * Clear stored MCP authentication tokens.
+   */
+  async clearMcpAuth(params) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.clear_mcp_auth" /* CLEAR_MCP_AUTH */,
+      params
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * Submit an MCP authentication code (OAuth callback).
+   */
+  async submitMcpAuthCode(params) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.submit_mcp_auth_code" /* SUBMIT_MCP_AUTH_CODE */,
+      params
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * Add an MCP server.
+   */
+  async addMcpServer(params) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.add_mcp_server" /* ADD_MCP_SERVER */,
+      params
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * Remove an MCP server.
+   */
+  async removeMcpServer(params) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.remove_mcp_server" /* REMOVE_MCP_SERVER */,
+      params
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * List available MCP registry servers.
+   */
+  async listMcpRegistry() {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.list_mcp_registry" /* LIST_MCP_REGISTRY */,
+      {}
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * List available MCP tools.
+   */
+  async listMcpTools() {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.list_mcp_tools" /* LIST_MCP_TOOLS */,
+      {}
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * List MCP servers with status and summary.
+   */
+  async listMcpServers() {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.list_mcp_servers" /* LIST_MCP_SERVERS */,
+      {}
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * Toggle an MCP tool on or off.
+   */
+  async toggleMcpTool(params) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.toggle_mcp_tool" /* TOGGLE_MCP_TOOL */,
+      params
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  // ------------------------------------------------------------------
+  // Skills and bug report methods
+  // ------------------------------------------------------------------
+  /**
+   * List available skills.
+   */
+  async listSkills() {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.list_skills" /* LIST_SKILLS */,
+      {}
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  /**
+   * Submit a bug report.
+   */
+  async submitBugReport(params) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    const response = await this._engine.sendRequest(
+      "droid.submit_bug_report" /* SUBMIT_BUG_REPORT */,
+      params
+    );
+    const result = response["result"];
+    return result ?? response;
+  }
+  // ------------------------------------------------------------------
+  // Notification subscription
+  // ------------------------------------------------------------------
+  /**
+   * Register a callback for incoming notification messages.
+   *
+   * Multiple listeners can be registered. Each receives the full parsed
+   * notification object. Optionally filter by notification type.
+   *
+   * Listener exceptions are isolated — if one raises, others still receive
+   * the event and the engine continues.
+   *
+   * @param callback - Invoked with the notification object.
+   * @param filter - Optional filter to only receive specific notification types.
+   * @returns An unsubscribe function. Calling it again is safe (no-op).
+   */
+  onNotification(callback, filter) {
+    const entry = {
+      callback,
+      typeFilter: filter?.type
+    };
+    this._notificationListeners.push(entry);
+    let unsubscribed = false;
+    return () => {
+      if (!unsubscribed) {
+        unsubscribed = true;
+        const idx = this._notificationListeners.indexOf(entry);
+        if (idx !== -1) {
+          this._notificationListeners.splice(idx, 1);
+        }
+      }
+    };
+  }
+  // ------------------------------------------------------------------
+  // Permission/ask-user handler registration
+  // ------------------------------------------------------------------
+  /**
+   * Register a handler for server→client permission requests.
+   *
+   * The handler receives the request params and should return a
+   * ToolConfirmationOutcome string value. Async handlers are awaited.
+   * Replaces any previously registered handler.
+   */
+  setPermissionHandler(handler) {
+    this._permissionHandler = handler;
+  }
+  /**
+   * Remove the permission request handler.
+   * Restores default behavior: return "cancel".
+   */
+  clearPermissionHandler() {
+    this._permissionHandler = null;
+  }
+  /**
+   * Register a handler for server→client ask-user requests.
+   *
+   * The handler receives the request params and should return a result
+   * object with `cancelled` and `answers` keys. Async handlers are awaited.
+   * Replaces any previously registered handler.
+   */
+  setAskUserHandler(handler) {
+    this._askUserHandler = handler;
+  }
+  /**
+   * Remove the ask-user request handler.
+   * Restores default behavior: return `{ cancelled: true, answers: [] }`.
+   */
+  clearAskUserHandler() {
+    this._askUserHandler = null;
+  }
+  // ------------------------------------------------------------------
+  // Lifecycle
+  // ------------------------------------------------------------------
+  /**
+   * Close the client and release all resources.
+   *
+   * Rejects pending requests, clears handlers and listeners, and closes
+   * the protocol engine. Idempotent — safe to call multiple times.
+   *
+   * After close, all method calls throw ConnectionError immediately.
+   */
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    this._notificationListeners.length = 0;
+    this._permissionHandler = null;
+    this._askUserHandler = null;
+    await this._engine.close();
+  }
+  // ------------------------------------------------------------------
+  // Internal: dispatch methods
+  // ------------------------------------------------------------------
+  /**
+   * Dispatch a notification to all registered client-level listeners.
+   * Filters by notification type if a type filter is set.
+   * Exception in one listener does not affect others.
+   */
+  _dispatchNotification(notification) {
+    const params = notification["params"];
+    const innerNotification = params?.["notification"];
+    const notificationType = innerNotification?.["type"];
+    const listeners = [...this._notificationListeners];
+    for (const listener of listeners) {
+      if (listener.typeFilter != null && listener.typeFilter !== notificationType) {
+        continue;
+      }
+      try {
+        listener.callback(notification);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Dispatch to the client-level permission handler.
+   * If no handler is set, returns the default "cancel" outcome.
+   * If handler throws, the error propagates to the protocol engine
+   * which sends an error response.
+   */
+  _dispatchPermissionRequest(params) {
+    const handler = this._permissionHandler;
+    if (handler == null) {
+      return "cancel";
+    }
+    return handler(params);
+  }
+  /**
+   * Dispatch to the client-level ask-user handler.
+   * If no handler is set, returns the default cancelled response.
+   * If handler throws, the error propagates to the protocol engine
+   * which sends an error response.
+   */
+  _dispatchAskUserRequest(params) {
+    const handler = this._askUserHandler;
+    if (handler == null) {
+      return { cancelled: true, answers: [] };
+    }
+    return handler(params);
+  }
+  // ------------------------------------------------------------------
+  // Internal: guards
+  // ------------------------------------------------------------------
+  /**
+   * Throw ConnectionError if the client has been closed.
+   */
+  _ensureNotClosed() {
+    if (this._closed) {
+      throw new ConnectionError(
+        "Client has been closed. Create a new DroidClient instance to reconnect."
+      );
+    }
+  }
+  /**
+   * Throw SessionError if no active session.
+   */
+  _ensureSession() {
+    if (this._sessionId == null) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+  }
+};
+
+// src/stream.ts
+function convertNotificationToStreamMessage(notification) {
+  switch (notification.type) {
+    case "assistant_text_delta" /* ASSISTANT_TEXT_DELTA */:
+      return {
+        type: "assistant_text_delta",
+        messageId: notification.messageId,
+        blockIndex: notification.blockIndex,
+        text: notification.textDelta
+      };
+    case "thinking_text_delta" /* THINKING_TEXT_DELTA */:
+      return {
+        type: "thinking_text_delta",
+        messageId: notification.messageId,
+        blockIndex: notification.blockIndex,
+        text: notification.textDelta
+      };
+    case "tool_result" /* TOOL_RESULT */:
+      return {
+        type: "tool_result",
+        toolUseId: notification.toolUseId,
+        content: normalizeToolResultContent(notification.content),
+        isError: Boolean(notification.isError)
+      };
+    case "tool_progress_update" /* TOOL_PROGRESS_UPDATE */: {
+      const update = notification.update;
+      const text = update?.text ?? update?.status ?? update?.details ?? "";
+      return {
+        type: "tool_progress",
+        toolUseId: notification.toolUseId,
+        toolName: notification.toolName,
+        content: text,
+        update
+      };
+    }
+    case "droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */:
+      return {
+        type: "working_state_changed",
+        state: notification.newState
+      };
+    case "session_token_usage_changed" /* SESSION_TOKEN_USAGE_CHANGED */: {
+      const tu = notification.tokenUsage;
+      return {
+        type: "token_usage_update",
+        inputTokens: tu.inputTokens,
+        outputTokens: tu.outputTokens,
+        cacheReadTokens: tu.cacheReadTokens,
+        cacheWriteTokens: tu.cacheCreationTokens,
+        thinkingTokens: tu.thinkingTokens
+      };
+    }
+    case "create_message" /* CREATE_MESSAGE */: {
+      const msg = notification.message;
+      const messages = [];
+      if (msg.content && Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "tool_use") {
+            messages.push({
+              type: "tool_use",
+              toolName: block.name,
+              toolInput: block.input ?? {},
+              toolUseId: block.id
+            });
+          }
+        }
+      }
+      messages.push({
+        type: "create_message",
+        messageId: msg.id,
+        role: msg.role,
+        content: msg.content ?? [],
+        parentId: notification.parentId
+      });
+      return messages;
+    }
+    case "error" /* ERROR */:
+      return {
+        type: "error",
+        message: notification.message,
+        errorType: notification.errorType,
+        timestamp: notification.timestamp
+      };
+    case "permission_resolved" /* PERMISSION_RESOLVED */:
+      return {
+        type: "permission_resolved",
+        requestId: notification.requestId,
+        toolUseIds: notification.toolUseIds,
+        selectedOption: notification.selectedOption
+      };
+    case "settings_updated" /* SETTINGS_UPDATED */:
+      return {
+        type: "settings_updated",
+        settings: notification.settings
+      };
+    case "session_title_updated" /* SESSION_TITLE_UPDATED */:
+      return {
+        type: "session_title_updated",
+        title: notification.title
+      };
+    case "mcp_status_changed" /* MCP_STATUS_CHANGED */:
+      return {
+        type: "mcp_status_changed",
+        servers: notification.servers,
+        summary: notification.summary
+      };
+    case "mission_state_changed" /* MISSION_STATE_CHANGED */:
+      return {
+        type: "mission_state_changed",
+        state: notification.state
+      };
+    case "mission_features_changed" /* MISSION_FEATURES_CHANGED */:
+      return {
+        type: "mission_features_changed",
+        features: notification.features
+      };
+    case "mission_progress_entry" /* MISSION_PROGRESS_ENTRY */:
+      return {
+        type: "mission_progress_entry",
+        progressLog: notification.progressLog
+      };
+    case "mission_heartbeat" /* MISSION_HEARTBEAT */:
+      return {
+        type: "mission_heartbeat",
+        timestamp: notification.timestamp
+      };
+    case "mission_worker_started" /* MISSION_WORKER_STARTED */:
+      return {
+        type: "mission_worker_started",
+        workerSessionId: notification.workerSessionId
+      };
+    case "mission_worker_completed" /* MISSION_WORKER_COMPLETED */:
+      return {
+        type: "mission_worker_completed",
+        workerSessionId: notification.workerSessionId,
+        exitCode: notification.exitCode
+      };
+    case "mcp_auth_required" /* MCP_AUTH_REQUIRED */:
+      return {
+        type: "mcp_auth_required",
+        serverName: notification.serverName,
+        authUrl: notification.authUrl,
+        message: notification.message,
+        state: notification.state
+      };
+    case "mcp_auth_completed" /* MCP_AUTH_COMPLETED */:
+      return {
+        type: "mcp_auth_completed",
+        serverName: notification.serverName,
+        outcome: notification.outcome,
+        message: notification.message
+      };
+    default:
+      console.warn(
+        `[droid-sdk] Unknown notification type: ${String(notification.type)}`
+      );
+      return null;
+  }
+}
+var StreamStateTracker = class {
+  /** Whether we have ever seen a non-idle state. */
+  hasBeenNonIdle = false;
+  /** Last-seen token usage update (to attach to TurnComplete). */
+  lastTokenUsage = null;
+  /**
+   * Process a DroidMessage and return any additional messages that should be
+   * emitted (e.g. TurnComplete sentinel).
+   *
+   * @param message - The DroidMessage to process.
+   * @returns An array of additional messages to emit (may be empty).
+   */
+  processMessage(message) {
+    const additional = [];
+    if (message.type === "token_usage_update") {
+      this.lastTokenUsage = message;
+    }
+    if (message.type === "working_state_changed") {
+      if (message.state !== "idle" /* Idle */) {
+        this.hasBeenNonIdle = true;
+      } else if (this.hasBeenNonIdle) {
+        additional.push({
+          type: "turn_complete",
+          tokenUsage: this.lastTokenUsage
+        });
+        this.hasBeenNonIdle = false;
+      }
+    }
+    return additional;
+  }
+  /**
+   * Reset the tracker for a new turn/stream call.
+   */
+  reset() {
+    this.hasBeenNonIdle = false;
+    this.lastTokenUsage = null;
+  }
+};
+function normalizeToolResultContent(content) {
+  if (content == null) {
+    return "";
+  }
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content;
+  }
+  return String(content);
+}
+
+// src/query.ts
+function query(options) {
+  let transport = null;
+  let client = null;
+  let sessionId = null;
+  let aborted = false;
+  const messageQueue = [];
+  let resolveWaiting = null;
+  let streamDone = false;
+  function enqueueMessage(msg) {
+    messageQueue.push(msg);
+    if (resolveWaiting) {
+      const resolve = resolveWaiting;
+      resolveWaiting = null;
+      resolve();
+    }
+  }
+  function signalDone() {
+    streamDone = true;
+    if (resolveWaiting) {
+      const resolve = resolveWaiting;
+      resolveWaiting = null;
+      resolve();
+    }
+  }
+  async function* generateMessages() {
+    if (options.transport) {
+      transport = options.transport;
+    } else {
+      const transportOptions = {
+        execPath: options.execPath,
+        execArgs: options.execArgs,
+        cwd: options.cwd,
+        env: options.env
+      };
+      const processTransport = new ProcessTransport(transportOptions);
+      await processTransport.connect();
+      transport = processTransport;
+    }
+    client = new DroidClient({ transport });
+    if (options.permissionHandler) {
+      client.setPermissionHandler(options.permissionHandler);
+    }
+    if (options.askUserHandler) {
+      client.setAskUserHandler(options.askUserHandler);
+    }
+    const stateTracker = new StreamStateTracker();
+    client.onNotification((notification) => {
+      const params = notification["params"];
+      const innerNotification = params?.["notification"];
+      if (!innerNotification) {
+        return;
+      }
+      const converted = convertNotificationToStreamMessage(
+        innerNotification
+      );
+      if (converted === null) {
+        return;
+      }
+      const messages = Array.isArray(converted) ? converted : [converted];
+      for (const msg of messages) {
+        enqueueMessage(msg);
+        const additional = stateTracker.processMessage(msg);
+        for (const extra of additional) {
+          enqueueMessage(extra);
+          if (extra.type === "turn_complete") {
+            signalDone();
+          }
+        }
+      }
+    });
+    const initParams = {
+      machineId: options.machineId ?? "default",
+      cwd: options.cwd ?? "."
+    };
+    if (options.modelId !== void 0) {
+      initParams.modelId = options.modelId;
+    }
+    if (options.autonomyLevel !== void 0) {
+      initParams.autonomyLevel = options.autonomyLevel;
+    }
+    if (options.interactionMode !== void 0) {
+      initParams.interactionMode = options.interactionMode;
+    }
+    if (options.reasoningEffort !== void 0) {
+      initParams.reasoningEffort = options.reasoningEffort;
+    }
+    if (options.mcpServers !== void 0) {
+      initParams.mcpServers = options.mcpServers;
+    }
+    if (options.enabledToolIds !== void 0) {
+      initParams.enabledToolIds = options.enabledToolIds;
+    }
+    const initResult = await client.initializeSession(
+      initParams
+    );
+    sessionId = initResult.sessionId;
+    await client.addUserMessage({ text: options.prompt });
+    try {
+      while (true) {
+        if (aborted) {
+          return;
+        }
+        while (messageQueue.length > 0) {
+          const msg = messageQueue.shift();
+          yield msg;
+          if (msg.type === "turn_complete") {
+            return;
+          }
+        }
+        if (streamDone && messageQueue.length === 0) {
+          return;
+        }
+        await new Promise((resolve) => {
+          resolveWaiting = resolve;
+        });
+      }
+    } finally {
+    }
+  }
+  const generator = generateMessages();
+  async function* wrappedGenerator() {
+    try {
+      yield* generator;
+    } finally {
+      if (client) {
+        try {
+          await client.close();
+        } catch {
+        }
+        client = null;
+      } else if (transport) {
+        try {
+          await transport.close();
+        } catch {
+        }
+      }
+      transport = null;
+    }
+  }
+  const wrapped = wrappedGenerator();
+  const droidQuery = wrapped;
+  Object.defineProperties(droidQuery, {
+    interrupt: {
+      value: async function interrupt() {
+        if (client && !aborted) {
+          await client.interruptSession();
+        }
+      },
+      writable: false,
+      enumerable: true
+    },
+    abort: {
+      value: function abort() {
+        aborted = true;
+        signalDone();
+        if (client) {
+          void client.close().catch(() => {
+          });
+          client = null;
+        } else if (transport) {
+          void transport.close().catch(() => {
+          });
+        }
+        transport = null;
+      },
+      writable: false,
+      enumerable: true
+    },
+    sessionId: {
+      get() {
+        return sessionId;
+      },
+      enumerable: true
+    }
+  });
+  return droidQuery;
+}
+
+// src/session.ts
+var DroidSession = class {
+  _client;
+  _sessionId;
+  _initResult;
+  _closed = false;
+  /** @internal */
+  constructor(client, sessionId, initResult) {
+    this._client = client;
+    this._sessionId = sessionId;
+    this._initResult = initResult;
+  }
+  // ------------------------------------------------------------------
+  // Properties
+  // ------------------------------------------------------------------
+  /** The session ID. */
+  get sessionId() {
+    return this._sessionId;
+  }
+  /** The result from session initialization or loading. */
+  get initResult() {
+    return this._initResult;
+  }
+  // ------------------------------------------------------------------
+  // Messaging
+  // ------------------------------------------------------------------
+  /**
+   * Send a message and return a streaming async generator of DroidMessage events.
+   *
+   * The generator yields messages until a TurnComplete event is received,
+   * signaling the end of the agent's turn.
+   *
+   * @param text - The user message text.
+   * @param options - Optional images/files to include.
+   * @returns An async generator yielding DroidMessage events.
+   */
+  async *stream(text, options) {
+    this._ensureNotClosed();
+    const messageQueue = [];
+    let resolveWaiting = null;
+    let streamDone = false;
+    function enqueueMessage(msg) {
+      messageQueue.push(msg);
+      if (resolveWaiting) {
+        const resolve = resolveWaiting;
+        resolveWaiting = null;
+        resolve();
+      }
+    }
+    function signalDone() {
+      streamDone = true;
+      if (resolveWaiting) {
+        const resolve = resolveWaiting;
+        resolveWaiting = null;
+        resolve();
+      }
+    }
+    const stateTracker = new StreamStateTracker();
+    const unsubscribe = this._client.onNotification((notification) => {
+      const params = notification["params"];
+      const innerNotification = params?.["notification"];
+      if (!innerNotification) {
+        return;
+      }
+      const converted = convertNotificationToStreamMessage(
+        innerNotification
+      );
+      if (converted === null) {
+        return;
+      }
+      const messages = Array.isArray(converted) ? converted : [converted];
+      for (const msg of messages) {
+        enqueueMessage(msg);
+        const additional = stateTracker.processMessage(msg);
+        for (const extra of additional) {
+          enqueueMessage(extra);
+          if (extra.type === "turn_complete") {
+            signalDone();
+          }
+        }
+      }
+    });
+    try {
+      await this._client.addUserMessage({
+        text,
+        images: options?.images,
+        files: options?.files
+      });
+      while (true) {
+        while (messageQueue.length > 0) {
+          const msg = messageQueue.shift();
+          yield msg;
+          if (msg.type === "turn_complete") {
+            return;
+          }
+        }
+        if (streamDone && messageQueue.length === 0) {
+          return;
+        }
+        await new Promise((resolve) => {
+          resolveWaiting = resolve;
+        });
+      }
+    } finally {
+      unsubscribe();
+    }
+  }
+  /**
+   * Send a message and collect the complete response (non-streaming).
+   *
+   * Internally consumes all stream messages and returns an aggregated
+   * {@link DroidResult} with the concatenated text, all messages, and
+   * final token usage.
+   *
+   * @param text - The user message text.
+   * @param options - Optional images/files to include.
+   * @returns Aggregated result with text, messages, and token usage.
+   */
+  async send(text, options) {
+    this._ensureNotClosed();
+    const messages = [];
+    let fullText = "";
+    let lastTokenUsage = null;
+    for await (const msg of this.stream(text, options)) {
+      messages.push(msg);
+      if (msg.type === "assistant_text_delta") {
+        fullText += msg.text;
+      }
+      if (msg.type === "token_usage_update") {
+        lastTokenUsage = msg;
+      }
+      if (msg.type === "turn_complete" && msg.tokenUsage) {
+        lastTokenUsage = msg.tokenUsage;
+      }
+    }
+    return {
+      text: fullText,
+      messages,
+      tokenUsage: lastTokenUsage
+    };
+  }
+  // ------------------------------------------------------------------
+  // Session control
+  // ------------------------------------------------------------------
+  /**
+   * Interrupt the current agent turn.
+   *
+   * Sends an interrupt request. The agent will stop after completing
+   * its current operation.
+   */
+  async interrupt() {
+    this._ensureNotClosed();
+    await this._client.interruptSession();
+  }
+  /**
+   * Close the session and release all resources.
+   *
+   * Closes the underlying transport and rejects any pending requests.
+   * After close, the session cannot be used.
+   */
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    await this._client.close();
+  }
+  // ------------------------------------------------------------------
+  // Settings
+  // ------------------------------------------------------------------
+  /**
+   * Update session settings (model, reasoning effort, autonomy, etc.).
+   *
+   * @param params - Partial settings to update.
+   */
+  async updateSettings(params) {
+    this._ensureNotClosed();
+    return this._client.updateSessionSettings(params);
+  }
+  // ------------------------------------------------------------------
+  // MCP methods
+  // ------------------------------------------------------------------
+  /**
+   * Add an MCP server to the session.
+   */
+  async addMcpServer(params) {
+    this._ensureNotClosed();
+    return this._client.addMcpServer(params);
+  }
+  /**
+   * Remove an MCP server from the session.
+   */
+  async removeMcpServer(params) {
+    this._ensureNotClosed();
+    return this._client.removeMcpServer(params);
+  }
+  /**
+   * Toggle an MCP server on or off.
+   */
+  async toggleMcpServer(params) {
+    this._ensureNotClosed();
+    return this._client.toggleMcpServer(params);
+  }
+  /**
+   * List MCP servers and their status.
+   */
+  async listMcpServers() {
+    this._ensureNotClosed();
+    return this._client.listMcpServers();
+  }
+  /**
+   * List available MCP tools.
+   */
+  async listMcpTools() {
+    this._ensureNotClosed();
+    return this._client.listMcpTools();
+  }
+  /**
+   * Authenticate an MCP server (OAuth flow).
+   */
+  async authenticateMcpServer(params) {
+    this._ensureNotClosed();
+    return this._client.authenticateMcpServer(params);
+  }
+  // ------------------------------------------------------------------
+  // Skills
+  // ------------------------------------------------------------------
+  /**
+   * List available skills.
+   */
+  async listSkills() {
+    this._ensureNotClosed();
+    return this._client.listSkills();
+  }
+  // ------------------------------------------------------------------
+  // Notification subscription
+  // ------------------------------------------------------------------
+  /**
+   * Register a callback for incoming notification messages.
+   *
+   * @param callback - Invoked with the notification object.
+   * @param filter - Optional filter to only receive specific notification types.
+   * @returns An unsubscribe function.
+   */
+  onNotification(callback, filter) {
+    return this._client.onNotification(callback, filter);
+  }
+  // ------------------------------------------------------------------
+  // Internal
+  // ------------------------------------------------------------------
+  _ensureNotClosed() {
+    if (this._closed) {
+      throw new ConnectionError(
+        "Session has been closed. Create a new session to continue."
+      );
+    }
+  }
+};
+async function createSession(options = {}) {
+  let transport;
+  if (options.transport) {
+    transport = options.transport;
+  } else {
+    const transportOptions = {
+      execPath: options.execPath,
+      execArgs: options.execArgs,
+      cwd: options.cwd,
+      env: options.env
+    };
+    const processTransport = new ProcessTransport(transportOptions);
+    await processTransport.connect();
+    transport = processTransport;
+  }
+  const client = new DroidClient({ transport });
+  if (options.permissionHandler) {
+    client.setPermissionHandler(options.permissionHandler);
+  }
+  if (options.askUserHandler) {
+    client.setAskUserHandler(options.askUserHandler);
+  }
+  const initParams = {
+    machineId: options.machineId ?? "default",
+    cwd: options.cwd ?? "."
+  };
+  if (options.modelId !== void 0) {
+    initParams.modelId = options.modelId;
+  }
+  if (options.autonomyLevel !== void 0) {
+    initParams.autonomyLevel = options.autonomyLevel;
+  }
+  if (options.interactionMode !== void 0) {
+    initParams.interactionMode = options.interactionMode;
+  }
+  if (options.reasoningEffort !== void 0) {
+    initParams.reasoningEffort = options.reasoningEffort;
+  }
+  if (options.mcpServers !== void 0) {
+    initParams.mcpServers = options.mcpServers;
+  }
+  if (options.enabledToolIds !== void 0) {
+    initParams.enabledToolIds = options.enabledToolIds;
+  }
+  try {
+    const initResult = await client.initializeSession(
+      initParams
+    );
+    return new DroidSession(client, initResult.sessionId, initResult);
+  } catch (error) {
+    try {
+      await client.close();
+    } catch {
+    }
+    throw error;
+  }
+}
+async function resumeSession(sessionId, options = {}) {
+  let transport;
+  if (options.transport) {
+    transport = options.transport;
+  } else {
+    const transportOptions = {
+      execPath: options.execPath,
+      execArgs: options.execArgs,
+      cwd: options.cwd,
+      env: options.env
+    };
+    const processTransport = new ProcessTransport(transportOptions);
+    await processTransport.connect();
+    transport = processTransport;
+  }
+  const client = new DroidClient({ transport });
+  if (options.permissionHandler) {
+    client.setPermissionHandler(options.permissionHandler);
+  }
+  if (options.askUserHandler) {
+    client.setAskUserHandler(options.askUserHandler);
+  }
+  const loadParams = {
+    sessionId,
+    mcpServers: options.mcpServers
+  };
+  try {
+    const loadResult = await client.loadSession(loadParams);
+    return new DroidSession(client, sessionId, loadResult);
+  } catch (error) {
+    try {
+      await client.close();
+    } catch {
+    }
+    throw error;
+  }
+}
+export {
+  AddMcpServerRequestParamsSchema,
+  AddMcpServerRequestSchema,
+  AddMcpServerResponseSchema,
+  AddMcpServerResultSchema,
+  AddUserMessageRequestParamsSchema,
+  AddUserMessageRequestSchema,
+  AddUserMessageResponseSchema,
+  AddUserMessageResultSchema,
+  ApplyPatchToolConfirmationDetailsSchema,
+  AskUserCollectedAnswerSchema,
+  AskUserConfirmationDetailsSchema,
+  AskUserQuestionSchema,
+  AskUserRequestParamsSchema,
+  AskUserRequestSchema,
+  AskUserResponseSchema,
+  AskUserResultSchema,
+  AssistantTextDeltaNotificationSchema,
+  AuthenticateMcpServerRequestParamsSchema,
+  AuthenticateMcpServerRequestSchema,
+  AuthenticateMcpServerResponseSchema,
+  AuthenticateMcpServerResultSchema,
+  AutonomyLevel,
+  AutonomyMode,
+  AvailableModelConfigSchema,
+  Base64ImageSourceSchema,
+  BaseNotificationSchema,
+  BaseRequestSchema,
+  BaseResponseFailureSchema,
+  BaseResponseSuccessSchema,
+  CancelMcpAuthRequestParamsSchema,
+  CancelMcpAuthRequestSchema,
+  CancelMcpAuthResponseSchema,
+  CancelMcpAuthResultSchema,
+  ClearMcpAuthRequestParamsSchema,
+  ClearMcpAuthRequestSchema,
+  ClearMcpAuthResponseSchema,
+  ClearMcpAuthResultSchema,
+  CliRequestOrNotificationSchema,
+  ClientRequestSchema,
+  ConnectionError,
+  ContentBlockSchema,
+  CreateMessageNotificationSchema,
+  CreateToolConfirmationDetailsSchema,
+  DEFAULT_REQUEST_TIMEOUT,
+  DecompSessionType,
+  DiscoveredIssueSchema,
+  DismissalRecordSchema,
+  DismissalType,
+  DocumentBlockSchema,
+  DocumentSourceSchema,
+  DroidClient,
+  DroidClientMethod,
+  DroidErrorType,
+  DroidInteractionMode,
+  DroidServerMethod,
+  DroidSession,
+  DroidWorkingState,
+  DroidWorkingStateChangedNotificationSchema,
+  EditToolConfirmationDetailsSchema,
+  ErrorDetailSchema,
+  ErrorNotificationSchema,
+  ExecuteToolConfirmationDetailsSchema,
+  ExitSpecModeConfirmationDetailsSchema,
+  FACTORY_CLIENT_HEADER,
+  FACTORY_CLIENT_VERSION,
+  FACTORY_PROTOCOL_VERSION,
+  FactoryDroidMessageSchema,
+  FeatureStatus,
+  FeatureSuccessState,
+  FeatureSuccessStateSchema,
+  GitRepoInfoSchema,
+  HandoffItemsDismissedEntrySchema,
+  HandoffSchema,
+  HttpHeaderSchema,
+  HttpMcpConfigSchema,
+  ImageBlockSchema,
+  InitializeSessionRequestParamsSchema,
+  InitializeSessionRequestSchema,
+  InitializeSessionResponseSchema,
+  InitializeSessionResultSchema,
+  InteractiveCheckSchema,
+  InterruptSessionRequestParamsSchema,
+  InterruptSessionRequestSchema,
+  InterruptSessionResponseSchema,
+  InterruptSessionResultSchema,
+  IssueSeverity,
+  JSONRPC_VERSION,
+  JsonRpcEnvelopeSchema,
+  JsonRpcErrorCode,
+  JsonRpcErrorSchema,
+  JsonRpcMessageSchema,
+  JsonRpcMessageType,
+  JsonRpcNotificationSchema,
+  JsonRpcRequestSchema,
+  JsonRpcResponseFailureSchema,
+  JsonRpcResponseSchema,
+  JsonRpcResponseSuccessSchema,
+  KillWorkerSessionRequestParamsSchema,
+  KillWorkerSessionRequestSchema,
+  KillWorkerSessionResponseSchema,
+  KillWorkerSessionResultSchema,
+  LEGACY_FACTORY_API_VERSION,
+  ListMcpRegistryRequestParamsSchema,
+  ListMcpRegistryRequestSchema,
+  ListMcpRegistryResponseSchema,
+  ListMcpRegistryResultSchema,
+  ListMcpServersRequestParamsSchema,
+  ListMcpServersRequestSchema,
+  ListMcpServersResponseSchema,
+  ListMcpServersResultSchema,
+  ListMcpToolsRequestParamsSchema,
+  ListMcpToolsRequestSchema,
+  ListMcpToolsResponseSchema,
+  ListMcpToolsResultSchema,
+  ListSkillsRequestParamsSchema,
+  ListSkillsRequestSchema,
+  ListSkillsResponseSchema,
+  ListSkillsResultSchema,
+  LoadSessionRequestParamsSchema,
+  LoadSessionRequestSchema,
+  LoadSessionResponseSchema,
+  LoadSessionResultSchema,
+  MCP_AUTH_TIMEOUT,
+  McpAuthCompletedNotificationSchema,
+  McpAuthOutcome,
+  McpAuthRequiredNotificationSchema,
+  McpHttpServerConfigFieldsSchema,
+  McpRegistryServerSchema,
+  McpServerConfigSchema,
+  McpServerStatus,
+  McpServerStatusInfoSchema,
+  McpServerType,
+  McpSseServerConfigFieldsSchema,
+  McpStatus,
+  McpStatusChangedNotificationSchema,
+  McpStatusSummarySchema,
+  McpStdioServerConfigFieldsSchema,
+  McpToolConfirmationDetailsSchema,
+  McpToolInfoSchema,
+  McpToolInputSchemaSchema,
+  MilestoneValidationTriggeredEntrySchema,
+  MissionAcceptedEntrySchema,
+  MissionFeatureSchema,
+  MissionFeaturesChangedNotificationSchema,
+  MissionHeartbeatNotificationSchema,
+  MissionPausedEntrySchema,
+  MissionProgressEntryNotificationSchema,
+  MissionResumedEntrySchema,
+  MissionRunStartedEntrySchema,
+  MissionSnapshotSchema,
+  MissionState,
+  MissionStateChangedNotificationSchema,
+  MissionWorkerCompletedNotificationSchema,
+  MissionWorkerStartedNotificationSchema,
+  ModelProvider,
+  PermissionResolvedNotificationSchema,
+  ProcessExitError,
+  ProcessTransport,
+  ProgressLogEntrySchema,
+  ProgressLogEntryType,
+  ProposeMissionConfirmationDetailsSchema,
+  ProtocolEngine,
+  ProtocolError,
+  ReasoningEffort,
+  RedactedThinkingBlockSchema,
+  RemoveMcpServerRequestParamsSchema,
+  RemoveMcpServerRequestSchema,
+  RemoveMcpServerResponseSchema,
+  RemoveMcpServerResultSchema,
+  RequestPermissionRequestParamsSchema,
+  RequestPermissionRequestSchema,
+  RequestPermissionResponseSchema,
+  RequestPermissionResultSchema,
+  SESSION_INIT_TIMEOUT,
+  SessionError,
+  SessionNotFoundError,
+  SessionNotificationParamsSchema,
+  SessionNotificationPayloadSchema,
+  SessionNotificationSchema,
+  SessionNotificationSchemaList,
+  SessionNotificationType,
+  SessionSettingsSchema,
+  SessionSourceSchema,
+  SessionTagSchema,
+  SessionTitleUpdatedNotificationSchema,
+  SessionTokenUsageChangedNotificationSchema,
+  SettingsLevel,
+  SettingsUpdatedNotificationSchema,
+  SettingsUpdatedPayloadSchema,
+  SkillDeviationSchema,
+  SkillFeedbackSchema,
+  SkillInfoSchema,
+  SkillLocation,
+  SkillResourceSchema,
+  SseMcpConfigSchema,
+  StartMissionRunConfirmationDetailsSchema,
+  StdioMcpConfigSchema,
+  StreamStateTracker,
+  SubmitBugReportRequestParamsSchema,
+  SubmitBugReportRequestSchema,
+  SubmitBugReportResponseSchema,
+  SubmitBugReportResultSchema,
+  SubmitMcpAuthCodeRequestParamsSchema,
+  SubmitMcpAuthCodeRequestSchema,
+  SubmitMcpAuthCodeResponseSchema,
+  SubmitMcpAuthCodeResultSchema,
+  TestCaseSchema,
+  TestFileSchema,
+  TestsSchema,
+  TextBlockSchema,
+  ThinkingBlockSchema,
+  ThinkingTextDeltaNotificationSchema,
+  TimeoutError,
+  ToggleMcpServerRequestParamsSchema,
+  ToggleMcpServerRequestSchema,
+  ToggleMcpServerResponseSchema,
+  ToggleMcpServerResultSchema,
+  ToggleMcpToolRequestParamsSchema,
+  ToggleMcpToolRequestSchema,
+  ToggleMcpToolResponseSchema,
+  ToggleMcpToolResultSchema,
+  TokenUsageSchema,
+  ToolConfirmationDetailsSchema,
+  ToolConfirmationInfoSchema,
+  ToolConfirmationListItemSchema,
+  ToolConfirmationOutcome,
+  ToolConfirmationType,
+  ToolProgressUpdateNotificationSchema,
+  ToolProgressUpdateSchema,
+  ToolResultBlockSchema,
+  ToolResultNotificationSchema,
+  ToolUseBlockSchema,
+  ToolUseSchema,
+  TraceContextMetaSchema,
+  UpdateSessionSettingsRequestParamsSchema,
+  UpdateSessionSettingsRequestSchema,
+  UpdateSessionSettingsResponseSchema,
+  UpdateSessionSettingsResultSchema,
+  VerificationCommandSchema,
+  VerificationSchema,
+  WorkerCompletedEntrySchema,
+  WorkerFailedEntrySchema,
+  WorkerPausedEntrySchema,
+  WorkerSelectedFeatureEntrySchema,
+  WorkerStartedEntrySchema,
+  WorkerStateInfoSchema,
+  convertNotificationToStreamMessage,
+  createSession,
+  query,
+  resumeSession
+};
+//# sourceMappingURL=index.js.map