@factory/droid-sdk 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -46,6 +46,7 @@ __export(index_exports, {
   AskUserRequestSchema: () => AskUserRequestSchema,
   AskUserResponseSchema: () => AskUserResponseSchema,
   AskUserResultSchema: () => AskUserResultSchema,
+  AssistantTextCompleteNotificationSchema: () => AssistantTextCompleteNotificationSchema,
   AssistantTextDeltaNotificationSchema: () => AssistantTextDeltaNotificationSchema,
   AuthenticateMcpServerRequestParamsSchema: () => AuthenticateMcpServerRequestParamsSchema,
   AuthenticateMcpServerRequestSchema: () => AuthenticateMcpServerRequestSchema,
@@ -70,17 +71,30 @@ __export(index_exports, {
   ClearMcpAuthResultSchema: () => ClearMcpAuthResultSchema,
   CliRequestOrNotificationSchema: () => CliRequestOrNotificationSchema,
   ClientRequestSchema: () => ClientRequestSchema,
+  CloseSessionRequestParamsSchema: () => CloseSessionRequestParamsSchema,
+  CloseSessionRequestSchema: () => CloseSessionRequestSchema,
+  CloseSessionResponseSchema: () => CloseSessionResponseSchema,
+  CloseSessionResultSchema: () => CloseSessionResultSchema,
   CompactSessionRequestParamsSchema: () => CompactSessionRequestParamsSchema,
   CompactSessionRequestSchema: () => CompactSessionRequestSchema,
   CompactSessionResponseSchema: () => CompactSessionResponseSchema,
   CompactSessionResultSchema: () => CompactSessionResultSchema,
+  ComputerListResponseSchema: () => ComputerListResponseSchema,
+  ComputerMetricSchema: () => ComputerMetricSchema,
+  ComputerMetricsResponseSchema: () => ComputerMetricsResponseSchema,
+  ComputerSchema: () => ComputerSchema,
   ConnectionError: () => ConnectionError,
   ContentBlockSchema: () => ContentBlockSchema,
+  ContextBreakdownCategorySchema: () => ContextBreakdownCategorySchema,
+  ContextBreakdownResultSchema: () => ContextBreakdownResultSchema,
   ContextStatsAccuracy: () => ContextStatsAccuracy,
   ContextStatsSchema: () => ContextStatsSchema,
   CreateMessageNotificationSchema: () => CreateMessageNotificationSchema,
   CreateToolConfirmationDetailsSchema: () => CreateToolConfirmationDetailsSchema,
   DEFAULT_REQUEST_TIMEOUT: () => DEFAULT_REQUEST_TIMEOUT,
+  DaemonClient: () => DaemonClient,
+  DaemonConnection: () => DaemonConnection,
+  DaemonSession: () => DaemonSession,
   DecompSessionType: () => DecompSessionType,
   DiscoveredIssueSchema: () => DiscoveredIssueSchema,
   DismissalRecordSchema: () => DismissalRecordSchema,
@@ -90,6 +104,10 @@ __export(index_exports, {
   DroidClient: () => DroidClient,
   DroidClientMethod: () => DroidClientMethod,
   DroidErrorType: () => DroidErrorType,
+  DroidHookEventSchema: () => DroidHookEventSchema,
+  DroidHookExecutionResultSchema: () => DroidHookExecutionResultSchema,
+  DroidHookOutputSchema: () => DroidHookOutputSchema,
+  DroidHookSpecificOutputSchema: () => DroidHookSpecificOutputSchema,
   DroidInteractionMode: () => DroidInteractionMode,
   DroidMessageType: () => DroidMessageType,
   DroidServerMethod: () => DroidServerMethod,
@@ -130,6 +148,10 @@ __export(index_exports, {
   GitRepoInfoSchema: () => GitRepoInfoSchema,
   HandoffItemsDismissedEntrySchema: () => HandoffItemsDismissedEntrySchema,
   HandoffSchema: () => HandoffSchema,
+  HookCommandSchema: () => HookCommandSchema,
+  HookExecutionCompletedNotificationSchema: () => HookExecutionCompletedNotificationSchema,
+  HookExecutionStartedNotificationSchema: () => HookExecutionStartedNotificationSchema,
+  HookResultSchema: () => HookResultSchema,
   HttpHeaderSchema: () => HttpHeaderSchema,
   HttpMcpConfigSchema: () => HttpMcpConfigSchema,
   ImageBlockSchema: () => ImageBlockSchema,
@@ -187,6 +209,10 @@ __export(index_exports, {
   LoadSessionResponseSchema: () => LoadSessionResponseSchema,
   LoadSessionResultSchema: () => LoadSessionResultSchema,
   MCP_AUTH_TIMEOUT: () => MCP_AUTH_TIMEOUT,
+  MachineTemplateBuildStatusSchema: () => MachineTemplateBuildStatusSchema,
+  MachineTemplateListResponseSchema: () => MachineTemplateListResponseSchema,
+  MachineTemplateSchema: () => MachineTemplateSchema,
+  MachineType: () => MachineType,
   McpAuthCompletedNotificationSchema: () => McpAuthCompletedNotificationSchema,
   McpAuthOutcome: () => McpAuthOutcome,
   McpAuthRequiredNotificationSchema: () => McpAuthRequiredNotificationSchema,
@@ -232,6 +258,9 @@ __export(index_exports, {
   REWIND_TIMEOUT: () => REWIND_TIMEOUT,
   ReasoningEffort: () => ReasoningEffort,
   RedactedThinkingBlockSchema: () => RedactedThinkingBlockSchema,
+  RefreshComputerResponseSchema: () => RefreshComputerResponseSchema,
+  RemoteSessionListResponseSchema: () => RemoteSessionListResponseSchema,
+  RemoteSessionSchema: () => RemoteSessionSchema,
   RemoveMcpServerRequestParamsSchema: () => RemoveMcpServerRequestParamsSchema,
   RemoveMcpServerRequestSchema: () => RemoveMcpServerRequestSchema,
   RemoveMcpServerResponseSchema: () => RemoveMcpServerResponseSchema,
@@ -251,6 +280,7 @@ __export(index_exports, {
   SDK_VERSION: () => SDK_VERSION,
   SESSION_INIT_TIMEOUT: () => SESSION_INIT_TIMEOUT,
   SdkMcpServer: () => SdkMcpServer,
+  ServerRequestHandlerType: () => ServerRequestHandlerType,
   SessionError: () => SessionError,
   SessionMetadataSchema: () => SessionMetadataSchema,
   SessionNotFoundError: () => SessionNotFoundError,
@@ -278,6 +308,8 @@ __export(index_exports, {
   StartMissionRunConfirmationDetailsSchema: () => StartMissionRunConfirmationDetailsSchema,
   StdioMcpConfigSchema: () => StdioMcpConfigSchema,
   StreamStateTracker: () => StreamStateTracker,
+  StructuredOutputErrorSchema: () => StructuredOutputErrorSchema,
+  StructuredOutputNotificationSchema: () => StructuredOutputNotificationSchema,
   SubmitBugReportRequestParamsSchema: () => SubmitBugReportRequestParamsSchema,
   SubmitBugReportRequestSchema: () => SubmitBugReportRequestSchema,
   SubmitBugReportResponseSchema: () => SubmitBugReportResponseSchema,
@@ -292,6 +324,7 @@ __export(index_exports, {
   TestsSchema: () => TestsSchema,
   TextBlockSchema: () => TextBlockSchema,
   ThinkingBlockSchema: () => ThinkingBlockSchema,
+  ThinkingTextCompleteNotificationSchema: () => ThinkingTextCompleteNotificationSchema,
   ThinkingTextDeltaNotificationSchema: () => ThinkingTextDeltaNotificationSchema,
   TimeoutError: () => TimeoutError,
   ToggleMcpServerRequestParamsSchema: () => ToggleMcpServerRequestParamsSchema,
@@ -303,6 +336,7 @@ __export(index_exports, {
   ToggleMcpToolResponseSchema: () => ToggleMcpToolResponseSchema,
   ToggleMcpToolResultSchema: () => ToggleMcpToolResultSchema,
   TokenUsageSchema: () => TokenUsageSchema,
+  ToolCallNotificationSchema: () => ToolCallNotificationSchema,
   ToolConfirmationDetailsSchema: () => ToolConfirmationDetailsSchema,
   ToolConfirmationInfoSchema: () => ToolConfirmationInfoSchema,
   ToolConfirmationListItemSchema: () => ToolConfirmationListItemSchema,
@@ -322,20 +356,38 @@ __export(index_exports, {
   UpdateSessionSettingsResultSchema: () => UpdateSessionSettingsResultSchema,
   VerificationCommandSchema: () => VerificationCommandSchema,
   VerificationSchema: () => VerificationSchema,
+  WebSocketTransport: () => WebSocketTransport,
   WorkerCompletedEntrySchema: () => WorkerCompletedEntrySchema,
   WorkerFailedEntrySchema: () => WorkerFailedEntrySchema,
   WorkerPausedEntrySchema: () => WorkerPausedEntrySchema,
   WorkerSelectedFeatureEntrySchema: () => WorkerSelectedFeatureEntrySchema,
   WorkerStartedEntrySchema: () => WorkerStartedEntrySchema,
   WorkerStateInfoSchema: () => WorkerStateInfoSchema,
+  connectDaemon: () => connectDaemon,
   convertNotificationToStreamMessage: () => convertNotificationToStreamMessage,
+  createComputer: () => createComputer,
+  createResponseSchema: () => createResponseSchema,
   createSdkMcpServer: () => createSdkMcpServer,
   createSession: () => createSession,
+  deleteComputer: () => deleteComputer,
+  dispatchNotification: () => dispatchNotification,
+  ensureLocalDaemon: () => ensureLocalDaemon,
+  getComputer: () => getComputer,
+  getComputerByName: () => getComputerByName,
+  getComputerMetrics: () => getComputerMetrics,
+  getMachineTemplate: () => getMachineTemplate,
+  listComputers: () => listComputers,
+  listMachineTemplates: () => listMachineTemplates,
+  listRemoteSessions: () => listRemoteSessions,
   listSessions: () => listSessions,
-  query: () => query,
+  refreshComputer: () => refreshComputer,
+  resolveWebSocketUrl: () => resolveWebSocketUrl,
+  restartComputer: () => restartComputer,
   resumeSession: () => resumeSession,
+  retryInstallDeps: () => retryInstallDeps,
   run: () => run,
-  tool: () => tool
+  tool: () => tool,
+  updateComputer: () => updateComputer
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -344,6 +396,7 @@ 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["CLOSE_SESSION"] = "droid.close_session";
   DroidServerMethod2["INTERRUPT_SESSION"] = "droid.interrupt_session";
   DroidServerMethod2["KILL_WORKER_SESSION"] = "droid.kill_worker_session";
   DroidServerMethod2["UPDATE_SESSION_SETTINGS"] = "droid.update_session_settings";
@@ -386,7 +439,10 @@ var SessionNotificationType = /* @__PURE__ */ ((SessionNotificationType2) => {
   SessionNotificationType2["SESSION_TITLE_UPDATED"] = "session_title_updated";
   SessionNotificationType2["MCP_STATUS_CHANGED"] = "mcp_status_changed";
   SessionNotificationType2["ASSISTANT_TEXT_DELTA"] = "assistant_text_delta";
+  SessionNotificationType2["ASSISTANT_TEXT_COMPLETE"] = "assistant_text_complete";
   SessionNotificationType2["THINKING_TEXT_DELTA"] = "thinking_text_delta";
+  SessionNotificationType2["THINKING_TEXT_COMPLETE"] = "thinking_text_complete";
+  SessionNotificationType2["TOOL_CALL"] = "tool_call";
   SessionNotificationType2["SESSION_TOKEN_USAGE_CHANGED"] = "session_token_usage_changed";
   SessionNotificationType2["MISSION_STATE_CHANGED"] = "mission_state_changed";
   SessionNotificationType2["MISSION_FEATURES_CHANGED"] = "mission_features_changed";
@@ -396,6 +452,9 @@ var SessionNotificationType = /* @__PURE__ */ ((SessionNotificationType2) => {
   SessionNotificationType2["MISSION_WORKER_COMPLETED"] = "mission_worker_completed";
   SessionNotificationType2["MCP_AUTH_REQUIRED"] = "mcp_auth_required";
   SessionNotificationType2["MCP_AUTH_COMPLETED"] = "mcp_auth_completed";
+  SessionNotificationType2["HOOK_EXECUTION_STARTED"] = "hook_execution_started";
+  SessionNotificationType2["HOOK_EXECUTION_COMPLETED"] = "hook_execution_completed";
+  SessionNotificationType2["STRUCTURED_OUTPUT"] = "structured_output";
   return SessionNotificationType2;
 })(SessionNotificationType || {});
 var ToolConfirmationOutcome = /* @__PURE__ */ ((ToolConfirmationOutcome3) => {
@@ -589,6 +648,11 @@ var JsonRpcMessageType = /* @__PURE__ */ ((JsonRpcMessageType2) => {
   JsonRpcMessageType2["Notification"] = "notification";
   return JsonRpcMessageType2;
 })(JsonRpcMessageType || {});
+var ServerRequestHandlerType = /* @__PURE__ */ ((ServerRequestHandlerType2) => {
+  ServerRequestHandlerType2["Permission"] = "permission";
+  ServerRequestHandlerType2["AskUser"] = "askUser";
+  return ServerRequestHandlerType2;
+})(ServerRequestHandlerType || {});
 var SettingsLevel = /* @__PURE__ */ ((SettingsLevel2) => {
   SettingsLevel2["Org"] = "org";
   SettingsLevel2["Runtime"] = "runtime";
@@ -609,7 +673,7 @@ var SkillLocation = /* @__PURE__ */ ((SkillLocation2) => {
 // src/schemas/constants.ts
 var JSONRPC_VERSION = "2.0";
 var LEGACY_FACTORY_API_VERSION = "1.0.0";
-var FACTORY_PROTOCOL_VERSION = "1.3.0";
+var FACTORY_PROTOCOL_VERSION = "1.51.0";
 var FACTORY_CLIENT_HEADER = "X-Factory-Client";
 var FACTORY_CLIENT_VERSION = "X-Client-Version";
 var DEFAULT_REQUEST_TIMEOUT = 3e4;
@@ -700,6 +764,12 @@ var JsonRpcMessageSchema = import_zod.z.discriminatedUnion("type", [
   }),
   JsonRpcNotificationSchema
 ]);
+function createResponseSchema(resultSchema) {
+  return import_zod.z.union([
+    JsonRpcResponseSuccessSchema.extend({ result: resultSchema }),
+    JsonRpcResponseFailureSchema
+  ]);
+}
 
 // src/schemas/session-metadata.ts
 var import_zod6 = require("zod");
@@ -1147,6 +1217,9 @@ var AddUserMessageRequestParamsSchema = import_zod5.z.object({
   outputFormat: OutputFormatSchema.optional()
 }).strict();
 var InterruptSessionRequestParamsSchema = import_zod5.z.object({}).strict();
+var CloseSessionRequestParamsSchema = import_zod5.z.object({
+  reason: import_zod5.z.enum(["clear", "logout", "prompt_input_exit", "other"]).optional()
+}).strict();
 var KillWorkerSessionRequestParamsSchema = import_zod5.z.object({
   workerSessionId: import_zod5.z.string()
 }).strict();
@@ -1263,6 +1336,10 @@ var InterruptSessionRequestSchema = JsonRpcRequestSchema.extend({
   method: import_zod5.z.literal("droid.interrupt_session" /* INTERRUPT_SESSION */),
   params: InterruptSessionRequestParamsSchema
 });
+var CloseSessionRequestSchema = JsonRpcRequestSchema.extend({
+  method: import_zod5.z.literal("droid.close_session" /* CLOSE_SESSION */),
+  params: CloseSessionRequestParamsSchema
+});
 var KillWorkerSessionRequestSchema = JsonRpcRequestSchema.extend({
   method: import_zod5.z.literal("droid.kill_worker_session" /* KILL_WORKER_SESSION */),
   params: KillWorkerSessionRequestParamsSchema
@@ -1355,6 +1432,7 @@ var ClientRequestSchema = import_zod5.z.discriminatedUnion("method", [
   InitializeSessionRequestSchema,
   LoadSessionRequestSchema,
   AddUserMessageRequestSchema,
+  CloseSessionRequestSchema,
   InterruptSessionRequestSchema,
   KillWorkerSessionRequestSchema,
   UpdateSessionSettingsRequestSchema,
@@ -1415,6 +1493,7 @@ var LoadSessionResultSchema = import_zod5.z.object({
 }).passthrough();
 var AddUserMessageResultSchema = EmptyResultSchema;
 var InterruptSessionResultSchema = EmptyResultSchema;
+var CloseSessionResultSchema = EmptyResultSchema;
 var KillWorkerSessionResultSchema = EmptyResultSchema;
 var UpdateSessionSettingsResultSchema = EmptyResultSchema;
 var ToggleMcpServerResultSchema = SuccessResultSchema;
@@ -1454,128 +1533,102 @@ var ForkSessionResultSchema = import_zod5.z.object({
   newSessionId: import_zod5.z.string()
 }).passthrough();
 var GetContextStatsResultSchema = ContextStatsSchema;
+var ContextBreakdownCategorySchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  tokens: import_zod5.z.number(),
+  colorKey: import_zod5.z.string()
+}).passthrough();
+var ContextBreakdownResultSchema = import_zod5.z.object({
+  modelId: import_zod5.z.string(),
+  modelDisplayName: import_zod5.z.string(),
+  contextBudget: import_zod5.z.number(),
+  usedTokens: import_zod5.z.number(),
+  freeTokens: import_zod5.z.number(),
+  categories: import_zod5.z.array(ContextBreakdownCategorySchema)
+}).passthrough();
 var RenameSessionResultSchema = SuccessResultSchema;
-var InitializeSessionResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: InitializeSessionResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var _LoadSessionResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: LoadSessionResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
+var InitializeSessionResponseSchema = createResponseSchema(
+  InitializeSessionResultSchema
+);
+var _LoadSessionResponseSchema = createResponseSchema(
+  LoadSessionResultSchema
+);
 var LoadSessionResponseSchema = _LoadSessionResponseSchema;
-var AddUserMessageResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: AddUserMessageResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var InterruptSessionResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: InterruptSessionResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var KillWorkerSessionResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: KillWorkerSessionResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var UpdateSessionSettingsResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: UpdateSessionSettingsResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var ToggleMcpServerResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: ToggleMcpServerResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var AuthenticateMcpServerResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: AuthenticateMcpServerResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var CancelMcpAuthResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: CancelMcpAuthResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ClearMcpAuthResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ClearMcpAuthResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var SubmitMcpAuthCodeResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: SubmitMcpAuthCodeResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var AddMcpServerResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: AddMcpServerResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var RemoveMcpServerResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: RemoveMcpServerResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ListMcpRegistryResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: ListMcpRegistryResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var ListMcpToolsResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ListMcpToolsResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ListToolsResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ListToolsResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ListMcpServersResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ListMcpServersResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ToggleMcpToolResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ToggleMcpToolResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ListSkillsResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ListSkillsResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var SubmitBugReportResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: SubmitBugReportResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var GetRewindInfoResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: GetRewindInfoResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ExecuteRewindResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ExecuteRewindResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var CompactSessionResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: CompactSessionResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ForkSessionResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ForkSessionResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var GetContextStatsResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: GetContextStatsResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var RenameSessionResponseSchema = import_zod5.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: RenameSessionResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
+var AddUserMessageResponseSchema = createResponseSchema(
+  AddUserMessageResultSchema
+);
+var InterruptSessionResponseSchema = createResponseSchema(
+  InterruptSessionResultSchema
+);
+var CloseSessionResponseSchema = createResponseSchema(
+  CloseSessionResultSchema
+);
+var KillWorkerSessionResponseSchema = createResponseSchema(
+  KillWorkerSessionResultSchema
+);
+var UpdateSessionSettingsResponseSchema = createResponseSchema(
+  UpdateSessionSettingsResultSchema
+);
+var ToggleMcpServerResponseSchema = createResponseSchema(
+  ToggleMcpServerResultSchema
+);
+var AuthenticateMcpServerResponseSchema = createResponseSchema(
+  AuthenticateMcpServerResultSchema
+);
+var CancelMcpAuthResponseSchema = createResponseSchema(
+  CancelMcpAuthResultSchema
+);
+var ClearMcpAuthResponseSchema = createResponseSchema(
+  ClearMcpAuthResultSchema
+);
+var SubmitMcpAuthCodeResponseSchema = createResponseSchema(
+  SubmitMcpAuthCodeResultSchema
+);
+var AddMcpServerResponseSchema = createResponseSchema(
+  AddMcpServerResultSchema
+);
+var RemoveMcpServerResponseSchema = createResponseSchema(
+  RemoveMcpServerResultSchema
+);
+var ListMcpRegistryResponseSchema = createResponseSchema(
+  ListMcpRegistryResultSchema
+);
+var ListMcpToolsResponseSchema = createResponseSchema(
+  ListMcpToolsResultSchema
+);
+var ListToolsResponseSchema = createResponseSchema(
+  ListToolsResultSchema
+);
+var ListMcpServersResponseSchema = createResponseSchema(
+  ListMcpServersResultSchema
+);
+var ToggleMcpToolResponseSchema = createResponseSchema(
+  ToggleMcpToolResultSchema
+);
+var ListSkillsResponseSchema = createResponseSchema(
+  ListSkillsResultSchema
+);
+var SubmitBugReportResponseSchema = createResponseSchema(
+  SubmitBugReportResultSchema
+);
+var GetRewindInfoResponseSchema = createResponseSchema(
+  GetRewindInfoResultSchema
+);
+var ExecuteRewindResponseSchema = createResponseSchema(
+  ExecuteRewindResultSchema
+);
+var CompactSessionResponseSchema = createResponseSchema(
+  CompactSessionResultSchema
+);
+var ForkSessionResponseSchema = createResponseSchema(
+  ForkSessionResultSchema
+);
+var GetContextStatsResponseSchema = createResponseSchema(
+  GetContextStatsResultSchema
+);
+var RenameSessionResponseSchema = createResponseSchema(
+  RenameSessionResultSchema
+);
 
 // src/schemas/session-metadata.ts
 var SessionMetadataSchema = import_zod6.z.object({
@@ -1606,140 +1659,231 @@ var SessionSettingsFileSchema = import_zod6.z.object({
   tags: import_zod6.z.array(SessionTagSchema).optional()
 }).passthrough();
 
-// src/schemas/server.ts
+// src/schemas/hooks.ts
 var import_zod7 = require("zod");
+var DroidHookEventSchema = import_zod7.z.enum([
+  "PreToolUse",
+  "PostToolUse",
+  "Notification",
+  "UserPromptSubmit",
+  "Stop",
+  "SubagentStop",
+  "PreCompact",
+  "SessionStart",
+  "SessionEnd"
+]);
+var DroidHookSpecificOutputSchema = import_zod7.z.object({
+  hookEventName: DroidHookEventSchema.optional(),
+  permissionDecision: import_zod7.z.enum(["allow", "deny", "ask"]).optional(),
+  permissionDecisionReason: import_zod7.z.string().optional(),
+  additionalContext: import_zod7.z.string().optional(),
+  updatedInput: import_zod7.z.record(import_zod7.z.unknown()).optional()
+}).passthrough();
+var DroidHookOutputSchema = import_zod7.z.object({
+  continue: import_zod7.z.boolean().optional(),
+  stopReason: import_zod7.z.string().optional(),
+  suppressOutput: import_zod7.z.boolean().optional(),
+  systemMessage: import_zod7.z.string().optional(),
+  decision: import_zod7.z.enum(["block", "approve"]).optional(),
+  reason: import_zod7.z.string().optional(),
+  hookSpecificOutput: DroidHookSpecificOutputSchema.optional()
+}).passthrough();
+var DroidHookExecutionResultSchema = DroidHookOutputSchema.extend({
+  exitCode: import_zod7.z.number(),
+  stdout: import_zod7.z.string(),
+  stderr: import_zod7.z.string()
+});
+
+// src/schemas/server.ts
+var import_zod8 = require("zod");
 var ToolUseBlockSchema2 = ToolUseBlockSchema;
 var ToolUseSchema = ToolUseBlockSchema2;
-var ErrorDetailSchema = import_zod7.z.object({
-  name: import_zod7.z.string(),
-  message: import_zod7.z.string()
+var ErrorDetailSchema = import_zod8.z.object({
+  name: import_zod8.z.string(),
+  message: import_zod8.z.string()
 }).passthrough();
-var ToolProgressUpdateSchema = import_zod7.z.object({
-  type: import_zod7.z.enum(["tool_call", "tool_result", "error", "status", "message"]),
-  toolName: import_zod7.z.string().optional(),
-  status: import_zod7.z.string().optional(),
-  details: import_zod7.z.string().optional(),
-  text: import_zod7.z.string().optional(),
-  error: import_zod7.z.string().optional(),
-  timestamp: import_zod7.z.number().optional(),
+var ToolProgressUpdateSchema = import_zod8.z.object({
+  type: import_zod8.z.enum(["tool_call", "tool_result", "error", "status", "message"]),
+  toolName: import_zod8.z.string().optional(),
+  status: import_zod8.z.string().optional(),
+  details: import_zod8.z.string().optional(),
+  text: import_zod8.z.string().optional(),
+  error: import_zod8.z.string().optional(),
+  timestamp: import_zod8.z.number().optional(),
   parameters: JsonObjectSchema.optional(),
-  valueSnippet: import_zod7.z.string().optional(),
-  subagentSessionId: import_zod7.z.string().optional()
+  valueSnippet: import_zod8.z.string().optional(),
+  subagentSessionId: import_zod8.z.string().optional()
 }).passthrough();
-var SettingsUpdatedPayloadSchema = import_zod7.z.object({
-  autonomyMode: import_zod7.z.nativeEnum(AutonomyMode).optional(),
-  interactionMode: import_zod7.z.nativeEnum(DroidInteractionMode).optional().catch(void 0),
-  autonomyLevel: import_zod7.z.nativeEnum(AutonomyLevel).optional().catch(void 0),
-  modelId: import_zod7.z.string().optional(),
-  reasoningEffort: import_zod7.z.nativeEnum(ReasoningEffort).optional(),
-  specModeModelId: import_zod7.z.string().optional(),
-  specModeReasoningEffort: import_zod7.z.nativeEnum(ReasoningEffort).optional(),
+var SettingsUpdatedPayloadSchema = import_zod8.z.object({
+  autonomyMode: import_zod8.z.nativeEnum(AutonomyMode).optional(),
+  interactionMode: import_zod8.z.nativeEnum(DroidInteractionMode).optional().catch(void 0),
+  autonomyLevel: import_zod8.z.nativeEnum(AutonomyLevel).optional().catch(void 0),
+  modelId: import_zod8.z.string().optional(),
+  reasoningEffort: import_zod8.z.nativeEnum(ReasoningEffort).optional(),
+  specModeModelId: import_zod8.z.string().optional(),
+  specModeReasoningEffort: import_zod8.z.nativeEnum(ReasoningEffort).optional(),
   ...ToolSelectionOverridesSchema.shape
 }).passthrough();
-var ToolResultNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("tool_result" /* TOOL_RESULT */),
-  messageId: import_zod7.z.string(),
-  toolUseId: import_zod7.z.string(),
+var ToolResultNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("tool_result" /* TOOL_RESULT */),
+  messageId: import_zod8.z.string(),
+  toolUseId: import_zod8.z.string(),
   content: JsonValueSchema.optional(),
-  isError: import_zod7.z.boolean().optional(),
-  id: import_zod7.z.string().optional()
+  isError: import_zod8.z.boolean().optional(),
+  id: import_zod8.z.string().optional()
 }).passthrough();
-var ToolProgressUpdateNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("tool_progress_update" /* TOOL_PROGRESS_UPDATE */),
-  toolUseId: import_zod7.z.string(),
-  toolName: import_zod7.z.string(),
+var ToolProgressUpdateNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("tool_progress_update" /* TOOL_PROGRESS_UPDATE */),
+  toolUseId: import_zod8.z.string(),
+  toolName: import_zod8.z.string(),
   update: ToolProgressUpdateSchema
 }).passthrough();
-var CreateMessageNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("create_message" /* CREATE_MESSAGE */),
+var CreateMessageNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("create_message" /* CREATE_MESSAGE */),
   message: FactoryDroidMessageSchema,
-  parentId: import_zod7.z.string().optional(),
-  requestId: import_zod7.z.string().optional()
+  parentId: import_zod8.z.string().optional(),
+  requestId: import_zod8.z.string().optional()
 }).passthrough();
-var ErrorNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("error" /* ERROR */),
-  message: import_zod7.z.string(),
-  errorType: import_zod7.z.nativeEnum(DroidErrorType),
-  timestamp: import_zod7.z.string(),
+var ErrorNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("error" /* ERROR */),
+  message: import_zod8.z.string(),
+  errorType: import_zod8.z.nativeEnum(DroidErrorType),
+  timestamp: import_zod8.z.string(),
   error: ErrorDetailSchema.optional()
 }).passthrough();
-var DroidWorkingStateChangedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */),
-  newState: import_zod7.z.nativeEnum(DroidWorkingState)
+var DroidWorkingStateChangedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */),
+  newState: import_zod8.z.nativeEnum(DroidWorkingState)
 }).passthrough();
-var PermissionResolvedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("permission_resolved" /* PERMISSION_RESOLVED */),
-  requestId: import_zod7.z.string(),
-  toolUseIds: import_zod7.z.array(import_zod7.z.string()),
-  selectedOption: import_zod7.z.nativeEnum(ToolConfirmationOutcome)
+var PermissionResolvedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("permission_resolved" /* PERMISSION_RESOLVED */),
+  requestId: import_zod8.z.string(),
+  toolUseIds: import_zod8.z.array(import_zod8.z.string()),
+  selectedOption: import_zod8.z.nativeEnum(ToolConfirmationOutcome)
 }).passthrough();
-var SettingsUpdatedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("settings_updated" /* SETTINGS_UPDATED */),
+var SettingsUpdatedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("settings_updated" /* SETTINGS_UPDATED */),
   settings: SettingsUpdatedPayloadSchema
 }).passthrough();
-var SessionTitleUpdatedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("session_title_updated" /* SESSION_TITLE_UPDATED */),
-  title: import_zod7.z.string()
+var SessionTitleUpdatedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("session_title_updated" /* SESSION_TITLE_UPDATED */),
+  title: import_zod8.z.string()
 }).passthrough();
-var McpStatusChangedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("mcp_status_changed" /* MCP_STATUS_CHANGED */),
-  servers: import_zod7.z.array(McpServerStatusInfoSchema),
+var McpStatusChangedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mcp_status_changed" /* MCP_STATUS_CHANGED */),
+  servers: import_zod8.z.array(McpServerStatusInfoSchema),
   summary: McpStatusSummarySchema
 }).passthrough();
-var AssistantTextDeltaNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("assistant_text_delta" /* ASSISTANT_TEXT_DELTA */),
-  messageId: import_zod7.z.string(),
-  blockIndex: import_zod7.z.number(),
-  textDelta: import_zod7.z.string()
+var AssistantTextDeltaNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("assistant_text_delta" /* ASSISTANT_TEXT_DELTA */),
+  messageId: import_zod8.z.string(),
+  blockIndex: import_zod8.z.number(),
+  textDelta: import_zod8.z.string()
 }).passthrough();
-var ThinkingTextDeltaNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("thinking_text_delta" /* THINKING_TEXT_DELTA */),
-  messageId: import_zod7.z.string(),
-  blockIndex: import_zod7.z.number(),
-  textDelta: import_zod7.z.string()
+var AssistantTextCompleteNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("assistant_text_complete" /* ASSISTANT_TEXT_COMPLETE */),
+  messageId: import_zod8.z.string(),
+  blockIndex: import_zod8.z.number()
 }).passthrough();
-var SessionTokenUsageChangedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("session_token_usage_changed" /* SESSION_TOKEN_USAGE_CHANGED */),
-  sessionId: import_zod7.z.string(),
+var ThinkingTextDeltaNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("thinking_text_delta" /* THINKING_TEXT_DELTA */),
+  messageId: import_zod8.z.string(),
+  blockIndex: import_zod8.z.number(),
+  textDelta: import_zod8.z.string()
+}).passthrough();
+var ThinkingTextCompleteNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("thinking_text_complete" /* THINKING_TEXT_COMPLETE */),
+  messageId: import_zod8.z.string(),
+  blockIndex: import_zod8.z.number(),
+  durationMs: import_zod8.z.number().optional()
+}).passthrough();
+var ToolCallNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("tool_call" /* TOOL_CALL */),
+  toolUse: ToolUseBlockSchema2
+}).passthrough();
+var SessionTokenUsageChangedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("session_token_usage_changed" /* SESSION_TOKEN_USAGE_CHANGED */),
+  sessionId: import_zod8.z.string(),
   tokenUsage: TokenUsageSchema
 }).passthrough();
-var MissionStateChangedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("mission_state_changed" /* MISSION_STATE_CHANGED */),
-  state: import_zod7.z.nativeEnum(MissionState)
+var MissionStateChangedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mission_state_changed" /* MISSION_STATE_CHANGED */),
+  state: import_zod8.z.nativeEnum(MissionState)
+}).passthrough();
+var MissionFeaturesChangedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mission_features_changed" /* MISSION_FEATURES_CHANGED */),
+  features: import_zod8.z.array(MissionFeatureSchema)
 }).passthrough();
-var MissionFeaturesChangedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("mission_features_changed" /* MISSION_FEATURES_CHANGED */),
-  features: import_zod7.z.array(MissionFeatureSchema)
+var MissionProgressEntryNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mission_progress_entry" /* MISSION_PROGRESS_ENTRY */),
+  progressLog: import_zod8.z.array(ProgressLogEntrySchema)
 }).passthrough();
