@factory/droid-sdk 0.2.0 → 0.3.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,6 +71,10 @@ __export(index_exports, {
   ClearMcpAuthResultSchema: () => ClearMcpAuthResultSchema,
   CliRequestOrNotificationSchema: () => CliRequestOrNotificationSchema,
   ClientRequestSchema: () => ClientRequestSchema,
+  CloseSessionRequestParamsSchema: () => CloseSessionRequestParamsSchema,
+  CloseSessionRequestSchema: () => CloseSessionRequestSchema,
+  CloseSessionResponseSchema: () => CloseSessionResponseSchema,
+  CloseSessionResultSchema: () => CloseSessionResultSchema,
   CompactSessionRequestParamsSchema: () => CompactSessionRequestParamsSchema,
   CompactSessionRequestSchema: () => CompactSessionRequestSchema,
   CompactSessionResponseSchema: () => CompactSessionResponseSchema,
@@ -90,6 +95,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 +139,10 @@ __export(index_exports, {
   GitRepoInfoSchema: () => GitRepoInfoSchema,
   HandoffItemsDismissedEntrySchema: () => HandoffItemsDismissedEntrySchema,
   HandoffSchema: () => HandoffSchema,
+  HookCommandSchema: () => HookCommandSchema,
+  HookExecutionCompletedNotificationSchema: () => HookExecutionCompletedNotificationSchema,
+  HookExecutionStartedNotificationSchema: () => HookExecutionStartedNotificationSchema,
+  HookResultSchema: () => HookResultSchema,
   HttpHeaderSchema: () => HttpHeaderSchema,
   HttpMcpConfigSchema: () => HttpMcpConfigSchema,
   ImageBlockSchema: () => ImageBlockSchema,
@@ -278,6 +291,8 @@ __export(index_exports, {
   StartMissionRunConfirmationDetailsSchema: () => StartMissionRunConfirmationDetailsSchema,
   StdioMcpConfigSchema: () => StdioMcpConfigSchema,
   StreamStateTracker: () => StreamStateTracker,
+  StructuredOutputErrorSchema: () => StructuredOutputErrorSchema,
+  StructuredOutputNotificationSchema: () => StructuredOutputNotificationSchema,
   SubmitBugReportRequestParamsSchema: () => SubmitBugReportRequestParamsSchema,
   SubmitBugReportRequestSchema: () => SubmitBugReportRequestSchema,
   SubmitBugReportResponseSchema: () => SubmitBugReportResponseSchema,
@@ -292,6 +307,7 @@ __export(index_exports, {
   TestsSchema: () => TestsSchema,
   TextBlockSchema: () => TextBlockSchema,
   ThinkingBlockSchema: () => ThinkingBlockSchema,
+  ThinkingTextCompleteNotificationSchema: () => ThinkingTextCompleteNotificationSchema,
   ThinkingTextDeltaNotificationSchema: () => ThinkingTextDeltaNotificationSchema,
   TimeoutError: () => TimeoutError,
   ToggleMcpServerRequestParamsSchema: () => ToggleMcpServerRequestParamsSchema,
@@ -303,6 +319,7 @@ __export(index_exports, {
   ToggleMcpToolResponseSchema: () => ToggleMcpToolResponseSchema,
   ToggleMcpToolResultSchema: () => ToggleMcpToolResultSchema,
   TokenUsageSchema: () => TokenUsageSchema,
+  ToolCallNotificationSchema: () => ToolCallNotificationSchema,
   ToolConfirmationDetailsSchema: () => ToolConfirmationDetailsSchema,
   ToolConfirmationInfoSchema: () => ToolConfirmationInfoSchema,
   ToolConfirmationListItemSchema: () => ToolConfirmationListItemSchema,
@@ -329,10 +346,11 @@ __export(index_exports, {
   WorkerStartedEntrySchema: () => WorkerStartedEntrySchema,
   WorkerStateInfoSchema: () => WorkerStateInfoSchema,
   convertNotificationToStreamMessage: () => convertNotificationToStreamMessage,
+  createResponseSchema: () => createResponseSchema,
   createSdkMcpServer: () => createSdkMcpServer,
   createSession: () => createSession,
+  dispatchNotification: () => dispatchNotification,
   listSessions: () => listSessions,
-  query: () => query,
   resumeSession: () => resumeSession,
   run: () => run,
   tool: () => tool
@@ -344,6 +362,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 +405,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 +418,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) => {
@@ -700,6 +725,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 +1178,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 +1297,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 +1393,7 @@ var ClientRequestSchema = import_zod5.z.discriminatedUnion("method", [
   InitializeSessionRequestSchema,
   LoadSessionRequestSchema,
   AddUserMessageRequestSchema,
+  CloseSessionRequestSchema,
   InterruptSessionRequestSchema,
   KillWorkerSessionRequestSchema,
   UpdateSessionSettingsRequestSchema,
@@ -1415,6 +1454,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;
@@ -1455,127 +1495,88 @@ var ForkSessionResultSchema = import_zod5.z.object({
 }).passthrough();
 var GetContextStatsResultSchema = ContextStatsSchema;
 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 +1607,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 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 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 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 SessionTokenUsageChangedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("session_token_usage_changed" /* SESSION_TOKEN_USAGE_CHANGED */),
-  sessionId: import_zod7.z.string(),
+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 MissionProgressEntryNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mission_progress_entry" /* MISSION_PROGRESS_ENTRY */),
+  progressLog: import_zod8.z.array(ProgressLogEntrySchema)
 }).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 MissionHeartbeatNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mission_heartbeat" /* MISSION_HEARTBEAT */),
+  timestamp: import_zod8.z.string()
 }).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 MissionWorkerStartedNotificationSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("mission_worker_started" /* MISSION_WORKER_STARTED */),
+  workerSessionId: 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 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 MissionWorkerStartedNotificationSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("mission_worker_started" /* MISSION_WORKER_STARTED */),
-  workerSessionId: import_zod7.z.string()
+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 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 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 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 HookCommandSchema = import_zod8.z.object({
+  command: import_zod8.z.string(),
+  timeout: import_zod8.z.number().optional()
 }).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 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 +1844,10 @@ var SessionNotificationSchemaList = [
   SessionTitleUpdatedNotificationSchema,
   McpStatusChangedNotificationSchema,
   AssistantTextDeltaNotificationSchema,
+  AssistantTextCompleteNotificationSchema,
   ThinkingTextDeltaNotificationSchema,
+  ThinkingTextCompleteNotificationSchema,
+  ToolCallNotificationSchema,
   SessionTokenUsageChangedNotificationSchema,
   MissionStateChangedNotificationSchema,
   MissionFeaturesChangedNotificationSchema,
@@ -1761,88 +1856,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 +1951,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 +1997,7 @@ var _CliRequestOrNotificationSchema = import_zod7.z.union([
 var CliRequestOrNotificationSchema = _CliRequestOrNotificationSchema;
 
 // src/constants.ts
-var SDK_VERSION = "0.2.0";
+var SDK_VERSION = "0.3.0";
 var SDK_TAG = {
   name: "sdk",
   metadata: { language: "typescript", version: SDK_VERSION }
@@ -2221,6 +2313,24 @@ 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 ProtocolEngine = class {
   _transport;
   _defaultTimeout;
@@ -2385,22 +2495,7 @@ 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 */) {
@@ -2521,10 +2616,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 +2689,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 +2884,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 +2918,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 +2942,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 +2960,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 +2973,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 +3024,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 +3129,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 +3340,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) {
@@ -3081,10 +3363,20 @@ function extractInnerNotification(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 +3385,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 +3406,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 +3418,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 +3433,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;
@@ -3214,7 +3520,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 +3533,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,162 +3710,6 @@ 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;
-  }
-  get sessionId() {
-    return this._getSessionId();
-  }
-  get initResult() {
-    return this._getInitResult();
-  }
-  get initialized() {
-    return this._getInitialized();
-  }
-  async interrupt() {
-    return this._interruptFn();
-  }
-  abort() {
-    this._abortFn();
-  }
-  next(...args) {
-    return this._generator.next(...args);
-  }
-  return(value) {
-    return this._generator.return(value);
-  }
-  throw(e) {
-    return this._generator.throw(e);
-  }
-  [Symbol.asyncIterator]() {
-    return this;
-  }
-};
-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) {
@@ -3574,24 +3724,6 @@ function throwIfAborted(signal) {
     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;
@@ -3599,6 +3731,7 @@ var DroidSession = class {
   _closed = false;
   _cleanupAbortSignal = null;
   _cleanupCallbacks = [];
+  _activeBridges = /* @__PURE__ */ new Set();
   /** @internal */
   constructor(client, sessionId, initResult) {
     this._client = client;
@@ -3619,11 +3752,22 @@ var DroidSession = class {
   addCleanup(cleanup) {
     this._cleanupCallbacks.push(cleanup);
   }
-  /** Yields {@link DroidMessage} events until `turn_complete`. */
-  async *stream(text, options) {
+  async *stream(prompt, options) {
     this._ensureNotClosed();
     throwIfAborted(options?.abortSignal);
-    const bridge = new MessageBridge();
+    const startedAt = Date.now();
+    let resolveDone = () => {
+    };
+    const donePromise = new Promise((resolve2) => {
+      resolveDone = resolve2;
+    });
+    const bridge = new MessageBridge(resolveDone, {
+      includePartialMessages: options?.includePartialMessages,
+      sessionId: this._sessionId,
+      startedAt,
+      outputFormat: options?.outputFormat
+    });
+    this._activeBridges.add(bridge);
     const unsubscribe = this._client.onNotification(bridge.notificationHandler);
     let resolveAbort = () => {
     };
@@ -3639,11 +3783,12 @@ var DroidSession = class {
     try {
       await Promise.race([
         this._client.addUserMessage({
-          text,
+          text: prompt,
           images: options?.images,
           files: options?.files,
           outputFormat: options?.outputFormat
         }),
+        donePromise,
         abortPromise
       ]);
       throwIfAborted(options?.abortSignal);
@@ -3655,62 +3800,9 @@ var DroidSession = class {
     } finally {
       cleanupAbortSignal();
       unsubscribe();
+      this._activeBridges.delete(bridge);
     }
   }
-  /** 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();
@@ -3722,7 +3814,12 @@ var DroidSession = class {
     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);
@@ -3861,10 +3958,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();
   }
@@ -4111,6 +4216,7 @@ async function listSessions(options = {}) {
   AskUserRequestSchema,
   AskUserResponseSchema,
   AskUserResultSchema,
+  AssistantTextCompleteNotificationSchema,
   AssistantTextDeltaNotificationSchema,
   AuthenticateMcpServerRequestParamsSchema,
   AuthenticateMcpServerRequestSchema,
@@ -4135,6 +4241,10 @@ async function listSessions(options = {}) {
   ClearMcpAuthResultSchema,
   CliRequestOrNotificationSchema,
   ClientRequestSchema,
+  CloseSessionRequestParamsSchema,
+  CloseSessionRequestSchema,
+  CloseSessionResponseSchema,
+  CloseSessionResultSchema,
   CompactSessionRequestParamsSchema,
   CompactSessionRequestSchema,
   CompactSessionResponseSchema,
@@ -4155,6 +4265,10 @@ async function listSessions(options = {}) {
   DroidClient,
   DroidClientMethod,
   DroidErrorType,
+  DroidHookEventSchema,
+  DroidHookExecutionResultSchema,
+  DroidHookOutputSchema,
+  DroidHookSpecificOutputSchema,
   DroidInteractionMode,
   DroidMessageType,
   DroidServerMethod,
@@ -4195,6 +4309,10 @@ async function listSessions(options = {}) {
   GitRepoInfoSchema,
   HandoffItemsDismissedEntrySchema,
   HandoffSchema,
+  HookCommandSchema,
+  HookExecutionCompletedNotificationSchema,
+  HookExecutionStartedNotificationSchema,
+  HookResultSchema,
   HttpHeaderSchema,
   HttpMcpConfigSchema,
   ImageBlockSchema,
@@ -4343,6 +4461,8 @@ async function listSessions(options = {}) {
   StartMissionRunConfirmationDetailsSchema,
   StdioMcpConfigSchema,
   StreamStateTracker,
+  StructuredOutputErrorSchema,
+  StructuredOutputNotificationSchema,
   SubmitBugReportRequestParamsSchema,
   SubmitBugReportRequestSchema,
   SubmitBugReportResponseSchema,
@@ -4357,6 +4477,7 @@ async function listSessions(options = {}) {
   TestsSchema,
   TextBlockSchema,
   ThinkingBlockSchema,
+  ThinkingTextCompleteNotificationSchema,
   ThinkingTextDeltaNotificationSchema,
   TimeoutError,
   ToggleMcpServerRequestParamsSchema,
@@ -4368,6 +4489,7 @@ async function listSessions(options = {}) {
   ToggleMcpToolResponseSchema,
   ToggleMcpToolResultSchema,
   TokenUsageSchema,
+  ToolCallNotificationSchema,
   ToolConfirmationDetailsSchema,
   ToolConfirmationInfoSchema,
   ToolConfirmationListItemSchema,
@@ -4394,10 +4516,11 @@ async function listSessions(options = {}) {
   WorkerStartedEntrySchema,
   WorkerStateInfoSchema,
   convertNotificationToStreamMessage,
+  createResponseSchema,
   createSdkMcpServer,
   createSession,
+  dispatchNotification,
   listSessions,
-  query,
   resumeSession,
   run,
   tool