-var MissionProgressEntryNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("mission_progress_entry" /* MISSION_PROGRESS_ENTRY */),
-  progressLog: import_zod7.z.array(ProgressLogEntrySchema)
+var MissionHeartbeatNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mission_heartbeat" /* MISSION_HEARTBEAT */),
+  timestamp: import_zod8.z.string()
 }).passthrough();
-var MissionHeartbeatNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("mission_heartbeat" /* MISSION_HEARTBEAT */),
-  timestamp: import_zod7.z.string()
+var MissionWorkerStartedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mission_worker_started" /* MISSION_WORKER_STARTED */),
+  workerSessionId: import_zod8.z.string()
 }).passthrough();
-var MissionWorkerStartedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("mission_worker_started" /* MISSION_WORKER_STARTED */),
-  workerSessionId: import_zod7.z.string()
+var MissionWorkerCompletedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mission_worker_completed" /* MISSION_WORKER_COMPLETED */),
+  workerSessionId: import_zod8.z.string(),
+  exitCode: import_zod8.z.number()
 }).passthrough();
-var MissionWorkerCompletedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("mission_worker_completed" /* MISSION_WORKER_COMPLETED */),
-  workerSessionId: import_zod7.z.string(),
-  exitCode: import_zod7.z.number()
+var McpAuthRequiredNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mcp_auth_required" /* MCP_AUTH_REQUIRED */),
+  serverName: import_zod8.z.string(),
+  authUrl: import_zod8.z.string(),
+  message: import_zod8.z.string(),
+  state: import_zod8.z.string()
 }).passthrough();
-var McpAuthRequiredNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("mcp_auth_required" /* MCP_AUTH_REQUIRED */),
-  serverName: import_zod7.z.string(),
-  authUrl: import_zod7.z.string(),
-  message: import_zod7.z.string(),
-  state: import_zod7.z.string()
+var McpAuthCompletedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mcp_auth_completed" /* MCP_AUTH_COMPLETED */),
+  serverName: import_zod8.z.string(),
+  outcome: import_zod8.z.nativeEnum(McpAuthOutcome),
+  message: import_zod8.z.string()
 }).passthrough();
-var McpAuthCompletedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("mcp_auth_completed" /* MCP_AUTH_COMPLETED */),
-  serverName: import_zod7.z.string(),
-  outcome: import_zod7.z.nativeEnum(McpAuthOutcome),
-  message: import_zod7.z.string()
+var HookCommandSchema = import_zod8.z.object({
+  command: import_zod8.z.string(),
+  timeout: import_zod8.z.number().optional()
+}).passthrough();
+var HookResultSchema = import_zod8.z.object({
+  exitCode: import_zod8.z.number(),
+  stdout: import_zod8.z.string(),
+  stderr: import_zod8.z.string(),
+  command: import_zod8.z.string().optional(),
+  timeout: import_zod8.z.number().optional()
+}).passthrough();
+var HookExecutionStartedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("hook_execution_started" /* HOOK_EXECUTION_STARTED */),
+  hookId: import_zod8.z.string(),
+  hookEventName: DroidHookEventSchema,
+  hookMatcher: import_zod8.z.string().optional(),
+  hookCommands: import_zod8.z.array(HookCommandSchema),
+  hookToolCallId: import_zod8.z.string().optional(),
+  isParallelExecution: import_zod8.z.boolean().optional(),
+  parallelGroupId: import_zod8.z.string().optional()
+}).passthrough();
+var HookExecutionCompletedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("hook_execution_completed" /* HOOK_EXECUTION_COMPLETED */),
+  hookId: import_zod8.z.string(),
+  hookEventName: DroidHookEventSchema.optional(),
+  hookMatcher: import_zod8.z.string().optional(),
+  hookToolCallId: import_zod8.z.string().optional(),
+  hookStatus: import_zod8.z.enum(["completed", "error"]),
+  hookResults: import_zod8.z.array(HookResultSchema).optional()
+}).passthrough();
+var StructuredOutputErrorSchema = import_zod8.z.object({
+  code: import_zod8.z.string(),
+  message: import_zod8.z.string(),
+  details: import_zod8.z.unknown().optional()
+}).passthrough();
+var StructuredOutputNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("structured_output" /* STRUCTURED_OUTPUT */),
+  messageId: import_zod8.z.string(),
+  structuredOutput: JsonObjectSchema.nullable(),
+  structuredOutputError: StructuredOutputErrorSchema.nullable()
 }).passthrough();
 var SessionNotificationSchemaList = [
   ToolResultNotificationSchema,
@@ -1752,7 +1896,10 @@ var SessionNotificationSchemaList = [
   SessionTitleUpdatedNotificationSchema,
   McpStatusChangedNotificationSchema,
   AssistantTextDeltaNotificationSchema,
+  AssistantTextCompleteNotificationSchema,
   ThinkingTextDeltaNotificationSchema,
+  ThinkingTextCompleteNotificationSchema,
+  ToolCallNotificationSchema,
   SessionTokenUsageChangedNotificationSchema,
   MissionStateChangedNotificationSchema,
   MissionFeaturesChangedNotificationSchema,
@@ -1761,88 +1908,91 @@ var SessionNotificationSchemaList = [
   MissionWorkerStartedNotificationSchema,
   MissionWorkerCompletedNotificationSchema,
   McpAuthRequiredNotificationSchema,
-  McpAuthCompletedNotificationSchema
+  McpAuthCompletedNotificationSchema,
+  HookExecutionStartedNotificationSchema,
+  HookExecutionCompletedNotificationSchema,
+  StructuredOutputNotificationSchema
 ];
-var SessionNotificationPayloadSchema = import_zod7.z.discriminatedUnion(
+var SessionNotificationPayloadSchema = import_zod8.z.discriminatedUnion(
   "type",
   SessionNotificationSchemaList
 );
-var _SessionNotificationParamsSchema = import_zod7.z.object({
+var _SessionNotificationParamsSchema = import_zod8.z.object({
   notification: SessionNotificationPayloadSchema
 }).passthrough();
 var SessionNotificationParamsSchema = _SessionNotificationParamsSchema;
 var _SessionNotificationSchema = JsonRpcNotificationSchema.extend({
-  method: import_zod7.z.literal("droid.session_notification" /* SESSION_NOTIFICATION */),
+  method: import_zod8.z.literal("droid.session_notification" /* SESSION_NOTIFICATION */),
   params: SessionNotificationParamsSchema
 });
 var SessionNotificationSchema = _SessionNotificationSchema;
-var EditToolConfirmationDetailsSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("edit" /* Edit */),
-  filePath: import_zod7.z.string(),
-  fileName: import_zod7.z.string(),
-  oldContent: import_zod7.z.string().optional(),
-  newContent: import_zod7.z.string().optional()
+var EditToolConfirmationDetailsSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("edit" /* Edit */),
+  filePath: import_zod8.z.string(),
+  fileName: import_zod8.z.string(),
+  oldContent: import_zod8.z.string().optional(),
+  newContent: import_zod8.z.string().optional()
 }).passthrough();
-var ExecuteToolConfirmationDetailsSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("exec" /* Execute */),
-  fullCommand: import_zod7.z.string(),
-  command: import_zod7.z.string(),
-  extractedCommands: import_zod7.z.array(import_zod7.z.string()).optional(),
-  impactLevel: import_zod7.z.string().optional()
+var ExecuteToolConfirmationDetailsSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("exec" /* Execute */),
+  fullCommand: import_zod8.z.string(),
+  command: import_zod8.z.string(),
+  extractedCommands: import_zod8.z.array(import_zod8.z.string()).optional(),
+  impactLevel: import_zod8.z.string().optional()
 }).passthrough();
-var CreateToolConfirmationDetailsSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("create" /* Create */),
-  filePath: import_zod7.z.string(),
-  fileName: import_zod7.z.string(),
-  content: import_zod7.z.string()
+var CreateToolConfirmationDetailsSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("create" /* Create */),
+  filePath: import_zod8.z.string(),
+  fileName: import_zod8.z.string(),
+  content: import_zod8.z.string()
 }).passthrough();
-var AskUserQuestionSchema = import_zod7.z.object({
-  index: import_zod7.z.number(),
-  topic: import_zod7.z.string(),
-  question: import_zod7.z.string(),
-  options: import_zod7.z.array(import_zod7.z.string())
+var AskUserQuestionSchema = import_zod8.z.object({
+  index: import_zod8.z.number(),
+  topic: import_zod8.z.string(),
+  question: import_zod8.z.string(),
+  options: import_zod8.z.array(import_zod8.z.string())
 }).passthrough();
-var AskUserConfirmationDetailsSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("ask_user" /* AskUser */),
-  questionnaire: import_zod7.z.string(),
-  parsed: import_zod7.z.object({
-    questions: import_zod7.z.array(AskUserQuestionSchema)
+var AskUserConfirmationDetailsSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("ask_user" /* AskUser */),
+  questionnaire: import_zod8.z.string(),
+  parsed: import_zod8.z.object({
+    questions: import_zod8.z.array(AskUserQuestionSchema)
   }).optional(),
-  parseError: import_zod7.z.object({
-    message: import_zod7.z.string(),
-    line: import_zod7.z.number().optional()
+  parseError: import_zod8.z.object({
+    message: import_zod8.z.string(),
+    line: import_zod8.z.number().optional()
   }).optional()
 }).passthrough();
-var ExitSpecModeConfirmationDetailsSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("exit_spec_mode" /* ExitSpecMode */),
-  plan: import_zod7.z.string(),
-  title: import_zod7.z.string().optional(),
-  optionNames: import_zod7.z.array(import_zod7.z.string()).optional()
+var ExitSpecModeConfirmationDetailsSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("exit_spec_mode" /* ExitSpecMode */),
+  plan: import_zod8.z.string(),
+  title: import_zod8.z.string().optional(),
+  optionNames: import_zod8.z.array(import_zod8.z.string()).optional()
 }).passthrough();
-var ProposeMissionConfirmationDetailsSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("propose_mission" /* ProposeMission */),
-  proposal: import_zod7.z.string(),
-  title: import_zod7.z.string().optional()
+var ProposeMissionConfirmationDetailsSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("propose_mission" /* ProposeMission */),
+  proposal: import_zod8.z.string(),
+  title: import_zod8.z.string().optional()
 }).passthrough();
-var StartMissionRunConfirmationDetailsSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("start_mission_run" /* StartMissionRun */),
-  runningMissionCount: import_zod7.z.number(),
-  runningMissionSessionIds: import_zod7.z.array(import_zod7.z.string())
+var StartMissionRunConfirmationDetailsSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("start_mission_run" /* StartMissionRun */),
+  runningMissionCount: import_zod8.z.number(),
+  runningMissionSessionIds: import_zod8.z.array(import_zod8.z.string())
 }).passthrough();
-var ApplyPatchToolConfirmationDetailsSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("apply_patch" /* ApplyPatch */),
-  filePath: import_zod7.z.string(),
-  fileName: import_zod7.z.string(),
-  patchContent: import_zod7.z.string(),
-  oldContent: import_zod7.z.string().optional(),
-  newContent: import_zod7.z.string().optional()
+var ApplyPatchToolConfirmationDetailsSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("apply_patch" /* ApplyPatch */),
+  filePath: import_zod8.z.string(),
+  fileName: import_zod8.z.string(),
+  patchContent: import_zod8.z.string(),
+  oldContent: import_zod8.z.string().optional(),
+  newContent: import_zod8.z.string().optional()
 }).passthrough();
-var McpToolConfirmationDetailsSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("mcp_tool" /* McpTool */),
-  toolName: import_zod7.z.string(),
-  impactLevel: import_zod7.z.string()
+var McpToolConfirmationDetailsSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mcp_tool" /* McpTool */),
+  toolName: import_zod8.z.string(),
+  impactLevel: import_zod8.z.string()
 }).passthrough();
-var ToolConfirmationDetailsSchema = import_zod7.z.discriminatedUnion("type", [
+var ToolConfirmationDetailsSchema = import_zod8.z.discriminatedUnion("type", [
   EditToolConfirmationDetailsSchema,
   ExecuteToolConfirmationDetailsSchema,
   CreateToolConfirmationDetailsSchema,
@@ -1853,51 +2003,45 @@ var ToolConfirmationDetailsSchema = import_zod7.z.discriminatedUnion("type", [
   ApplyPatchToolConfirmationDetailsSchema,
   McpToolConfirmationDetailsSchema
 ]);
-var ToolConfirmationInfoSchema = import_zod7.z.object({
+var ToolConfirmationInfoSchema = import_zod8.z.object({
   toolUse: ToolUseSchema,
-  confirmationType: import_zod7.z.nativeEnum(ToolConfirmationType),
+  confirmationType: import_zod8.z.nativeEnum(ToolConfirmationType),
   details: ToolConfirmationDetailsSchema
 }).passthrough();
-var RequestPermissionRequestParamsSchema = import_zod7.z.object({
-  toolUses: import_zod7.z.array(ToolConfirmationInfoSchema),
-  options: import_zod7.z.array(ToolConfirmationListItemSchema)
+var RequestPermissionRequestParamsSchema = import_zod8.z.object({
+  toolUses: import_zod8.z.array(ToolConfirmationInfoSchema),
+  options: import_zod8.z.array(ToolConfirmationListItemSchema)
 }).passthrough();
 var RequestPermissionRequestSchema = JsonRpcRequestSchema.extend({
-  method: import_zod7.z.literal("droid.request_permission" /* REQUEST_PERMISSION */),
+  method: import_zod8.z.literal("droid.request_permission" /* REQUEST_PERMISSION */),
   params: RequestPermissionRequestParamsSchema
 });
-var RequestPermissionResultSchema = import_zod7.z.object({
-  selectedOption: import_zod7.z.nativeEnum(ToolConfirmationOutcome),
-  comment: import_zod7.z.string().optional()
+var RequestPermissionResultSchema = import_zod8.z.object({
+  selectedOption: import_zod8.z.nativeEnum(ToolConfirmationOutcome),
+  comment: import_zod8.z.string().optional()
 }).strict();
-var RequestPermissionResponseSchema = import_zod7.z.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: RequestPermissionResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var AskUserRequestParamsSchema = import_zod7.z.object({
-  toolCallId: import_zod7.z.string(),
-  questions: import_zod7.z.array(AskUserQuestionSchema)
+var RequestPermissionResponseSchema = createResponseSchema(
+  RequestPermissionResultSchema
+);
+var AskUserRequestParamsSchema = import_zod8.z.object({
+  toolCallId: import_zod8.z.string(),
+  questions: import_zod8.z.array(AskUserQuestionSchema)
 }).passthrough();
 var AskUserRequestSchema = JsonRpcRequestSchema.extend({
-  method: import_zod7.z.literal("droid.ask_user" /* ASK_USER */),
+  method: import_zod8.z.literal("droid.ask_user" /* ASK_USER */),
   params: AskUserRequestParamsSchema
 });
-var AskUserCollectedAnswerSchema = import_zod7.z.object({
-  index: import_zod7.z.number(),
-  question: import_zod7.z.string(),
-  answer: import_zod7.z.string()
+var AskUserCollectedAnswerSchema = import_zod8.z.object({
+  index: import_zod8.z.number(),
+  question: import_zod8.z.string(),
+  answer: import_zod8.z.string()
 }).strict();
-var AskUserResultSchema = import_zod7.z.object({
-  cancelled: import_zod7.z.boolean().optional(),
-  answers: import_zod7.z.array(AskUserCollectedAnswerSchema)
+var AskUserResultSchema = import_zod8.z.object({
+  cancelled: import_zod8.z.boolean().optional(),
+  answers: import_zod8.z.array(AskUserCollectedAnswerSchema)
 }).strict();
-var AskUserResponseSchema = import_zod7.z.union([
-  JsonRpcResponseSuccessSchema.extend({ result: AskUserResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var _CliRequestOrNotificationSchema = import_zod7.z.union([
+var AskUserResponseSchema = createResponseSchema(AskUserResultSchema);
+var _CliRequestOrNotificationSchema = import_zod8.z.union([
   SessionNotificationSchema,
   RequestPermissionRequestSchema,
   AskUserRequestSchema
@@ -1905,7 +2049,7 @@ var _CliRequestOrNotificationSchema = import_zod7.z.union([
 var CliRequestOrNotificationSchema = _CliRequestOrNotificationSchema;
 
 // src/constants.ts
-var SDK_VERSION = "0.2.0";
+var SDK_VERSION = "0.4.0";
 var SDK_TAG = {
   name: "sdk",
   metadata: { language: "typescript", version: SDK_VERSION }
@@ -2221,9 +2365,32 @@ var ProcessTransport = class {
 
 // src/protocol.ts
 var import_uuid = require("uuid");
+function dispatchNotification(notification, listeners) {
+  let notificationType;
+  const parsed = SessionNotificationParamsSchema.safeParse(
+    notification["params"]
+  );
+  if (parsed.success) {
+    notificationType = parsed.data.notification.type;
+  }
+  for (const listener of listeners) {
+    if (listener.filter?.type != null && listener.filter.type !== notificationType) {
+      continue;
+    }
+    try {
+      listener.callback(notification);
+    } catch {
+    }
+  }
+}
+var DEFAULT_SERVER_REQUEST_METHOD_MAP = {
+  ["droid.request_permission" /* REQUEST_PERMISSION */]: "permission" /* Permission */,
+  ["droid.ask_user" /* ASK_USER */]: "askUser" /* AskUser */
+};
 var ProtocolEngine = class {
   _transport;
   _defaultTimeout;
+  _serverRequestMethodMap;
   _pendingRequests = /* @__PURE__ */ new Map();
   _notificationListeners = /* @__PURE__ */ new Set();
   _permissionHandler = null;
@@ -2233,6 +2400,7 @@ var ProtocolEngine = class {
   constructor(options) {
     this._transport = options.transport;
     this._defaultTimeout = options.defaultTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+    this._serverRequestMethodMap = options.serverRequestMethodMap ?? DEFAULT_SERVER_REQUEST_METHOD_MAP;
     this._transport.onMessage((message) => {
       this._handleMessage(message);
     });
@@ -2385,27 +2553,13 @@ var ProtocolEngine = class {
     pending.resolve(result);
   }
   _handleNotification(notification) {
-    let notificationType;
-    const parsed = SessionNotificationParamsSchema.safeParse(
-      notification["params"]
-    );
-    if (parsed.success) {
-      notificationType = parsed.data.notification.type;
-    }
-    for (const listener of this._notificationListeners) {
-      if (listener.filter?.type != null && listener.filter.type !== notificationType) {
-        continue;
-      }
-      try {
-        listener.callback(notification);
-      } catch {
-      }
-    }
+    dispatchNotification(notification, this._notificationListeners);
   }
   async _handleServerRequest(method, requestId, params) {
-    if (method === "droid.request_permission" /* REQUEST_PERMISSION */) {
+    const handlerType = this._serverRequestMethodMap[method];
+    if (handlerType === "permission" /* Permission */) {
       await this._handlePermissionRequest(requestId, params);
-    } else if (method === "droid.ask_user" /* ASK_USER */) {
+    } else if (handlerType === "askUser" /* AskUser */) {
       await this._handleAskUserRequest(requestId, params);
     }
   }
@@ -2521,10 +2675,6 @@ var DroidClient = class {
   _engine;
   _sessionId = null;
   _closed = false;
-  /**
-   * Client-level notification listeners.
-   * Each entry is [callback, optional notification filter].
-   */
   _notificationListeners = [];
   /** Client-level permission handler. */
   _permissionHandler = null;
@@ -2598,6 +2748,13 @@ var DroidClient = class {
       InterruptSessionResultSchema
     );
   }
+  async closeSession(params = {}) {
+    return this._sessionRpc(
+      "droid.close_session" /* CLOSE_SESSION */,
+      params,
+      CloseSessionResultSchema
+    );
+  }
   async killWorkerSession(params) {
     return this._sessionRpc(
       "droid.kill_worker_session" /* KILL_WORKER_SESSION */,
@@ -2786,23 +2943,7 @@ var DroidClient = class {
     await this._engine.close();
   }
   _dispatchNotification(notification) {
-    let notificationType;
-    const parsed = SessionNotificationParamsSchema.safeParse(
-      notification["params"]
-    );
-    if (parsed.success) {
-      notificationType = parsed.data.notification.type;
-    }
-    const listeners = [...this._notificationListeners];
-    for (const listener of listeners) {
-      if (listener.filter?.type != null && listener.filter.type !== notificationType) {
-        continue;
-      }
-      try {
-        listener.callback(notification);
-      } catch {
-      }
-    }
+    dispatchNotification(notification, [...this._notificationListeners]);
   }
   _dispatchPermissionRequest(params) {
     const handler = this._permissionHandler;
@@ -2836,14 +2977,18 @@ var DroidClient = class {
 
 // src/stream.ts
 var DroidMessageType = {
+  Assistant: "assistant",
+  User: "user",
+  ToolCall: "tool_call",
   AssistantTextDelta: "assistant_text_delta",
+  AssistantTextComplete: "assistant_text_complete",
   ThinkingTextDelta: "thinking_text_delta",
-  ToolUse: "tool_use",
+  ThinkingTextComplete: "thinking_text_complete",
+  ToolCallDelta: "tool_call_delta",
   ToolResult: "tool_result",
   ToolProgress: "tool_progress",
   WorkingStateChanged: "working_state_changed",
   TokenUsageUpdate: "token_usage_update",
-  CreateMessage: "create_message",
   PermissionResolved: "permission_resolved",
   SettingsUpdated: "settings_updated",
   SessionTitleUpdated: "session_title_updated",
@@ -2856,8 +3001,9 @@ var DroidMessageType = {
   MissionWorkerCompleted: "mission_worker_completed",
   McpAuthRequired: "mcp_auth_required",
   McpAuthCompleted: "mcp_auth_completed",
+  Hook: "hook",
   Error: "error",
-  TurnComplete: "turn_complete"
+  Result: "result"
 };
 function convertNotificationToStreamMessage(raw) {
   const parsed = SessionNotificationPayloadSchema.safeParse(raw);
@@ -2873,6 +3019,12 @@ function convertNotificationToStreamMessage(raw) {
         blockIndex: notification.blockIndex,
         text: notification.textDelta
       };
+    case "assistant_text_complete" /* ASSISTANT_TEXT_COMPLETE */:
+      return {
+        type: DroidMessageType.AssistantTextComplete,
+        messageId: notification.messageId,
+        blockIndex: notification.blockIndex
+      };
     case "thinking_text_delta" /* THINKING_TEXT_DELTA */:
       return {
         type: DroidMessageType.ThinkingTextDelta,
@@ -2880,6 +3032,18 @@ function convertNotificationToStreamMessage(raw) {
         blockIndex: notification.blockIndex,
         text: notification.textDelta
       };
+    case "thinking_text_complete" /* THINKING_TEXT_COMPLETE */:
+      return {
+        type: DroidMessageType.ThinkingTextComplete,
+        messageId: notification.messageId,
+        blockIndex: notification.blockIndex,
+        durationMs: notification.durationMs
+      };
+    case "tool_call" /* TOOL_CALL */:
+      return {
+        type: DroidMessageType.ToolCallDelta,
+        toolUse: notification.toolUse
+      };
     case "tool_result" /* TOOL_RESULT */:
       return {
         type: DroidMessageType.ToolResult,
@@ -2919,22 +3083,33 @@ function convertNotificationToStreamMessage(raw) {
       const msg = notification.message;
       const messages = [];
       for (const block of msg.content) {
-        if (block.type === DroidMessageType.ToolUse) {
+        if (block.type === "tool_use") {
           messages.push({
-            type: DroidMessageType.ToolUse,
-            toolName: block.name,
-            toolInput: block.input,
-            toolUseId: block.id
+            type: DroidMessageType.ToolCall,
+            toolUse: block
           });
         }
       }
-      messages.push({
-        type: DroidMessageType.CreateMessage,
-        messageId: msg.id,
-        role: msg.role,
-        content: msg.content,
-        parentId: notification.parentId
-      });
+      if (msg.role === FactoryDroidMessageRole.Assistant) {
+        messages.push({
+          type: DroidMessageType.Assistant,
+          message: msg,
+          text: extractTextFromMessage(msg)
+        });
+      } else if (msg.role === FactoryDroidMessageRole.User) {
+        messages.push({
+          type: DroidMessageType.User,
+          message: msg
+        });
+      } else {
+        messages.push({
+          type: "create_message",
+          messageId: msg.id,
+          role: msg.role,
+          content: msg.content,
+          parentId: notification.parentId
+        });
+      }
       return messages;
     }
     case "error" /* ERROR */:
@@ -3013,42 +3188,205 @@ function convertNotificationToStreamMessage(raw) {
         outcome: notification.outcome,
         message: notification.message
       };
+    case "hook_execution_started" /* HOOK_EXECUTION_STARTED */:
+      return notification.hookCommands.map((hookCommand) => ({
+        type: DroidMessageType.Hook,
+        hookId: notification.hookId,
+        eventName: notification.hookEventName,
+        matcher: notification.hookMatcher,
+        toolCallId: notification.hookToolCallId,
+        command: hookCommand.command,
+        timeout: hookCommand.timeout,
+        status: "started"
+      }));
+    case "hook_execution_completed" /* HOOK_EXECUTION_COMPLETED */:
+      return (notification.hookResults ?? []).map((hookResult) => ({
+        type: DroidMessageType.Hook,
+        hookId: notification.hookId,
+        eventName: notification.hookEventName,
+        matcher: notification.hookMatcher,
+        toolCallId: notification.hookToolCallId,
+        command: hookResult.command,
+        timeout: hookResult.timeout,
+        status: notification.hookStatus,
+        exitCode: hookResult.exitCode,
+        stdout: hookResult.stdout,
+        stderr: hookResult.stderr
+      }));
+    case "structured_output" /* STRUCTURED_OUTPUT */:
+      return {
+        type: "structured_output",
+        messageId: notification.messageId,
+        structuredOutput: notification.structuredOutput,
+        structuredOutputError: notification.structuredOutputError
+      };
     default:
       return null;
   }
 }
 var StreamStateTracker = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
   hasBeenNonIdle = false;
   lastTokenUsage = null;
+  fullText = "";
+  finalAssistantText = "";
+  structuredOutput = null;
+  structuredOutputError = null;
+  errors = [];
+  numTurns = 0;
+  emittedMessages = [];
   toolNameMap = /* @__PURE__ */ new Map();
   getToolName(toolUseId) {
     return this.toolNameMap.get(toolUseId) ?? "";
   }
   processMessage(message) {
     const additional = [];
-    if (message.type === DroidMessageType.ToolUse) {
+    if (message.type === "tool_use") {
       this.toolNameMap.set(message.toolUseId, message.toolName);
     }
+    if (message.type === DroidMessageType.ToolCall) {
+      this.toolNameMap.set(message.toolUse.id, message.toolUse.name);
+    }
+    if (message.type === DroidMessageType.ToolCallDelta) {
+      this.toolNameMap.set(message.toolUse.id, message.toolUse.name);
+    }
     if (message.type === DroidMessageType.ToolResult) {
       message = { ...message, toolName: this.getToolName(message.toolUseId) };
     }
+    if (message.type === DroidMessageType.AssistantTextDelta) {
+      this.fullText += message.text;
+    }
+    if (message.type === DroidMessageType.Assistant) {
+      this.finalAssistantText = message.text;
+      if (this.fullText.length === 0) {
+        this.fullText = message.text;
+      }
+    }
     if (message.type === DroidMessageType.TokenUsageUpdate) {
       this.lastTokenUsage = message;
     }
+    if (message.type === DroidMessageType.Error) {
+      this.errors.push(message);
+    }
+    if (message.type === "structured_output") {
+      this.structuredOutput = message.structuredOutput;
+      this.structuredOutputError = message.structuredOutputError;
+      return { message: null, additional };
+    }
     if (message.type === DroidMessageType.WorkingStateChanged) {
       if (message.state !== "idle" /* Idle */) {
         this.hasBeenNonIdle = true;
       } else if (this.hasBeenNonIdle) {
-        additional.push({
-          type: DroidMessageType.TurnComplete,
-          tokenUsage: this.lastTokenUsage
-        });
+        this.numTurns++;
+        additional.push(this.createResultMessage());
         this.hasBeenNonIdle = false;
+        this.resetTurnState();
       }
     }
+    if (message.type !== DroidMessageType.WorkingStateChanged) {
+      this.trackEmittedMessage(message);
+    }
     return { message, additional };
   }
+  createResultMessage() {
+    if (this.options.hasOutputFormat && this.structuredOutput === null && this.structuredOutputError === null) {
+      this.structuredOutput = parseJsonObject(this.finalAssistantText || this.fullText) ?? null;
+    }
+    const tokenUsage = this.lastTokenUsage ? stripTokenUsageType(this.lastTokenUsage) : null;
+    const result = this.finalAssistantText || this.fullText;
+    const base = {
+      type: DroidMessageType.Result,
+      sessionId: this.options.sessionId ?? "",
+      durationMs: Date.now() - (this.options.startedAt ?? Date.now()),
+      numTurns: this.numTurns,
+      result,
+      tokenUsage,
+      messages: [...this.emittedMessages],
+      text: result,
+      turnCount: this.numTurns
+    };
+    if (this.structuredOutputError) {
+      return {
+        ...base,
+        subtype: "error_structured_output",
+        isError: true,
+        success: false,
+        errors: [this.structuredOutputError.message],
+        structuredOutput: this.structuredOutput,
+        structuredOutputError: this.structuredOutputError,
+        error: null
+      };
+    }
+    if (this.errors.length > 0) {
+      return {
+        ...base,
+        subtype: "error_during_execution",
+        isError: true,
+        success: false,
+        errors: this.errors.map((error) => error.message),
+        structuredOutput: this.structuredOutput,
+        structuredOutputError: null,
+        error: this.errors[0] ?? null
+      };
+    }
+    return {
+      ...base,
+      subtype: "success",
+      isError: false,
+      success: true,
+      structuredOutput: this.structuredOutput,
+      structuredOutputError: null,
+      error: null
+    };
+  }
+  trackEmittedMessage(message) {
+    if (isDefaultStreamMessage(message)) {
+      this.emittedMessages.push(message);
+    }
+  }
+  resetTurnState() {
+    this.lastTokenUsage = null;
+    this.fullText = "";
+    this.finalAssistantText = "";
+    this.structuredOutput = null;
+    this.structuredOutputError = null;
+    this.errors = [];
+    this.emittedMessages = [];
+  }
 };
+function isInternalMessage(message) {
+  return message.type === "structured_output" || message.type === "tool_use" || message.type === "create_message";
+}
+function isDefaultStreamMessage(message) {
+  return message.type === DroidMessageType.Assistant || message.type === DroidMessageType.User || message.type === DroidMessageType.ToolCall || message.type === DroidMessageType.ToolResult || message.type === DroidMessageType.Hook || message.type === DroidMessageType.Error || message.type === DroidMessageType.Result;
+}
+function stripTokenUsageType(message) {
+  const {
+    inputTokens,
+    outputTokens,
+    cacheCreationTokens,
+    cacheReadTokens,
+    thinkingTokens
+  } = message;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheCreationTokens,
+    cacheReadTokens,
+    thinkingTokens
+  };
+}
+function parseJsonObject(text) {
+  try {
+    const parsed = JSON.parse(text);
+    const result = JsonObjectSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}
 function normalizeToolResultContent(content) {
   if (content == null) {
     return "";
@@ -3061,6 +3399,9 @@ function normalizeToolResultContent(content) {
   }
   return String(content);
 }
+function extractTextFromMessage(message) {
+  return message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
 
 // src/helpers.ts
 function wireAbortSignal(signal, onAbort) {
@@ -3076,15 +3417,88 @@ function wireAbortSignal(signal, onAbort) {
     return () => signal.removeEventListener("abort", listener);
   }
 }
+function getAbortError(signal) {
+  if (signal.reason instanceof Error) {
+    return signal.reason;
+  }
+  return new Error(
+    typeof signal.reason === "string" ? signal.reason : "Operation aborted"
+  );
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw getAbortError(signal);
+  }
+}
+async function* streamFromClient(client, sessionId, activeBridges, prompt, options) {
+  throwIfAborted(options?.abortSignal);
+  const startedAt = Date.now();
+  let resolveDone = () => {
+  };
+  const donePromise = new Promise((resolve2) => {
+    resolveDone = resolve2;
+  });
+  const bridge = new MessageBridge(resolveDone, {
+    includePartialMessages: options?.includePartialMessages,
+    sessionId,
+    startedAt,
+    outputFormat: options?.outputFormat
+  });
+  activeBridges.add(bridge);
+  const unsubscribe = client.onNotification(bridge.notificationHandler);
+  let resolveAbort = () => {
+  };
+  const abortPromise = new Promise((resolve2) => {
+    resolveAbort = resolve2;
+  });
+  const cleanupAbortSignal = wireAbortSignal(options?.abortSignal, () => {
+    bridge.signalDone();
+    resolveAbort();
+    void client.interruptSession().catch(() => {
+    });
+  });
+  try {
+    await Promise.race([
+      client.addUserMessage({
+        text: prompt,
+        images: options?.images,
+        files: options?.files,
+        outputFormat: options?.outputFormat
+      }),
+      donePromise,
+      abortPromise
+    ]);
+    throwIfAborted(options?.abortSignal);
+    for await (const msg of bridge.messages()) {
+      throwIfAborted(options?.abortSignal);
+      yield msg;
+    }
+    throwIfAborted(options?.abortSignal);
+  } finally {
+    cleanupAbortSignal();
+    unsubscribe();
+    activeBridges.delete(bridge);
+  }
+}
 function extractInnerNotification(notification) {
   const parsed = SessionNotificationSchema.safeParse(notification);
   return parsed.success ? parsed.data.params.notification : null;
 }
 var MessageBridge = class {
+  constructor(onDone, _options = {}) {
+    this._options = _options;
+    this._onDone = onDone;
+    this._stateTracker = new StreamStateTracker({
+      sessionId: _options.sessionId,
+      startedAt: _options.startedAt,
+      hasOutputFormat: _options.outputFormat !== void 0
+    });
+  }
   _queue = [];
+  _onDone;
   _resolveWaiting = null;
   _done = false;
-  _stateTracker = new StreamStateTracker();
+  _stateTracker;
   notificationHandler = (notification) => {
     const inner = extractInnerNotification(notification);
     if (!inner) return;
@@ -3093,10 +3507,14 @@ var MessageBridge = class {
     const messages = Array.isArray(converted) ? converted : [converted];
     for (const msg of messages) {
       const { message, additional } = this._stateTracker.processMessage(msg);
-      this._enqueue(message);
+      if (message && this._shouldYield(message)) {
+        this._enqueue(message);
+      }
       for (const extra of additional) {
-        this._enqueue(extra);
-        if (extra.type === DroidMessageType.TurnComplete) {
+        if (this._shouldYield(extra)) {
+          this._enqueue(extra);
+        }
+        if (extra.type === DroidMessageType.Result) {
           this._signalDone();
         }
       }
@@ -3110,7 +3528,7 @@ var MessageBridge = class {
       while (this._queue.length > 0) {
         const msg = this._queue.shift();
         yield msg;
-        if (msg.type === DroidMessageType.TurnComplete) {
+        if (msg.type === DroidMessageType.Result) {
           return;
         }
       }
@@ -3122,6 +3540,12 @@ var MessageBridge = class {
       });
     }
   }
+  _shouldYield(message) {
+    if (isInternalMessage(message)) {
+      return false;
+    }
+    return this._options.includePartialMessages ? true : isDefaultStreamMessage(message);
+  }
   _enqueue(msg) {
     this._queue.push(msg);
     if (this._resolveWaiting) {
@@ -3131,7 +3555,11 @@ var MessageBridge = class {
     }
   }
   _signalDone() {
+    const wasDone = this._done;
     this._done = true;
+    if (!wasDone) {
+      this._onDone?.();
+    }
     if (this._resolveWaiting) {
       const resolve2 = this._resolveWaiting;
       this._resolveWaiting = null;
@@ -3147,7 +3575,7 @@ async function createTransport(options) {
     execPath: options.execPath,
     execArgs: options.execArgs,
     cwd: options.cwd,
-    env: options.env
+    env: { ...options.env, FACTORY_API_KEY: options.apiKey }
   };
   const processTransport = new ProcessTransport(transportOptions);
   await processTransport.connect();
@@ -3205,6 +3633,9 @@ function buildInitParams(options) {
     ...options.disabledToolIds !== void 0 && {
       disabledToolIds: options.disabledToolIds
     },
+    ...options.sessionSource !== void 0 && {
+      sessionSource: options.sessionSource
+    },
     tags: [...options.tags ?? [], SDK_TAG]
   };
 }
@@ -3214,7 +3645,7 @@ var import_node_events = require("events");
 var import_node_http = __toESM(require("http"), 1);
 var import_mcp4 = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 function tool(name, description, inputSchemaOrHandler, handler) {
   if (typeof inputSchemaOrHandler === "function") {
     const actualHandler = inputSchemaOrHandler;
@@ -3227,7 +3658,7 @@ function tool(name, description, inputSchemaOrHandler, handler) {
   if (!handler) {
     throw new Error(`Missing handler for SDK MCP tool "${name}"`);
   }
-  const inputObjectSchema = import_zod8.z.object(inputSchemaOrHandler);
+  const inputObjectSchema = import_zod9.z.object(inputSchemaOrHandler);
   return {
     name,
     description,
@@ -3404,325 +3835,62 @@ async function startSdkMcpServers(servers) {
   };
 }
 
-// src/query.ts
-var DroidQueryImpl = class {
-  _generator;
-  _getSessionId;
-  _getInitResult;
-  _getInitialized;
-  _interruptFn;
-  _abortFn;
-  constructor(generator, getSessionId, getInitResult, getInitialized, interruptFn, abortFn) {
-    this._generator = generator;
-    this._getSessionId = getSessionId;
-    this._getInitResult = getInitResult;
-    this._getInitialized = getInitialized;
-    this._interruptFn = interruptFn;
-    this._abortFn = abortFn;
+// src/session.ts
+var DroidSession = class {
+  _client;
+  _sessionId;
+  _initResult;
+  _closed = false;
+  _cleanupAbortSignal = null;
+  _cleanupCallbacks = [];
+  _activeBridges = /* @__PURE__ */ new Set();
+  /** @internal */
+  constructor(client, sessionId, initResult) {
+    this._client = client;
+    this._sessionId = sessionId;
+    this._initResult = initResult;
   }
   get sessionId() {
-    return this._getSessionId();
+    return this._sessionId;
   }
   get initResult() {
-    return this._getInitResult();
-  }
-  get initialized() {
-    return this._getInitialized();
-  }
-  async interrupt() {
-    return this._interruptFn();
-  }
-  abort() {
-    this._abortFn();
+    return this._initResult;
   }
-  next(...args) {
-    return this._generator.next(...args);
+  /** @internal */
+  setAbortSignalCleanup(cleanup) {
+    this._cleanupAbortSignal = cleanup;
   }
-  return(value) {
-    return this._generator.return(value);
+  /** @internal */
+  addCleanup(cleanup) {
+    this._cleanupCallbacks.push(cleanup);
   }
-  throw(e) {
-    return this._generator.throw(e);
+  async *stream(prompt, options) {
+    this._ensureNotClosed();
+    yield* streamFromClient(
+      this._client,
+      this._sessionId,
+      this._activeBridges,
+      prompt,
+      options
+    );
   }
-  [Symbol.asyncIterator]() {
-    return this;
+  async interrupt() {
+    this._ensureNotClosed();
+    await this._client.interruptSession();
   }
-};
-function query(options) {
-  let transport = null;
-  let client = null;
-  let sessionId = null;
-  let initResult = null;
-  let aborted = false;
-  let initializationPromise = null;
-  let promptPromise = null;
-  let cleanupAbortSignal = () => {
-  };
-  let cleanupSdkMcpServers = null;
-  const bridge = new MessageBridge();
-  const closeActiveResources = async () => {
-    const closer = client ?? transport;
-    const cleanupMcp = cleanupSdkMcpServers;
-    client = null;
-    transport = null;
-    cleanupSdkMcpServers = null;
-    await Promise.all([closeQuietly(closer), cleanupMcp?.()]);
-  };
-  const ensureInitialized = () => {
-    if (initResult) {
-      return Promise.resolve(initResult);
-    }
-    if (initializationPromise) {
-      return initializationPromise;
-    }
-    initializationPromise = (async () => {
-      try {
-        if (aborted) {
-          throw new Error("Query aborted before initialization");
-        }
-        const configuredClient = await createConfiguredClient(options);
-        transport = configuredClient.transport;
-        client = configuredClient.client;
-        client.onNotification(bridge.notificationHandler);
-        if (aborted) {
-          throw new Error("Query aborted before initialization");
-        }
-        const sdkMcpServers = await startSdkMcpServers(options.mcpServers);
-        cleanupSdkMcpServers = sdkMcpServers.cleanup;
-        const result = await client.initializeSession(
-          buildInitParams({
-            ...options,
-            mcpServers: sdkMcpServers.mcpServers
-          })
-        );
-        sessionId = result.sessionId;
-        initResult = result;
-        return result;
-      } catch (error) {
-        await closeActiveResources();
-        throw error;
-      }
-    })();
-    return initializationPromise;
-  };
-  const ensurePromptSent = () => {
-    if (promptPromise) {
-      return promptPromise;
-    }
-    promptPromise = (async () => {
-      await ensureInitialized();
-      if (aborted || client === null) {
-        return;
-      }
-      await client.addUserMessage({ text: options.prompt });
-    })();
-    return promptPromise;
-  };
-  async function* generateMessages() {
-    if (aborted) return;
-    await ensurePromptSent();
-    if (aborted) return;
-    for await (const msg of bridge.messages()) {
-      if (aborted) return;
-      yield msg;
-    }
-  }
-  const generator = generateMessages();
-  async function* wrappedGenerator() {
-    try {
-      yield* generator;
-    } finally {
-      cleanupAbortSignal();
-      await closeActiveResources();
-    }
-  }
-  const droidQuery = new DroidQueryImpl(
-    wrappedGenerator(),
-    () => sessionId,
-    () => initResult,
-    () => ensureInitialized(),
-    async () => {
-      if (client && !aborted) {
-        await client.interruptSession();
-      }
-    },
-    () => {
-      aborted = true;
-      bridge.signalDone();
-      cleanupAbortSignal();
-      void closeActiveResources();
-    }
-  );
-  cleanupAbortSignal = wireAbortSignal(
-    options.abortSignal,
-    () => droidQuery.abort()
-  );
-  return droidQuery;
-}
-
-// src/session.ts
-function getAbortError(signal) {
-  if (signal.reason instanceof Error) {
-    return signal.reason;
-  }
-  return new Error(
-    typeof signal.reason === "string" ? signal.reason : "Operation aborted"
-  );
-}
-function throwIfAborted(signal) {
-  if (signal?.aborted) {
-    throw getAbortError(signal);
-  }
-}
-function parseJsonObject(text) {
-  try {
-    const parsed = JSON.parse(text);
-    const result = JsonObjectSchema.safeParse(parsed);
-    return result.success ? result.data : null;
-  } catch {
-    return null;
-  }
-}
-function extractAssistantText(message) {
-  if (message.type !== DroidMessageType.CreateMessage) {
-    return "";
-  }
-  if (message.role !== FactoryDroidMessageRole.Assistant) {
-    return "";
-  }
-  return message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
-}
-var DroidSession = class {
-  _client;
-  _sessionId;
-  _initResult;
-  _closed = false;
-  _cleanupAbortSignal = null;
-  _cleanupCallbacks = [];
-  /** @internal */
-  constructor(client, sessionId, initResult) {
-    this._client = client;
-    this._sessionId = sessionId;
-    this._initResult = initResult;
-  }
-  get sessionId() {
-    return this._sessionId;
-  }
-  get initResult() {
-    return this._initResult;
-  }
-  /** @internal */
-  setAbortSignalCleanup(cleanup) {
-    this._cleanupAbortSignal = cleanup;
-  }
-  /** @internal */
-  addCleanup(cleanup) {
-    this._cleanupCallbacks.push(cleanup);
-  }
-  /** Yields {@link DroidMessage} events until `turn_complete`. */
-  async *stream(text, options) {
-    this._ensureNotClosed();
-    throwIfAborted(options?.abortSignal);
-    const bridge = new MessageBridge();
-    const unsubscribe = this._client.onNotification(bridge.notificationHandler);
-    let resolveAbort = () => {
-    };
-    const abortPromise = new Promise((resolve2) => {
-      resolveAbort = resolve2;
-    });
-    const cleanupAbortSignal = wireAbortSignal(options?.abortSignal, () => {
-      bridge.signalDone();
-      resolveAbort();
-      void this._client.interruptSession().catch(() => {
-      });
-    });
-    try {
-      await Promise.race([
-        this._client.addUserMessage({
-          text,
-          images: options?.images,
-          files: options?.files,
-          outputFormat: options?.outputFormat
-        }),
-        abortPromise
-      ]);
-      throwIfAborted(options?.abortSignal);
-      for await (const msg of bridge.messages()) {
-        throwIfAborted(options?.abortSignal);
-        yield msg;
-      }
-      throwIfAborted(options?.abortSignal);
-    } finally {
-      cleanupAbortSignal();
-      unsubscribe();
-    }
-  }
-  /** Consumes the stream and returns an aggregated {@link DroidResult}. */
-  async send(text, options) {
-    this._ensureNotClosed();
-    const messages = [];
-    let fullText = "";
-    let lastTokenUsage = null;
-    let firstError = null;
-    let structuredOutput = null;
-    let finalAssistantText = "";
-    let turnCount = 0;
-    const startedAt = Date.now();
-    for await (const msg of this.stream(text, options)) {
-      messages.push(msg);
-      if (msg.type === DroidMessageType.AssistantTextDelta) {
-        fullText += msg.text;
-      }
-      const assistantText = extractAssistantText(msg);
-      if (assistantText) {
-        finalAssistantText = assistantText;
-        if (options?.outputFormat && fullText.length === 0) {
-          fullText = assistantText;
-        }
-      }
-      if (msg.type === DroidMessageType.TokenUsageUpdate) {
-        lastTokenUsage = msg;
-      }
-      if (msg.type === DroidMessageType.Error && firstError === null) {
-        firstError = msg;
-      }
-      if (options?.outputFormat && structuredOutput === null) {
-        const textToParse = finalAssistantText || fullText;
-        if (textToParse) {
-          structuredOutput = parseJsonObject(textToParse);
-        }
-      }
-      if (msg.type === DroidMessageType.TurnComplete) {
-        turnCount++;
-        if (msg.tokenUsage) {
-          lastTokenUsage = msg.tokenUsage;
-        }
-      }
-    }
-    return {
-      sessionId: this._sessionId,
-      text: fullText,
-      messages,
-      tokenUsage: lastTokenUsage,
-      durationMs: Date.now() - startedAt,
-      turnCount,
-      error: firstError,
-      structuredOutput,
-      success: firstError === null
-    };
-  }
-  async interrupt() {
-    this._ensureNotClosed();
-    await this._client.interruptSession();
-  }
-  async close() {
-    if (this._closed) {
-      return;
+  async close() {
+    if (this._closed) {
+      return;
     }
     this._closed = true;
     this._cleanupAbortSignal?.();
     this._cleanupAbortSignal = null;
+    for (const bridge of this._activeBridges) {
+      bridge.signalDone();
+    }
     try {
+      await this._client.closeSession({ reason: "other" }).catch(() => {
+      });
       await this._client.close();
     } finally {
       const cleanups = this._cleanupCallbacks.splice(0);
@@ -3807,7 +3975,7 @@ var DroidSession = class {
     }
   }
 };
-async function createSession(options = {}) {
+async function createSession(options) {
   const { client } = await createConfiguredClient(options);
   let cleanupInitAbortSignal = options.abortSignal?.aborted ? () => {
   } : wireAbortSignal(options.abortSignal, () => {
@@ -3837,7 +4005,7 @@ async function createSession(options = {}) {
     throw error;
   }
 }
-async function resumeSession(sessionId, options = {}) {
+async function resumeSession(sessionId, options) {
   const { client } = await createConfiguredClient(options);
   let sdkMcpServers;
   try {
@@ -3861,10 +4029,18 @@ async function resumeSession(sessionId, options = {}) {
 }
 
 // src/run.ts
-async function run(text, options = {}) {
+async function run(prompt, options) {
   const session = await createSession(options);
   try {
-    return await session.send(text, options);
+    for await (const msg of session.stream(prompt, {
+      ...options,
+      includePartialMessages: false
+    })) {
+      if (msg.type === DroidMessageType.Result) {
+        return msg;
+      }
+    }
+    throw new Error("Stream completed without a result message");
   } finally {
     await session.close();
   }
@@ -4093,6 +4269,1431 @@ async function listSessions(options = {}) {
   }
   return sorted;
 }
+
+// src/api-types.ts
+var import_zod10 = require("zod");
+var EnvironmentVariableSchema = import_zod10.z.object({
+  key: import_zod10.z.string(),
+  value: import_zod10.z.string()
+});
+var MachineTemplateBuildStatusSchema = import_zod10.z.object({
+  status: import_zod10.z.enum(["building", "success", "failed"]),
+  failureReason: import_zod10.z.enum(["setup_script_error", "system_error"]).optional(),
+  buildStartedAt: import_zod10.z.number().int().optional(),
+  builtAt: import_zod10.z.number().int().optional(),
+  logs: import_zod10.z.string().optional()
+});
+var MachineTemplateSchema = import_zod10.z.object({
+  templateId: import_zod10.z.string(),
+  repoUrl: import_zod10.z.string(),
+  templateName: import_zod10.z.string(),
+  defaultBranch: import_zod10.z.string(),
+  createdBy: import_zod10.z.string(),
+  createdAt: import_zod10.z.number().int().optional(),
+  buildStatus: MachineTemplateBuildStatusSchema.optional(),
+  lastUpdatedAt: import_zod10.z.number().int().nullable().optional(),
+  environmentVariables: import_zod10.z.array(EnvironmentVariableSchema).optional(),
+  userEnvironmentVariablesByUser: import_zod10.z.array(EnvironmentVariableSchema).optional(),
+  setupScript: import_zod10.z.string().optional()
+});
+var MachineTemplateListResponseSchema = import_zod10.z.object({
+  templates: import_zod10.z.array(MachineTemplateSchema),
+  pagination: import_zod10.z.object({
+    hasMore: import_zod10.z.boolean(),
+    nextCursor: import_zod10.z.string().nullable()
+  })
+});
+var ComputerSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  name: import_zod10.z.string(),
+  hostname: import_zod10.z.string().optional(),
+  providerType: import_zod10.z.enum(["byom", "e2b"]),
+  status: import_zod10.z.enum(["provisioning", "active", "error"]).optional(),
+  createdAt: import_zod10.z.number().int(),
+  relayClientUrl: import_zod10.z.string().optional(),
+  remoteUser: import_zod10.z.string().optional()
+}).passthrough();
+var ComputerListResponseSchema = import_zod10.z.object({
+  computers: import_zod10.z.array(ComputerSchema)
+});
+var RefreshComputerResponseSchema = import_zod10.z.object({
+  configured: import_zod10.z.number().int()
+});
+var ComputerMetricSchema = import_zod10.z.object({
+  timestamp: import_zod10.z.string(),
+  cpuUsedPct: import_zod10.z.number(),
+  cpuCount: import_zod10.z.number(),
+  memUsed: import_zod10.z.number(),
+  memTotal: import_zod10.z.number(),
+  diskUsed: import_zod10.z.number(),
+  diskTotal: import_zod10.z.number()
+});
+var ComputerMetricsResponseSchema = import_zod10.z.array(ComputerMetricSchema);
+var RemoteSessionSchema = import_zod10.z.object({
+  sessionId: import_zod10.z.string(),
+  title: import_zod10.z.string().optional(),
+  status: import_zod10.z.enum(["idle", "pending", "running"]),
+  messageCount: import_zod10.z.number().int(),
+  createdAt: import_zod10.z.number().int(),
+  updatedAt: import_zod10.z.number().int(),
+  completedAt: import_zod10.z.number().int().optional(),
+  computerId: import_zod10.z.string().optional()
+});
+var RemoteSessionListResponseSchema = import_zod10.z.object({
+  sessions: import_zod10.z.array(RemoteSessionSchema),
+  pagination: import_zod10.z.object({
+    hasMore: import_zod10.z.boolean(),
+    nextCursor: import_zod10.z.string().nullable()
+  })
+});
+
+// src/api.ts
+var DEFAULT_BASE_URL = "https://api.factory.ai";
+function extractErrorMessage(body, status) {
+  if (isRecord(body) && typeof body["error"] === "string") {
+    return body["error"];
+  }
+  return `Factory API error (status ${status})`;
+}
+async function factoryFetch(path3, apiKey, baseUrl, options) {
+  const url = `${baseUrl ?? DEFAULT_BASE_URL}${path3}`;
+  const method = options?.method ?? "GET";
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    Accept: "application/json"
+  };
+  if (options?.body) {
+    headers["Content-Type"] = "application/json";
+  }
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      ...options?.body ? { body: JSON.stringify(options.body) } : {}
+    });
+  } catch (error) {
+    throw new ConnectionError(
+      `Failed to reach Factory API: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (response.status === 204) {
+    return void 0;
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    throw new ProtocolError(
+      `Factory API returned non-JSON response (status ${response.status})`
+    );
+  }
+  if (!response.ok) {
+    const message = extractErrorMessage(body, response.status);
+    if (response.status === 401 || response.status === 403) {
+      throw new ProtocolError(`Invalid or expired API key: ${message}`, {
+        code: response.status
+      });
+    }
+    throw new ProtocolError(message, { code: response.status });
+  }
+  return body;
+}
+function parseResponse(body, schema) {
+  const parsed = schema.safeParse(body);
+  if (!parsed.success) {
+    throw new ProtocolError(
+      `Unexpected response format from Factory API: ${parsed.error.message}`
+    );
+  }
+  return parsed.data;
+}
+async function listMachineTemplates(options) {
+  const params = new URLSearchParams();
+  if (options.limit != null) {
+    params.set("limit", String(options.limit));
+  }
+  if (options.cursor != null) {
+    params.set("cursor", options.cursor);
+  }
+  const query = params.toString();
+  const path3 = `/api/v0/machines/templates${query ? `?${query}` : ""}`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, MachineTemplateListResponseSchema);
+}
+async function getMachineTemplate(options) {
+  const path3 = `/api/v0/machines/templates/${encodeURIComponent(options.templateId)}`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, MachineTemplateSchema);
+}
+async function listComputers(options) {
+  const path3 = "/api/v0/computers";
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, ComputerListResponseSchema);
+}
+async function getComputer(options) {
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, ComputerSchema);
+}
+async function createComputer(options) {
+  const path3 = "/api/v0/computers";
+  const reqBody = {
+    name: options.name,
+    remoteUser: options.remoteUser
+  };
+  if (options.provider != null) reqBody["provider"] = options.provider;
+  if (options.hostId != null) reqBody["hostId"] = options.hostId;
+  if (options.repos != null) reqBody["repos"] = options.repos;
+  if (options.autoInstallDeps != null)
+    reqBody["autoInstallDeps"] = options.autoInstallDeps;
+  if (options.serviceAccountId != null)
+    reqBody["serviceAccountId"] = options.serviceAccountId;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl, {
+    method: "POST",
+    body: reqBody
+  });
+  return parseResponse(body, ComputerSchema);
+}
+async function getComputerByName(options) {
+  const path3 = `/api/v0/computers/name/${encodeURIComponent(options.name)}`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, ComputerSchema);
+}
+async function updateComputer(options) {
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}`;
+  const reqBody = {};
+  if (options.name != null) reqBody["name"] = options.name;
+  if (options.remoteUser != null) reqBody["remoteUser"] = options.remoteUser;
+  if (options.hostId != null) reqBody["hostId"] = options.hostId;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl, {
+    method: "PATCH",
+    body: reqBody
+  });
+  return parseResponse(body, ComputerSchema);
+}
+async function deleteComputer(options) {
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}`;
+  await factoryFetch(path3, options.apiKey, options.baseUrl, {
+    method: "DELETE"
+  });
+}
+async function restartComputer(options) {
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}/restart`;
+  await factoryFetch(path3, options.apiKey, options.baseUrl, {
+    method: "POST"
+  });
+}
+async function refreshComputer(options) {
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}/refresh`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl, {
+    method: "POST"
+  });
+  return parseResponse(body, RefreshComputerResponseSchema);
+}
+async function getComputerMetrics(options) {
+  const params = new URLSearchParams();
+  if (options.start != null) {
+    params.set("start", options.start);
+  }
+  const query = params.toString();
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}/metrics${query ? `?${query}` : ""}`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, ComputerMetricsResponseSchema);
+}
+async function retryInstallDeps(options) {
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}/install-deps`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl, {
+    method: "POST"
+  });
+  return parseResponse(body, ComputerSchema);
+}
+async function listRemoteSessions(options) {
+  const params = new URLSearchParams();
+  if (options.computerId != null) {
+    params.set("computerId", options.computerId);
+  }
+  if (options.limit != null) {
+    params.set("limit", String(options.limit));
+  }
+  if (options.cursor != null) {
+    params.set("cursor", options.cursor);
+  }
+  const query = params.toString();
+  const path3 = `/api/v0/sessions${query ? `?${query}` : ""}`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, RemoteSessionListResponseSchema);
+}
+
+// src/daemon/client.ts
+var DAEMON_SERVER_REQUEST_METHODS = {
+  "daemon.request_permission": "permission" /* Permission */,
+  "daemon.ask_user": "askUser" /* AskUser */
+};
+var DaemonClient = class {
+  _engine;
+  _apiKey;
+  _sessionId = null;
+  _closed = false;
+  _notificationListeners = [];
+  _permissionHandler = null;
+  _askUserHandler = null;
+  constructor(options) {
+    this._apiKey = options.apiKey;
+    this._engine = new ProtocolEngine({
+      transport: options.transport,
+      serverRequestMethodMap: DAEMON_SERVER_REQUEST_METHODS
+    });
+    this._engine.onNotification((notification) => {
+      const normalized = notification["method"] === "daemon.session_notification" ? { ...notification, method: "droid.session_notification" } : notification;
+      dispatchNotification(normalized, [...this._notificationListeners]);
+    });
+    this._engine.setPermissionHandler(
+      (params) => this._dispatchPermissionRequest(params)
+    );
+    this._engine.setAskUserHandler(
+      (params) => this._dispatchAskUserRequest(params)
+    );
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  get isConnected() {
+    return !this._closed && this._engine.isHealthy;
+  }
+  async initializeSession(params) {
+    this._ensureNotClosed();
+    const result = await this._rpc(
+      "daemon.initialize_session" /* INITIALIZE_SESSION */,
+      { ...params, token: this._apiKey },
+      InitializeSessionResultSchema,
+      SESSION_INIT_TIMEOUT
+    );
+    this._sessionId = result.sessionId;
+    return result;
+  }
+  async loadSession(params) {
+    this._ensureNotClosed();
+    const result = await this._rpc(
+      "daemon.load_session" /* LOAD_SESSION */,
+      { ...params, token: this._apiKey },
+      LoadSessionResultSchema,
+      SESSION_INIT_TIMEOUT
+    );
+    this._sessionId = params.sessionId;
+    return result;
+  }
+  async addUserMessage(params) {
+    return this._sessionRpc(
+      "daemon.add_user_message" /* ADD_USER_MESSAGE */,
+      params,
+      AddUserMessageResultSchema
+    );
+  }
+  async interruptSession() {
+    return this._sessionRpc(
+      "daemon.interrupt_session" /* INTERRUPT_SESSION */,
+      {},
+      InterruptSessionResultSchema
+    );
+  }
+  async closeSession(params = {}) {
+    return this._sessionRpc(
+      "daemon.close_session" /* CLOSE_SESSION */,
+      params,
+      CloseSessionResultSchema
+    );
+  }
+  async updateSessionSettings(params) {
+    return this._sessionRpc(
+      "daemon.update_session_settings" /* UPDATE_SESSION_SETTINGS */,
+      params,
+      UpdateSessionSettingsResultSchema
+    );
+  }
+  async compactSession(params = {}) {
+    return this._sessionRpc(
+      "daemon.compact_session" /* COMPACT_SESSION */,
+      params,
+      CompactSessionResultSchema,
+      COMPACTION_TIMEOUT
+    );
+  }
+  async forkSession() {
+    return this._sessionRpc(
+      "daemon.fork_session" /* FORK_SESSION */,
+      {},
+      ForkSessionResultSchema
+    );
+  }
+  async getContextBreakdown() {
+    return this._sessionRpc(
+      "daemon.get_context_breakdown" /* GET_CONTEXT_STATS */,
+      {},
+      ContextBreakdownResultSchema
+    );
+  }
+  async renameSession(params) {
+    return this._sessionRpc(
+      "daemon.rename_session" /* RENAME_SESSION */,
+      params,
+      RenameSessionResultSchema
+    );
+  }
+  async getRewindInfo(params) {
+    return this._sessionRpc(
+      "daemon.get_rewind_info" /* GET_REWIND_INFO */,
+      params,
+      GetRewindInfoResultSchema,
+      REWIND_TIMEOUT
+    );
+  }
+  async executeRewind(params) {
+    return this._sessionRpc(
+      "daemon.execute_rewind" /* EXECUTE_REWIND */,
+      params,
+      ExecuteRewindResultSchema,
+      REWIND_TIMEOUT
+    );
+  }
+  async addMcpServer(params) {
+    return this._sessionRpc(
+      "daemon.add_mcp_server" /* ADD_MCP_SERVER */,
+      params,
+      AddMcpServerResultSchema
+    );
+  }
+  async removeMcpServer(params) {
+    return this._sessionRpc(
+      "daemon.remove_mcp_server" /* REMOVE_MCP_SERVER */,
+      params,
+      RemoveMcpServerResultSchema
+    );
+  }
+  async toggleMcpServer(params) {
+    return this._sessionRpc(
+      "daemon.toggle_mcp_server" /* TOGGLE_MCP_SERVER */,
+      params,
+      ToggleMcpServerResultSchema
+    );
+  }
+  async listMcpServers() {
+    return this._sessionRpc(
+      "daemon.list_mcp_servers" /* LIST_MCP_SERVERS */,
+      {},
+      ListMcpServersResultSchema
+    );
+  }
+  async listMcpTools() {
+    return this._sessionRpc(
+      "daemon.list_mcp_tools" /* LIST_MCP_TOOLS */,
+      {},
+      ListMcpToolsResultSchema
+    );
+  }
+  async authenticateMcpServer(params) {
+    return this._sessionRpc(
+      "daemon.authenticate_mcp_server" /* AUTHENTICATE_MCP_SERVER */,
+      params,
+      AuthenticateMcpServerResultSchema
+    );
+  }
+  async listSkills() {
+    return this._sessionRpc(
+      "daemon.list_skills" /* LIST_SKILLS */,
+      {},
+      ListSkillsResultSchema
+    );
+  }
+  onNotification(callback, filter) {
+    const entry = { callback, filter };
+    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);
+        }
+      }
+    };
+  }
+  setPermissionHandler(handler) {
+    this._permissionHandler = handler;
+  }
+  setAskUserHandler(handler) {
+    this._askUserHandler = handler;
+  }
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    this._notificationListeners.length = 0;
+    this._permissionHandler = null;
+    this._askUserHandler = null;
+    await this._engine.close();
+  }
+  async _rpc(method, params, schema, timeout) {
+    const raw = await this._engine.sendRequest(method, params, timeout);
+    return schema.parse(raw);
+  }
+  async _sessionRpc(method, params, schema, timeout) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    return this._rpc(
+      method,
+      { sessionId: this._sessionId, ...params },
+      schema,
+      timeout
+    );
+  }
+  _dispatchPermissionRequest(params) {
+    const handler = this._permissionHandler;
+    if (handler == null) {
+      return "cancel" /* Cancel */;
+    }
+    return handler(params);
+  }
+  _dispatchAskUserRequest(params) {
+    const handler = this._askUserHandler;
+    if (handler == null) {
+      return { cancelled: true, answers: [] };
+    }
+    return handler(params);
+  }
+  _ensureNotClosed() {
+    if (this._closed) {
+      throw new ConnectionError(
+        "Daemon client has been closed. Create a new DaemonClient instance."
+      );
+    }
+  }
+  _ensureSession() {
+    if (this._sessionId == null) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+  }
+};
+
+// src/daemon/local.ts
+var import_node_child_process2 = require("child_process");
+var fs2 = __toESM(require("fs"), 1);
+var net = __toESM(require("net"), 1);
+var os2 = __toESM(require("os"), 1);
+var path2 = __toESM(require("path"), 1);
+var SOCKET_TIMEOUT_MS = 2e3;
+var STARTUP_POLL_INTERVAL_MS = 250;
+var STARTUP_TIMEOUT_MS = 3e4;
+var MAX_STARTUP_ATTEMPTS = 3;
+var FACTORY_DIR = ".factory";
+var DEFAULT_PORT = 37643;
+var DAEMON_PORT_FILE = "daemon.port";
+var DEFAULT_HOST = "127.0.0.1";
+var spawnedDaemonProcess = null;
+var daemonTarget = null;
+var daemonEnsureInflight = null;
+function getFactoryHome() {
+  return process.env.FACTORY_HOME_OVERRIDE || os2.homedir();
+}
+function getFactoryDirName() {
+  return FACTORY_DIR;
+}
+function getFactoryDir() {
+  return path2.join(getFactoryHome(), getFactoryDirName());
+}
+function getSdkDir() {
+  return path2.join(getFactoryDir(), "sdk");
+}
+function getDefaultDaemonPort() {
+  return DEFAULT_PORT;
+}
+function resolveExecPath() {
+  const override = process.env.FACTORY_DROID_BINARY?.trim();
+  if (override && override.length > 0) {
+    if (override.includes("/") || override.includes("\\")) {
+      try {
+        fs2.accessSync(override, fs2.constants.X_OK);
+        return override;
+      } catch {
+      }
+    } else {
+      return override;
+    }
+  }
+  return "droid";
+}
+async function allocatePort() {
+  return new Promise((resolve2, reject) => {
+    const server = net.createServer();
+    server.once("error", reject);
+    server.listen(0, DEFAULT_HOST, () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close();
+        reject(new Error("Failed to determine dynamic port"));
+        return;
+      }
+      const port = address.port;
+      server.close((err) => {
+        if (err) reject(err);
+        else resolve2(port);
+      });
+    });
+  });
+}
+async function isDaemonReachable(port) {
+  return new Promise((resolve2) => {
+    const socket = net.createConnection({ host: DEFAULT_HOST, port });
+    const cleanup = () => {
+      socket.removeAllListeners();
+      socket.destroy();
+    };
+    const fail = () => {
+      cleanup();
+      resolve2(false);
+    };
+    socket.setTimeout(SOCKET_TIMEOUT_MS, fail);
+    socket.once("error", fail);
+    socket.once("connect", () => {
+      cleanup();
+      resolve2(true);
+    });
+  });
+}
+async function waitForDaemonReady(child, port, timeoutMs = STARTUP_TIMEOUT_MS) {
+  return new Promise((resolve2) => {
+    let settled = false;
+    let exited = false;
+    const deadline = Date.now() + timeoutMs;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      child.removeListener("exit", onExit);
+      child.removeListener("error", onExit);
+      resolve2(result);
+    };
+    const onExit = () => {
+      exited = true;
+      settle("exited");
+    };
+    child.once("exit", onExit);
+    child.once("error", onExit);
+    const poll = async () => {
+      while (!exited && !settled) {
+        if (await isDaemonReachable(port)) {
+          settle("ready");
+          return;
+        }
+        if (Date.now() >= deadline) {
+          settle("timeout");
+          return;
+        }
+        await new Promise((r) => setTimeout(r, STARTUP_POLL_INTERVAL_MS));
+      }
+    };
+    void poll();
+  });
+}
+function readPortFile() {
+  try {
+    const portPath = path2.join(getSdkDir(), DAEMON_PORT_FILE);
+    const content = fs2.readFileSync(portPath, "utf-8").trim();
+    const port = parseInt(content, 10);
+    if (Number.isFinite(port) && port > 0 && port < 65536) {
+      return port;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writePortFile(port) {
+  try {
+    const sdkDir = getSdkDir();
+    fs2.mkdirSync(sdkDir, { recursive: true });
+    fs2.writeFileSync(path2.join(sdkDir, DAEMON_PORT_FILE), String(port), {
+      mode: 384
+    });
+  } catch {
+  }
+}
+function cacheTarget(port) {
+  daemonTarget = { host: DEFAULT_HOST, port };
+  return { port };
+}
+function clearSpawnedDaemonProcess(child) {
+  if (spawnedDaemonProcess === child) {
+    spawnedDaemonProcess = null;
+  }
+}
+async function spawnDaemon(execPath, port) {
+  const args = ["daemon", "--host", DEFAULT_HOST, "--port", String(port)];
+  let stderrFd;
+  try {
+    const logsDir = path2.join(getSdkDir(), "logs");
+    fs2.mkdirSync(logsDir, { recursive: true });
+    stderrFd = fs2.openSync(path2.join(logsDir, "daemon-stderr.log"), "a");
+  } catch {
+  }
+  const child = (0, import_node_child_process2.spawn)(execPath, args, {
+    detached: true,
+    stdio: ["ignore", "ignore", stderrFd ?? "ignore"],
+    cwd: os2.homedir(),
+    env: { ...process.env }
+  });
+  if (stderrFd !== void 0) {
+    try {
+      fs2.closeSync(stderrFd);
+    } catch {
+    }
+  }
+  spawnedDaemonProcess = child;
+  child.unref();
+  child.once("exit", () => {
+    clearSpawnedDaemonProcess(child);
+  });
+  child.on("error", () => {
+    clearSpawnedDaemonProcess(child);
+  });
+  const result = await waitForDaemonReady(child, port);
+  if (result !== "ready") {
+    clearSpawnedDaemonProcess(child);
+    if (result === "timeout") {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+async function _ensureLocalDaemon() {
+  const execPath = resolveExecPath();
+  const wellKnownPort = getDefaultDaemonPort();
+  if (await isDaemonReachable(wellKnownPort)) {
+    return cacheTarget(wellKnownPort);
+  }
+  const portFilePort = readPortFile();
+  if (portFilePort !== null && portFilePort !== wellKnownPort) {
+    if (await isDaemonReachable(portFilePort)) {
+      return cacheTarget(portFilePort);
+    }
+  }
+  const firstResult = await spawnDaemon(execPath, wellKnownPort);
+  if (firstResult === "ready") {
+    writePortFile(wellKnownPort);
+    return cacheTarget(wellKnownPort);
+  }
+  for (let attempt = 2; attempt <= MAX_STARTUP_ATTEMPTS; attempt++) {
+    const port = await allocatePort();
+    const result = await spawnDaemon(execPath, port);
+    if (result === "ready") {
+      writePortFile(port);
+      return cacheTarget(port);
+    }
+  }
+  throw new ConnectionError(
+    `Failed to start local droid daemon after ${MAX_STARTUP_ATTEMPTS} attempts. Ensure the \`droid\` CLI is installed and \`droid auth login\` has been run.`
+  );
+}
+async function ensureLocalDaemon() {
+  if (daemonTarget) {
+    if (await isDaemonReachable(daemonTarget.port)) {
+      return { port: daemonTarget.port };
+    }
+    daemonTarget = null;
+  }
+  if (!daemonEnsureInflight) {
+    daemonEnsureInflight = _ensureLocalDaemon().finally(() => {
+      daemonEnsureInflight = null;
+    });
+  }
+  return daemonEnsureInflight;
+}
+
+// src/daemon/session.ts
+var DaemonSession = class {
+  _client;
+  _sessionId;
+  _closed = false;
+  _activeBridges = /* @__PURE__ */ new Set();
+  _cleanupCallbacks = [];
+  /** @internal */
+  constructor(client, sessionId) {
+    this._client = client;
+    this._sessionId = sessionId;
+  }
+  /** @internal */
+  addCleanup(cleanup) {
+    this._cleanupCallbacks.push(cleanup);
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  async *stream(prompt, options) {
+    this._ensureNotClosed();
+    yield* streamFromClient(
+      this._client,
+      this._sessionId,
+      this._activeBridges,
+      prompt,
+      options
+    );
+  }
+  async send(prompt, options) {
+    this._ensureNotClosed();
+    await this._client.addUserMessage({
+      text: prompt,
+      images: options?.images,
+      files: options?.files,
+      outputFormat: options?.outputFormat
+    });
+  }
+  async interrupt() {
+    this._ensureNotClosed();
+    await this._client.interruptSession();
+  }
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    for (const bridge of this._activeBridges) {
+      bridge.signalDone();
+    }
+    try {
+      await this._client.closeSession({ reason: "other" }).catch(() => {
+      });
+    } finally {
+      await this._client.close();
+      for (const cleanup of this._cleanupCallbacks) {
+        try {
+          await cleanup();
+        } catch {
+        }
+      }
+      this._cleanupCallbacks.length = 0;
+    }
+  }
+  async updateSettings(params) {
+    this._ensureNotClosed();
+    return this._client.updateSessionSettings(params);
+  }
+  async enterSpecMode(params = {}) {
+    this._ensureNotClosed();
+    return this._client.updateSessionSettings({
+      interactionMode: "spec" /* Spec */,
+      ...params
+    });
+  }
+  async compactSession(params) {
+    this._ensureNotClosed();
+    return this._client.compactSession(params ?? {});
+  }
+  async forkSession() {
+    this._ensureNotClosed();
+    return this._client.forkSession();
+  }
+  async getContextBreakdown() {
+    this._ensureNotClosed();
+    return this._client.getContextBreakdown();
+  }
+  async renameSession(params) {
+    this._ensureNotClosed();
+    return this._client.renameSession(params);
+  }
+  async getRewindInfo(params) {
+    this._ensureNotClosed();
+    return this._client.getRewindInfo(params);
+  }
+  async executeRewind(params) {
+    this._ensureNotClosed();
+    return this._client.executeRewind(params);
+  }
+  async addMcpServer(params) {
+    this._ensureNotClosed();
+    return this._client.addMcpServer(params);
+  }
+  async removeMcpServer(params) {
+    this._ensureNotClosed();
+    return this._client.removeMcpServer(params);
+  }
+  async toggleMcpServer(params) {
+    this._ensureNotClosed();
+    return this._client.toggleMcpServer(params);
+  }
+  async listMcpServers() {
+    this._ensureNotClosed();
+    return this._client.listMcpServers();
+  }
+  async listMcpTools() {
+    this._ensureNotClosed();
+    return this._client.listMcpTools();
+  }
+  async authenticateMcpServer(params) {
+    this._ensureNotClosed();
+    return this._client.authenticateMcpServer(params);
+  }
+  async listSkills() {
+    this._ensureNotClosed();
+    return this._client.listSkills();
+  }
+  onNotification(callback, filter) {
+    return this._client.onNotification(callback, filter);
+  }
+  _ensureNotClosed() {
+    if (this._closed) {
+      throw new ConnectionError(
+        "Daemon session has been closed. Create a new session to continue."
+      );
+    }
+  }
+};
+
+// src/daemon/transport.ts
+var import_ws = __toESM(require("ws"), 1);
+
+// src/daemon/types.ts
+var MachineType = /* @__PURE__ */ ((MachineType2) => {
+  MachineType2["Local"] = "local";
+  MachineType2["Computer"] = "computer";
+  return MachineType2;
+})(MachineType || {});
+var DEFAULT_DAEMON_PORT = 37643;
+var DEFAULT_RELAY_BASE_URL = "wss://relay.factory.ai";
+var DEFAULT_WS_CONFIG = {
+  maxConnectRetries: 5,
+  initialRetryDelayMs: 500,
+  maxRetryDelayMs: 5e3,
+  connectionTimeoutMs: 5e3
+};
+var COMPUTER_WS_CONFIG = {
+  connectionTimeoutMs: 45e3,
+  maxConnectRetries: 10,
+  initialRetryDelayMs: 2e3,
+  maxRetryDelayMs: 1e4
+};
+
+// src/daemon/transport.ts
+var WebSocketTransport = class {
+  maxConnectRetries;
+  initialRetryDelayMs;
+  maxRetryDelayMs;
+  connectionTimeoutMs;
+  ws = null;
+  messageHandler = null;
+  errorHandler = null;
+  _isConnected = false;
+  isClosing = false;
+  constructor(options = {}) {
+    this.maxConnectRetries = options.maxConnectRetries ?? DEFAULT_WS_CONFIG.maxConnectRetries;
+    this.initialRetryDelayMs = options.initialRetryDelayMs ?? DEFAULT_WS_CONFIG.initialRetryDelayMs;
+    this.maxRetryDelayMs = options.maxRetryDelayMs ?? DEFAULT_WS_CONFIG.maxRetryDelayMs;
+    this.connectionTimeoutMs = options.connectionTimeoutMs ?? DEFAULT_WS_CONFIG.connectionTimeoutMs;
+  }
+  get isConnected() {
+    return this._isConnected;
+  }
+  async connect(url) {
+    if (!url) {
+      throw new ConnectionError("WebSocket URL is required");
+    }
+    if (this._isConnected) {
+      throw new ConnectionError("Transport already connected");
+    }
+    this.isClosing = false;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxConnectRetries; attempt++) {
+      try {
+        await this._doConnect(url);
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < this.maxConnectRetries) {
+          const delay = Math.min(
+            this.initialRetryDelayMs * 2 ** attempt,
+            this.maxRetryDelayMs
+          );
+          await new Promise((resolve2) => setTimeout(resolve2, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
+  send(message) {
+    if (!this._isConnected || !this.ws) {
+      throw new ConnectionError("WebSocket transport not connected");
+    }
+    try {
+      this.ws.send(JSON.stringify(message));
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      throw new ConnectionError(`Failed to send WebSocket message: ${msg}`);
+    }
+  }
+  onMessage(callback) {
+    this.messageHandler = callback;
+  }
+  onError(callback) {
+    this.errorHandler = callback;
+  }
+  async close() {
+    if (this.isClosing) {
+      return;
+    }
+    this.isClosing = true;
+    this._isConnected = false;
+    const ws = this.ws;
+    this.ws = null;
+    if (ws && ws.readyState === import_ws.default.OPEN) {
+      await new Promise((resolve2) => {
+        ws.once("close", () => resolve2());
+        ws.close(1e3, "Client disconnect");
+        setTimeout(() => resolve2(), 5e3);
+      });
+    }
+    this.isClosing = false;
+  }
+  async _doConnect(url) {
+    return new Promise((resolve2, reject) => {
+      let settled = false;
+      let timeoutId = null;
+      const cleanup = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+      };
+      const ws = new import_ws.default(url);
+      const handleOpen = () => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        this.ws = ws;
+        this._isConnected = true;
+        this._setupOngoingHandlers(ws);
+        resolve2();
+      };
+      const handleError = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        try {
+          ws.close();
+        } catch {
+        }
+        reject(
+          new ConnectionError(`WebSocket connection failed: ${error.message}`)
+        );
+      };
+      const handleClose = (code, reason) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(
+          new ConnectionError(
+            `WebSocket closed before opening (code: ${code}, reason: ${reason.toString()})`
+          )
+        );
+      };
+      ws.once("open", handleOpen);
+      ws.once("error", handleError);
+      ws.once("close", handleClose);
+      timeoutId = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        try {
+          ws.close();
+        } catch {
+        }
+        reject(
+          new ConnectionError(
+            `WebSocket connection timeout after ${this.connectionTimeoutMs}ms: ${url}`
+          )
+        );
+      }, this.connectionTimeoutMs);
+    });
+  }
+  _setupOngoingHandlers(ws) {
+    ws.on("message", (data) => {
+      if (!this.messageHandler) return;
+      const text = typeof data === "string" ? data : data.toString();
+      try {
+        const parsed = JSON.parse(text);
+        if (isRecord(parsed)) {
+          this.messageHandler(parsed);
+        }
+      } catch {
+      }
+    });
+    ws.on("error", (error) => {
+      if (!this.isClosing && this.errorHandler) {
+        this.errorHandler(
+          new ConnectionError(`WebSocket error: ${error.message}`)
+        );
+      }
+    });
+    ws.on("close", (code, reason) => {
+      this._isConnected = false;
+      this.ws = null;
+      if (!this.isClosing && this.errorHandler) {
+        this.errorHandler(
+          new ConnectionError(
+            `WebSocket closed (code: ${code}, reason: ${reason.toString()})`
+          )
+        );
+      }
+    });
+  }
+};
+
+// src/daemon/connection.ts
+var DAEMON_AUTHENTICATE_METHOD = "daemon.authenticate";
+var DAEMON_AUTHENTICATE_TIMEOUT = 3e4;
+var SDK_CALLER = "droid-sdk";
+function resolveWebSocketUrl(options) {
+  if (options.url) {
+    return options.url;
+  }
+  const machine = options.machine;
+  if (!machine || machine.type === "local" /* Local */) {
+    const port = options._localPort ?? options.daemonPort ?? DEFAULT_DAEMON_PORT;
+    return `ws://127.0.0.1:${port}`;
+  }
+  if (machine.type === "computer" /* Computer */) {
+    const relayBase = options.relayBaseUrl ?? DEFAULT_RELAY_BASE_URL;
+    return `${relayBase}/v0/computer/${machine.computerId}/client`;
+  }
+  const _exhaustive = machine;
+  throw new ConnectionError(`Unsupported machine type: ${String(_exhaustive)}`);
+}
+function getWebSocketConfig(machine) {
+  if (machine?.type === "computer" /* Computer */) {
+    return { ...DEFAULT_WS_CONFIG, ...COMPUTER_WS_CONFIG };
+  }
+  if (!machine || machine.type === "local" /* Local */) {
+    return { ...DEFAULT_WS_CONFIG, connectionTimeoutMs: 1e4 };
+  }
+  return { ...DEFAULT_WS_CONFIG };
+}
+var SharedTransportMultiplexer = class {
+  constructor(_inner) {
+    this._inner = _inner;
+    this._inner.onMessage((message) => {
+      this._routeMessage(message);
+    });
+    this._inner.onError((error) => {
+      for (const view of this._views) {
+        if (view.errorCallback) {
+          try {
+            view.errorCallback(error);
+          } catch {
+          }
+        }
+      }
+    });
+  }
+  _views = /* @__PURE__ */ new Set();
+  createView() {
+    const inner = this._inner;
+    const viewState = {
+      messageCallback: null,
+      errorCallback: null,
+      pendingRequestIds: /* @__PURE__ */ new Set(),
+      sessionId: null
+    };
+    this._views.add(viewState);
+    const view = {
+      send: (message) => {
+        if (message["type"] === "request" && typeof message["id"] === "string") {
+          viewState.pendingRequestIds.add(message["id"]);
+        }
+        inner.send(message);
+      },
+      onMessage: (callback) => {
+        viewState.messageCallback = callback;
+      },
+      onError: (callback) => {
+        viewState.errorCallback = callback;
+      },
+      close: async () => {
+        viewState.messageCallback = null;
+        viewState.errorCallback = null;
+        viewState.pendingRequestIds.clear();
+        this._views.delete(viewState);
+      },
+      get isConnected() {
+        return inner.isConnected;
+      }
+    };
+    return view;
+  }
+  _routeMessage(message) {
+    const messageType = message["type"];
+    const messageId = message["id"];
+    if (messageType === "response" && typeof messageId === "string") {
+      for (const view of this._views) {
+        if (view.pendingRequestIds.has(messageId)) {
+          view.pendingRequestIds.delete(messageId);
+          const result = message["result"];
+          if (isRecord(result) && typeof result["sessionId"] === "string") {
+            view.sessionId = result["sessionId"];
+          }
+          if (view.messageCallback) {
+            try {
+              view.messageCallback(message);
+            } catch {
+            }
+          }
+          return;
+        }
+      }
+      return;
+    }
+    if (messageType === "notification") {
+      const params = message["params"];
+      const sessionId = isRecord(params) && typeof params["sessionId"] === "string" ? params["sessionId"] : null;
+      if (sessionId) {
+        for (const view of this._views) {
+          if (view.sessionId === sessionId && view.messageCallback) {
+            try {
+              view.messageCallback(message);
+            } catch {
+            }
+            return;
+          }
+        }
+      }
+      for (const view of this._views) {
+        if (view.messageCallback) {
+          try {
+            view.messageCallback(message);
+          } catch {
+          }
+        }
+      }
+      return;
+    }
+    if (messageType === "request") {
+      const params = message["params"];
+      const sessionId = isRecord(params) && typeof params["sessionId"] === "string" ? params["sessionId"] : null;
+      if (sessionId) {
+        for (const view of this._views) {
+          if (view.sessionId === sessionId && view.messageCallback) {
+            try {
+              view.messageCallback(message);
+            } catch {
+            }
+            return;
+          }
+        }
+      }
+      for (const view of this._views) {
+        if (view.messageCallback) {
+          try {
+            view.messageCallback(message);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+};
+async function authenticate(transport, options) {
+  const requestId = crypto.randomUUID();
+  const envelope = {
+    jsonrpc: JSONRPC_VERSION,
+    factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+    factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+    type: "request" /* Request */,
+    id: requestId,
+    method: DAEMON_AUTHENTICATE_METHOD,
+    params: {
+      apiKey: options.apiKey,
+      caller: SDK_CALLER
+    }
+  };
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      transport.onMessage(() => {
+      });
+      reject(
+        new ConnectionError(
+          `Daemon authentication timed out after ${DAEMON_AUTHENTICATE_TIMEOUT}ms`
+        )
+      );
+    }, DAEMON_AUTHENTICATE_TIMEOUT);
+    transport.onMessage((message) => {
+      if (message["id"] !== requestId) {
+        return;
+      }
+      clearTimeout(timer);
+      transport.onMessage(() => {
+      });
+      if (message["error"]) {
+        const error = message["error"];
+        const errorMessage = error && typeof error === "object" && "message" in error ? String(error.message) : "unknown error";
+        reject(
+          new ConnectionError(`Daemon authentication failed: ${errorMessage}`)
+        );
+        return;
+      }
+      resolve2();
+    });
+    transport.send(envelope);
+  });
+}
+var DaemonConnection = class {
+  _transport;
+  _multiplexer;
+  _apiKey;
+  _closed = false;
+  /** @internal */
+  constructor(transport, apiKey) {
+    this._transport = transport;
+    this._multiplexer = new SharedTransportMultiplexer(transport);
+    this._apiKey = apiKey;
+  }
+  async createSession(options = {}) {
+    this._ensureNotClosed();
+    const view = this._multiplexer.createView();
+    const client = new DaemonClient({
+      transport: view,
+      apiKey: this._apiKey
+    });
+    if (options.permissionHandler) {
+      client.setPermissionHandler(options.permissionHandler);
+    }
+    if (options.askUserHandler) {
+      client.setAskUserHandler(options.askUserHandler);
+    }
+    let sdkMcpServers;
+    try {
+      sdkMcpServers = await startSdkMcpServers(options.mcpServers);
+      const initParams = buildInitParams({
+        ...options,
+        mcpServers: sdkMcpServers.mcpServers
+      });
+      const initResult = await client.initializeSession(initParams);
+      const session = new DaemonSession(client, initResult.sessionId);
+      if (sdkMcpServers) {
+        session.addCleanup(sdkMcpServers.cleanup);
+      }
+      return session;
+    } catch (error) {
+      await sdkMcpServers?.cleanup();
+      await client.close();
+      throw error;
+    }
+  }
+  async resumeSession(sessionId, options = {}) {
+    this._ensureNotClosed();
+    const view = this._multiplexer.createView();
+    const client = new DaemonClient({
+      transport: view,
+      apiKey: this._apiKey
+    });
+    if (options.permissionHandler) {
+      client.setPermissionHandler(options.permissionHandler);
+    }
+    if (options.askUserHandler) {
+      client.setAskUserHandler(options.askUserHandler);
+    }
+    let sdkMcpServers;
+    try {
+      sdkMcpServers = await startSdkMcpServers(options.mcpServers);
+      await client.loadSession({
+        sessionId,
+        mcpServers: sdkMcpServers.mcpServers
+      });
+      const session = new DaemonSession(client, sessionId);
+      if (sdkMcpServers) {
+        session.addCleanup(sdkMcpServers.cleanup);
+      }
+      return session;
+    } catch (error) {
+      await sdkMcpServers?.cleanup();
+      await client.close();
+      throw error;
+    }
+  }
+  async interruptSession(sessionId) {
+    this._ensureNotClosed();
+    const view = this._multiplexer.createView();
+    const client = new DaemonClient({
+      transport: view,
+      apiKey: this._apiKey
+    });
+    try {
+      await client.loadSession({ sessionId });
+      await client.interruptSession();
+    } finally {
+      await client.close();
+    }
+  }
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    await this._transport.close();
+  }
+  _ensureNotClosed() {
+    if (this._closed) {
+      throw new ConnectionError(
+        "Daemon connection has been closed. Call connectDaemon() to create a new connection."
+      );
+    }
+  }
+};
+async function connectDaemon(options) {
+  const isLocal = !options.url && (!options.machine || options.machine.type === "local" /* Local */);
+  let resolvedOptions = options;
+  if (isLocal) {
+    const { port } = await ensureLocalDaemon();
+    resolvedOptions = { ...options, _localPort: port };
+  }
+  const url = resolveWebSocketUrl(resolvedOptions);
+  const wsConfig = getWebSocketConfig(resolvedOptions.machine);
+  const transport = new WebSocketTransport(wsConfig);
+  const apiKey = resolvedOptions.apiKey;
+  const maxRetries = resolvedOptions.maxRetries ?? 0;
+  try {
+    if (maxRetries > 0) {
+      let lastError;
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+          await transport.connect(url);
+          await authenticate(transport, resolvedOptions);
+          return new DaemonConnection(transport, apiKey);
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          try {
+            await transport.close();
+          } catch {
+          }
+          if (attempt < maxRetries) {
+            await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+          }
+        }
+      }
+      throw lastError;
+    }
+    await transport.connect(url);
+    await authenticate(transport, resolvedOptions);
+    return new DaemonConnection(transport, apiKey);
+  } catch (error) {
+    try {
+      await transport.close();
+    } catch {
+    }
+    throw error;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AddMcpServerRequestParamsSchema,
@@ -4111,6 +5712,7 @@ async function listSessions(options = {}) {
   AskUserRequestSchema,
   AskUserResponseSchema,
   AskUserResultSchema,
+  AssistantTextCompleteNotificationSchema,
   AssistantTextDeltaNotificationSchema,
   AuthenticateMcpServerRequestParamsSchema,
   AuthenticateMcpServerRequestSchema,
@@ -4135,17 +5737,30 @@ async function listSessions(options = {}) {
   ClearMcpAuthResultSchema,
   CliRequestOrNotificationSchema,
   ClientRequestSchema,
+  CloseSessionRequestParamsSchema,
+  CloseSessionRequestSchema,
+  CloseSessionResponseSchema,
+  CloseSessionResultSchema,
   CompactSessionRequestParamsSchema,
   CompactSessionRequestSchema,
   CompactSessionResponseSchema,
   CompactSessionResultSchema,
+  ComputerListResponseSchema,
+  ComputerMetricSchema,
+  ComputerMetricsResponseSchema,
+  ComputerSchema,
   ConnectionError,
   ContentBlockSchema,
+  ContextBreakdownCategorySchema,
+  ContextBreakdownResultSchema,
   ContextStatsAccuracy,
   ContextStatsSchema,
   CreateMessageNotificationSchema,
   CreateToolConfirmationDetailsSchema,
   DEFAULT_REQUEST_TIMEOUT,
+  DaemonClient,
+  DaemonConnection,
+  DaemonSession,
   DecompSessionType,
   DiscoveredIssueSchema,
   DismissalRecordSchema,
@@ -4155,6 +5770,10 @@ async function listSessions(options = {}) {
   DroidClient,
   DroidClientMethod,
   DroidErrorType,
+  DroidHookEventSchema,
+  DroidHookExecutionResultSchema,
+  DroidHookOutputSchema,
+  DroidHookSpecificOutputSchema,
   DroidInteractionMode,
   DroidMessageType,
   DroidServerMethod,
@@ -4195,6 +5814,10 @@ async function listSessions(options = {}) {
   GitRepoInfoSchema,
   HandoffItemsDismissedEntrySchema,
   HandoffSchema,
+  HookCommandSchema,
+  HookExecutionCompletedNotificationSchema,
+  HookExecutionStartedNotificationSchema,
+  HookResultSchema,
   HttpHeaderSchema,
   HttpMcpConfigSchema,
   ImageBlockSchema,
@@ -4252,6 +5875,10 @@ async function listSessions(options = {}) {
   LoadSessionResponseSchema,
   LoadSessionResultSchema,
   MCP_AUTH_TIMEOUT,
+  MachineTemplateBuildStatusSchema,
+  MachineTemplateListResponseSchema,
+  MachineTemplateSchema,
+  MachineType,
   McpAuthCompletedNotificationSchema,
   McpAuthOutcome,
   McpAuthRequiredNotificationSchema,
@@ -4297,6 +5924,9 @@ async function listSessions(options = {}) {
   REWIND_TIMEOUT,
   ReasoningEffort,
   RedactedThinkingBlockSchema,
+  RefreshComputerResponseSchema,
+  RemoteSessionListResponseSchema,
+  RemoteSessionSchema,
   RemoveMcpServerRequestParamsSchema,
   RemoveMcpServerRequestSchema,
   RemoveMcpServerResponseSchema,
@@ -4316,6 +5946,7 @@ async function listSessions(options = {}) {
   SDK_VERSION,
   SESSION_INIT_TIMEOUT,
   SdkMcpServer,
+  ServerRequestHandlerType,
   SessionError,
   SessionMetadataSchema,
   SessionNotFoundError,
@@ -4343,6 +5974,8 @@ async function listSessions(options = {}) {
   StartMissionRunConfirmationDetailsSchema,
   StdioMcpConfigSchema,
   StreamStateTracker,
+  StructuredOutputErrorSchema,
+  StructuredOutputNotificationSchema,
   SubmitBugReportRequestParamsSchema,
   SubmitBugReportRequestSchema,
   SubmitBugReportResponseSchema,
@@ -4357,6 +5990,7 @@ async function listSessions(options = {}) {
   TestsSchema,
   TextBlockSchema,
   ThinkingBlockSchema,
+  ThinkingTextCompleteNotificationSchema,
   ThinkingTextDeltaNotificationSchema,
   TimeoutError,
   ToggleMcpServerRequestParamsSchema,
@@ -4368,6 +6002,7 @@ async function listSessions(options = {}) {
   ToggleMcpToolResponseSchema,
   ToggleMcpToolResultSchema,
   TokenUsageSchema,
+  ToolCallNotificationSchema,
   ToolConfirmationDetailsSchema,
   ToolConfirmationInfoSchema,
   ToolConfirmationListItemSchema,
@@ -4387,19 +6022,37 @@ async function listSessions(options = {}) {
   UpdateSessionSettingsResultSchema,
   VerificationCommandSchema,
   VerificationSchema,
+  WebSocketTransport,
   WorkerCompletedEntrySchema,
   WorkerFailedEntrySchema,
   WorkerPausedEntrySchema,
   WorkerSelectedFeatureEntrySchema,
   WorkerStartedEntrySchema,
   WorkerStateInfoSchema,
+  connectDaemon,
   convertNotificationToStreamMessage,
+  createComputer,
+  createResponseSchema,
   createSdkMcpServer,
   createSession,
+  deleteComputer,
+  dispatchNotification,
+  ensureLocalDaemon,
+  getComputer,
+  getComputerByName,
+  getComputerMetrics,
+  getMachineTemplate,
+  listComputers,
+  listMachineTemplates,
+  listRemoteSessions,
   listSessions,
-  query,
+  refreshComputer,
+  resolveWebSocketUrl,
+  restartComputer,
   resumeSession,
+  retryInstallDeps,
   run,
-  tool
+  tool,
+  updateComputer
 });
 //# sourceMappingURL=index.cjs.map