@factory/droid-sdk 0.2.0 → 0.3.0

package/dist/index.js

@@ -3,6 +3,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";
@@ -45,7 +46,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";
@@ -55,6 +59,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) => {
@@ -359,6 +366,12 @@ var JsonRpcMessageSchema = z.discriminatedUnion("type", [
   }),
   JsonRpcNotificationSchema
 ]);
+function createResponseSchema(resultSchema) {
+  return z.union([
+    JsonRpcResponseSuccessSchema.extend({ result: resultSchema }),
+    JsonRpcResponseFailureSchema
+  ]);
+}
 
 // src/schemas/session-metadata.ts
 import { z as z6 } from "zod";
@@ -806,6 +819,9 @@ var AddUserMessageRequestParamsSchema = z5.object({
   outputFormat: OutputFormatSchema.optional()
 }).strict();
 var InterruptSessionRequestParamsSchema = z5.object({}).strict();
+var CloseSessionRequestParamsSchema = z5.object({
+  reason: z5.enum(["clear", "logout", "prompt_input_exit", "other"]).optional()
+}).strict();
 var KillWorkerSessionRequestParamsSchema = z5.object({
   workerSessionId: z5.string()
 }).strict();
@@ -922,6 +938,10 @@ var InterruptSessionRequestSchema = JsonRpcRequestSchema.extend({
   method: z5.literal("droid.interrupt_session" /* INTERRUPT_SESSION */),
   params: InterruptSessionRequestParamsSchema
 });
+var CloseSessionRequestSchema = JsonRpcRequestSchema.extend({
+  method: z5.literal("droid.close_session" /* CLOSE_SESSION */),
+  params: CloseSessionRequestParamsSchema
+});
 var KillWorkerSessionRequestSchema = JsonRpcRequestSchema.extend({
   method: z5.literal("droid.kill_worker_session" /* KILL_WORKER_SESSION */),
   params: KillWorkerSessionRequestParamsSchema
@@ -1014,6 +1034,7 @@ var ClientRequestSchema = z5.discriminatedUnion("method", [
   InitializeSessionRequestSchema,
   LoadSessionRequestSchema,
   AddUserMessageRequestSchema,
+  CloseSessionRequestSchema,
   InterruptSessionRequestSchema,
   KillWorkerSessionRequestSchema,
   UpdateSessionSettingsRequestSchema,
@@ -1074,6 +1095,7 @@ var LoadSessionResultSchema = z5.object({
 }).passthrough();
 var AddUserMessageResultSchema = EmptyResultSchema;
 var InterruptSessionResultSchema = EmptyResultSchema;
+var CloseSessionResultSchema = EmptyResultSchema;
 var KillWorkerSessionResultSchema = EmptyResultSchema;
 var UpdateSessionSettingsResultSchema = EmptyResultSchema;
 var ToggleMcpServerResultSchema = SuccessResultSchema;
@@ -1114,127 +1136,88 @@ var ForkSessionResultSchema = z5.object({
 }).passthrough();
 var GetContextStatsResultSchema = ContextStatsSchema;
 var RenameSessionResultSchema = SuccessResultSchema;
-var InitializeSessionResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: InitializeSessionResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var _LoadSessionResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: LoadSessionResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
+var InitializeSessionResponseSchema = createResponseSchema(
+  InitializeSessionResultSchema
+);
+var _LoadSessionResponseSchema = createResponseSchema(
+  LoadSessionResultSchema
+);
 var LoadSessionResponseSchema = _LoadSessionResponseSchema;
-var AddUserMessageResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: AddUserMessageResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var InterruptSessionResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: InterruptSessionResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var KillWorkerSessionResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: KillWorkerSessionResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var UpdateSessionSettingsResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: UpdateSessionSettingsResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var ToggleMcpServerResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: ToggleMcpServerResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var AuthenticateMcpServerResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: AuthenticateMcpServerResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var CancelMcpAuthResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: CancelMcpAuthResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ClearMcpAuthResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ClearMcpAuthResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var SubmitMcpAuthCodeResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: SubmitMcpAuthCodeResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var AddMcpServerResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: AddMcpServerResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var RemoveMcpServerResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: RemoveMcpServerResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ListMcpRegistryResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: ListMcpRegistryResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var ListMcpToolsResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ListMcpToolsResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ListToolsResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ListToolsResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ListMcpServersResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ListMcpServersResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ToggleMcpToolResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ToggleMcpToolResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ListSkillsResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ListSkillsResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var SubmitBugReportResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: SubmitBugReportResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var GetRewindInfoResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: GetRewindInfoResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ExecuteRewindResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ExecuteRewindResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var CompactSessionResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: CompactSessionResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var ForkSessionResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: ForkSessionResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var GetContextStatsResponseSchema = z5.union([
-  JsonRpcResponseSuccessSchema.extend({ result: GetContextStatsResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var RenameSessionResponseSchema = z5.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 = z6.object({
@@ -1265,140 +1248,231 @@ var SessionSettingsFileSchema = z6.object({
   tags: z6.array(SessionTagSchema).optional()
 }).passthrough();
 
-// src/schemas/server.ts
+// src/schemas/hooks.ts
 import { z as z7 } from "zod";
+var DroidHookEventSchema = z7.enum([
+  "PreToolUse",
+  "PostToolUse",
+  "Notification",
+  "UserPromptSubmit",
+  "Stop",
+  "SubagentStop",
+  "PreCompact",
+  "SessionStart",
+  "SessionEnd"
+]);
+var DroidHookSpecificOutputSchema = z7.object({
+  hookEventName: DroidHookEventSchema.optional(),
+  permissionDecision: z7.enum(["allow", "deny", "ask"]).optional(),
+  permissionDecisionReason: z7.string().optional(),
+  additionalContext: z7.string().optional(),
+  updatedInput: z7.record(z7.unknown()).optional()
+}).passthrough();
+var DroidHookOutputSchema = z7.object({
+  continue: z7.boolean().optional(),
+  stopReason: z7.string().optional(),
+  suppressOutput: z7.boolean().optional(),
+  systemMessage: z7.string().optional(),
+  decision: z7.enum(["block", "approve"]).optional(),
+  reason: z7.string().optional(),
+  hookSpecificOutput: DroidHookSpecificOutputSchema.optional()
+}).passthrough();
+var DroidHookExecutionResultSchema = DroidHookOutputSchema.extend({
+  exitCode: z7.number(),
+  stdout: z7.string(),
+  stderr: z7.string()
+});
+
+// src/schemas/server.ts
+import { z as z8 } from "zod";
 var ToolUseBlockSchema2 = ToolUseBlockSchema;
 var ToolUseSchema = ToolUseBlockSchema2;
-var ErrorDetailSchema = z7.object({
-  name: z7.string(),
-  message: z7.string()
-}).passthrough();
-var ToolProgressUpdateSchema = z7.object({
-  type: z7.enum(["tool_call", "tool_result", "error", "status", "message"]),
-  toolName: z7.string().optional(),
-  status: z7.string().optional(),
-  details: z7.string().optional(),
-  text: z7.string().optional(),
-  error: z7.string().optional(),
-  timestamp: z7.number().optional(),
+var ErrorDetailSchema = z8.object({
+  name: z8.string(),
+  message: z8.string()
+}).passthrough();
+var ToolProgressUpdateSchema = z8.object({
+  type: z8.enum(["tool_call", "tool_result", "error", "status", "message"]),
+  toolName: z8.string().optional(),
+  status: z8.string().optional(),
+  details: z8.string().optional(),
+  text: z8.string().optional(),
+  error: z8.string().optional(),
+  timestamp: z8.number().optional(),
   parameters: JsonObjectSchema.optional(),
-  valueSnippet: z7.string().optional(),
-  subagentSessionId: z7.string().optional()
-}).passthrough();
-var SettingsUpdatedPayloadSchema = z7.object({
-  autonomyMode: z7.nativeEnum(AutonomyMode).optional(),
-  interactionMode: z7.nativeEnum(DroidInteractionMode).optional().catch(void 0),
-  autonomyLevel: z7.nativeEnum(AutonomyLevel).optional().catch(void 0),
-  modelId: z7.string().optional(),
-  reasoningEffort: z7.nativeEnum(ReasoningEffort).optional(),
-  specModeModelId: z7.string().optional(),
-  specModeReasoningEffort: z7.nativeEnum(ReasoningEffort).optional(),
+  valueSnippet: z8.string().optional(),
+  subagentSessionId: z8.string().optional()
+}).passthrough();
+var SettingsUpdatedPayloadSchema = z8.object({
+  autonomyMode: z8.nativeEnum(AutonomyMode).optional(),
+  interactionMode: z8.nativeEnum(DroidInteractionMode).optional().catch(void 0),
+  autonomyLevel: z8.nativeEnum(AutonomyLevel).optional().catch(void 0),
+  modelId: z8.string().optional(),
+  reasoningEffort: z8.nativeEnum(ReasoningEffort).optional(),
+  specModeModelId: z8.string().optional(),
+  specModeReasoningEffort: z8.nativeEnum(ReasoningEffort).optional(),
   ...ToolSelectionOverridesSchema.shape
 }).passthrough();
-var ToolResultNotificationSchema = z7.object({
-  type: z7.literal("tool_result" /* TOOL_RESULT */),
-  messageId: z7.string(),
-  toolUseId: z7.string(),
+var ToolResultNotificationSchema = z8.object({
+  type: z8.literal("tool_result" /* TOOL_RESULT */),
+  messageId: z8.string(),
+  toolUseId: z8.string(),
   content: JsonValueSchema.optional(),
-  isError: z7.boolean().optional(),
-  id: z7.string().optional()
+  isError: z8.boolean().optional(),
+  id: z8.string().optional()
 }).passthrough();
-var ToolProgressUpdateNotificationSchema = z7.object({
-  type: z7.literal("tool_progress_update" /* TOOL_PROGRESS_UPDATE */),
-  toolUseId: z7.string(),
-  toolName: z7.string(),
+var ToolProgressUpdateNotificationSchema = z8.object({
+  type: z8.literal("tool_progress_update" /* TOOL_PROGRESS_UPDATE */),
+  toolUseId: z8.string(),
+  toolName: z8.string(),
   update: ToolProgressUpdateSchema
 }).passthrough();
-var CreateMessageNotificationSchema = z7.object({
-  type: z7.literal("create_message" /* CREATE_MESSAGE */),
+var CreateMessageNotificationSchema = z8.object({
+  type: z8.literal("create_message" /* CREATE_MESSAGE */),
   message: FactoryDroidMessageSchema,
-  parentId: z7.string().optional(),
-  requestId: z7.string().optional()
-}).passthrough();
-var ErrorNotificationSchema = z7.object({
-  type: z7.literal("error" /* ERROR */),
-  message: z7.string(),
-  errorType: z7.nativeEnum(DroidErrorType),
-  timestamp: z7.string(),
+  parentId: z8.string().optional(),
+  requestId: z8.string().optional()
+}).passthrough();
+var ErrorNotificationSchema = z8.object({
+  type: z8.literal("error" /* ERROR */),
+  message: z8.string(),
+  errorType: z8.nativeEnum(DroidErrorType),
+  timestamp: z8.string(),
   error: ErrorDetailSchema.optional()
 }).passthrough();
-var DroidWorkingStateChangedNotificationSchema = z7.object({
-  type: z7.literal("droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */),
-  newState: z7.nativeEnum(DroidWorkingState)
+var DroidWorkingStateChangedNotificationSchema = z8.object({
+  type: z8.literal("droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */),
+  newState: z8.nativeEnum(DroidWorkingState)
 }).passthrough();
-var PermissionResolvedNotificationSchema = z7.object({
-  type: z7.literal("permission_resolved" /* PERMISSION_RESOLVED */),
-  requestId: z7.string(),
-  toolUseIds: z7.array(z7.string()),
-  selectedOption: z7.nativeEnum(ToolConfirmationOutcome)
+var PermissionResolvedNotificationSchema = z8.object({
+  type: z8.literal("permission_resolved" /* PERMISSION_RESOLVED */),
+  requestId: z8.string(),
+  toolUseIds: z8.array(z8.string()),
+  selectedOption: z8.nativeEnum(ToolConfirmationOutcome)
 }).passthrough();
-var SettingsUpdatedNotificationSchema = z7.object({
-  type: z7.literal("settings_updated" /* SETTINGS_UPDATED */),
+var SettingsUpdatedNotificationSchema = z8.object({
+  type: z8.literal("settings_updated" /* SETTINGS_UPDATED */),
   settings: SettingsUpdatedPayloadSchema
 }).passthrough();
-var SessionTitleUpdatedNotificationSchema = z7.object({
-  type: z7.literal("session_title_updated" /* SESSION_TITLE_UPDATED */),
-  title: z7.string()
+var SessionTitleUpdatedNotificationSchema = z8.object({
+  type: z8.literal("session_title_updated" /* SESSION_TITLE_UPDATED */),
+  title: z8.string()
 }).passthrough();
-var McpStatusChangedNotificationSchema = z7.object({
-  type: z7.literal("mcp_status_changed" /* MCP_STATUS_CHANGED */),
-  servers: z7.array(McpServerStatusInfoSchema),
+var McpStatusChangedNotificationSchema = z8.object({
+  type: z8.literal("mcp_status_changed" /* MCP_STATUS_CHANGED */),
+  servers: z8.array(McpServerStatusInfoSchema),
   summary: McpStatusSummarySchema
 }).passthrough();
-var AssistantTextDeltaNotificationSchema = z7.object({
-  type: z7.literal("assistant_text_delta" /* ASSISTANT_TEXT_DELTA */),
-  messageId: z7.string(),
-  blockIndex: z7.number(),
-  textDelta: z7.string()
-}).passthrough();
-var ThinkingTextDeltaNotificationSchema = z7.object({
-  type: z7.literal("thinking_text_delta" /* THINKING_TEXT_DELTA */),
-  messageId: z7.string(),
-  blockIndex: z7.number(),
-  textDelta: z7.string()
-}).passthrough();
-var SessionTokenUsageChangedNotificationSchema = z7.object({
-  type: z7.literal("session_token_usage_changed" /* SESSION_TOKEN_USAGE_CHANGED */),
-  sessionId: z7.string(),
+var AssistantTextDeltaNotificationSchema = z8.object({
+  type: z8.literal("assistant_text_delta" /* ASSISTANT_TEXT_DELTA */),
+  messageId: z8.string(),
+  blockIndex: z8.number(),
+  textDelta: z8.string()
+}).passthrough();
+var AssistantTextCompleteNotificationSchema = z8.object({
+  type: z8.literal("assistant_text_complete" /* ASSISTANT_TEXT_COMPLETE */),
+  messageId: z8.string(),
+  blockIndex: z8.number()
+}).passthrough();
+var ThinkingTextDeltaNotificationSchema = z8.object({
+  type: z8.literal("thinking_text_delta" /* THINKING_TEXT_DELTA */),
+  messageId: z8.string(),
+  blockIndex: z8.number(),
+  textDelta: z8.string()
+}).passthrough();
+var ThinkingTextCompleteNotificationSchema = z8.object({
+  type: z8.literal("thinking_text_complete" /* THINKING_TEXT_COMPLETE */),
+  messageId: z8.string(),
+  blockIndex: z8.number(),
+  durationMs: z8.number().optional()
+}).passthrough();
+var ToolCallNotificationSchema = z8.object({
+  type: z8.literal("tool_call" /* TOOL_CALL */),
+  toolUse: ToolUseBlockSchema2
+}).passthrough();
+var SessionTokenUsageChangedNotificationSchema = z8.object({
+  type: z8.literal("session_token_usage_changed" /* SESSION_TOKEN_USAGE_CHANGED */),
+  sessionId: z8.string(),
   tokenUsage: TokenUsageSchema
 }).passthrough();
-var MissionStateChangedNotificationSchema = z7.object({
-  type: z7.literal("mission_state_changed" /* MISSION_STATE_CHANGED */),
-  state: z7.nativeEnum(MissionState)
+var MissionStateChangedNotificationSchema = z8.object({
+  type: z8.literal("mission_state_changed" /* MISSION_STATE_CHANGED */),
+  state: z8.nativeEnum(MissionState)
 }).passthrough();
-var MissionFeaturesChangedNotificationSchema = z7.object({
-  type: z7.literal("mission_features_changed" /* MISSION_FEATURES_CHANGED */),
-  features: z7.array(MissionFeatureSchema)
+var MissionFeaturesChangedNotificationSchema = z8.object({
+  type: z8.literal("mission_features_changed" /* MISSION_FEATURES_CHANGED */),
+  features: z8.array(MissionFeatureSchema)
 }).passthrough();
-var MissionProgressEntryNotificationSchema = z7.object({
-  type: z7.literal("mission_progress_entry" /* MISSION_PROGRESS_ENTRY */),
-  progressLog: z7.array(ProgressLogEntrySchema)
+var MissionProgressEntryNotificationSchema = z8.object({
+  type: z8.literal("mission_progress_entry" /* MISSION_PROGRESS_ENTRY */),
+  progressLog: z8.array(ProgressLogEntrySchema)
 }).passthrough();
-var MissionHeartbeatNotificationSchema = z7.object({
-  type: z7.literal("mission_heartbeat" /* MISSION_HEARTBEAT */),
-  timestamp: z7.string()
+var MissionHeartbeatNotificationSchema = z8.object({
+  type: z8.literal("mission_heartbeat" /* MISSION_HEARTBEAT */),
+  timestamp: z8.string()
 }).passthrough();
-var MissionWorkerStartedNotificationSchema = z7.object({
-  type: z7.literal("mission_worker_started" /* MISSION_WORKER_STARTED */),
-  workerSessionId: z7.string()
+var MissionWorkerStartedNotificationSchema = z8.object({
+  type: z8.literal("mission_worker_started" /* MISSION_WORKER_STARTED */),
+  workerSessionId: z8.string()
 }).passthrough();
-var MissionWorkerCompletedNotificationSchema = z7.object({
-  type: z7.literal("mission_worker_completed" /* MISSION_WORKER_COMPLETED */),
-  workerSessionId: z7.string(),
-  exitCode: z7.number()
+var MissionWorkerCompletedNotificationSchema = z8.object({
+  type: z8.literal("mission_worker_completed" /* MISSION_WORKER_COMPLETED */),
+  workerSessionId: z8.string(),
+  exitCode: z8.number()
 }).passthrough();
-var McpAuthRequiredNotificationSchema = z7.object({
-  type: z7.literal("mcp_auth_required" /* MCP_AUTH_REQUIRED */),
-  serverName: z7.string(),
-  authUrl: z7.string(),
-  message: z7.string(),
-  state: z7.string()
+var McpAuthRequiredNotificationSchema = z8.object({
+  type: z8.literal("mcp_auth_required" /* MCP_AUTH_REQUIRED */),
+  serverName: z8.string(),
+  authUrl: z8.string(),
+  message: z8.string(),
+  state: z8.string()
 }).passthrough();
-var McpAuthCompletedNotificationSchema = z7.object({
-  type: z7.literal("mcp_auth_completed" /* MCP_AUTH_COMPLETED */),
-  serverName: z7.string(),
-  outcome: z7.nativeEnum(McpAuthOutcome),
-  message: z7.string()
+var McpAuthCompletedNotificationSchema = z8.object({
+  type: z8.literal("mcp_auth_completed" /* MCP_AUTH_COMPLETED */),
+  serverName: z8.string(),
+  outcome: z8.nativeEnum(McpAuthOutcome),
+  message: z8.string()
+}).passthrough();
+var HookCommandSchema = z8.object({
+  command: z8.string(),
+  timeout: z8.number().optional()
+}).passthrough();
+var HookResultSchema = z8.object({
+  exitCode: z8.number(),
+  stdout: z8.string(),
+  stderr: z8.string(),
+  command: z8.string().optional(),
+  timeout: z8.number().optional()
+}).passthrough();
+var HookExecutionStartedNotificationSchema = z8.object({
+  type: z8.literal("hook_execution_started" /* HOOK_EXECUTION_STARTED */),
+  hookId: z8.string(),
+  hookEventName: DroidHookEventSchema,
+  hookMatcher: z8.string().optional(),
+  hookCommands: z8.array(HookCommandSchema),
+  hookToolCallId: z8.string().optional(),
+  isParallelExecution: z8.boolean().optional(),
+  parallelGroupId: z8.string().optional()
+}).passthrough();
+var HookExecutionCompletedNotificationSchema = z8.object({
+  type: z8.literal("hook_execution_completed" /* HOOK_EXECUTION_COMPLETED */),
+  hookId: z8.string(),
+  hookEventName: DroidHookEventSchema.optional(),
+  hookMatcher: z8.string().optional(),
+  hookToolCallId: z8.string().optional(),
+  hookStatus: z8.enum(["completed", "error"]),
+  hookResults: z8.array(HookResultSchema).optional()
+}).passthrough();
+var StructuredOutputErrorSchema = z8.object({
+  code: z8.string(),
+  message: z8.string(),
+  details: z8.unknown().optional()
+}).passthrough();
+var StructuredOutputNotificationSchema = z8.object({
+  type: z8.literal("structured_output" /* STRUCTURED_OUTPUT */),
+  messageId: z8.string(),
+  structuredOutput: JsonObjectSchema.nullable(),
+  structuredOutputError: StructuredOutputErrorSchema.nullable()
 }).passthrough();
 var SessionNotificationSchemaList = [
   ToolResultNotificationSchema,
@@ -1411,7 +1485,10 @@ var SessionNotificationSchemaList = [
   SessionTitleUpdatedNotificationSchema,
   McpStatusChangedNotificationSchema,
   AssistantTextDeltaNotificationSchema,
+  AssistantTextCompleteNotificationSchema,
   ThinkingTextDeltaNotificationSchema,
+  ThinkingTextCompleteNotificationSchema,
+  ToolCallNotificationSchema,
   SessionTokenUsageChangedNotificationSchema,
   MissionStateChangedNotificationSchema,
   MissionFeaturesChangedNotificationSchema,
@@ -1420,88 +1497,91 @@ var SessionNotificationSchemaList = [
   MissionWorkerStartedNotificationSchema,
   MissionWorkerCompletedNotificationSchema,
   McpAuthRequiredNotificationSchema,
-  McpAuthCompletedNotificationSchema
+  McpAuthCompletedNotificationSchema,
+  HookExecutionStartedNotificationSchema,
+  HookExecutionCompletedNotificationSchema,
+  StructuredOutputNotificationSchema
 ];
-var SessionNotificationPayloadSchema = z7.discriminatedUnion(
+var SessionNotificationPayloadSchema = z8.discriminatedUnion(
   "type",
   SessionNotificationSchemaList
 );
-var _SessionNotificationParamsSchema = z7.object({
+var _SessionNotificationParamsSchema = z8.object({
   notification: SessionNotificationPayloadSchema
 }).passthrough();
 var SessionNotificationParamsSchema = _SessionNotificationParamsSchema;
 var _SessionNotificationSchema = JsonRpcNotificationSchema.extend({
-  method: z7.literal("droid.session_notification" /* SESSION_NOTIFICATION */),
+  method: z8.literal("droid.session_notification" /* SESSION_NOTIFICATION */),
   params: SessionNotificationParamsSchema
 });
 var SessionNotificationSchema = _SessionNotificationSchema;
-var EditToolConfirmationDetailsSchema = z7.object({
-  type: z7.literal("edit" /* Edit */),
-  filePath: z7.string(),
-  fileName: z7.string(),
-  oldContent: z7.string().optional(),
-  newContent: z7.string().optional()
-}).passthrough();
-var ExecuteToolConfirmationDetailsSchema = z7.object({
-  type: z7.literal("exec" /* Execute */),
-  fullCommand: z7.string(),
-  command: z7.string(),
-  extractedCommands: z7.array(z7.string()).optional(),
-  impactLevel: z7.string().optional()
-}).passthrough();
-var CreateToolConfirmationDetailsSchema = z7.object({
-  type: z7.literal("create" /* Create */),
-  filePath: z7.string(),
-  fileName: z7.string(),
-  content: z7.string()
-}).passthrough();
-var AskUserQuestionSchema = z7.object({
-  index: z7.number(),
-  topic: z7.string(),
-  question: z7.string(),
-  options: z7.array(z7.string())
-}).passthrough();
-var AskUserConfirmationDetailsSchema = z7.object({
-  type: z7.literal("ask_user" /* AskUser */),
-  questionnaire: z7.string(),
-  parsed: z7.object({
-    questions: z7.array(AskUserQuestionSchema)
+var EditToolConfirmationDetailsSchema = z8.object({
+  type: z8.literal("edit" /* Edit */),
+  filePath: z8.string(),
+  fileName: z8.string(),
+  oldContent: z8.string().optional(),
+  newContent: z8.string().optional()
+}).passthrough();
+var ExecuteToolConfirmationDetailsSchema = z8.object({
+  type: z8.literal("exec" /* Execute */),
+  fullCommand: z8.string(),
+  command: z8.string(),
+  extractedCommands: z8.array(z8.string()).optional(),
+  impactLevel: z8.string().optional()
+}).passthrough();
+var CreateToolConfirmationDetailsSchema = z8.object({
+  type: z8.literal("create" /* Create */),
+  filePath: z8.string(),
+  fileName: z8.string(),
+  content: z8.string()
+}).passthrough();
+var AskUserQuestionSchema = z8.object({
+  index: z8.number(),
+  topic: z8.string(),
+  question: z8.string(),
+  options: z8.array(z8.string())
+}).passthrough();
+var AskUserConfirmationDetailsSchema = z8.object({
+  type: z8.literal("ask_user" /* AskUser */),
+  questionnaire: z8.string(),
+  parsed: z8.object({
+    questions: z8.array(AskUserQuestionSchema)
   }).optional(),
-  parseError: z7.object({
-    message: z7.string(),
-    line: z7.number().optional()
+  parseError: z8.object({
+    message: z8.string(),
+    line: z8.number().optional()
   }).optional()
 }).passthrough();
-var ExitSpecModeConfirmationDetailsSchema = z7.object({
-  type: z7.literal("exit_spec_mode" /* ExitSpecMode */),
-  plan: z7.string(),
-  title: z7.string().optional(),
-  optionNames: z7.array(z7.string()).optional()
-}).passthrough();
-var ProposeMissionConfirmationDetailsSchema = z7.object({
-  type: z7.literal("propose_mission" /* ProposeMission */),
-  proposal: z7.string(),
-  title: z7.string().optional()
-}).passthrough();
-var StartMissionRunConfirmationDetailsSchema = z7.object({
-  type: z7.literal("start_mission_run" /* StartMissionRun */),
-  runningMissionCount: z7.number(),
-  runningMissionSessionIds: z7.array(z7.string())
-}).passthrough();
-var ApplyPatchToolConfirmationDetailsSchema = z7.object({
-  type: z7.literal("apply_patch" /* ApplyPatch */),
-  filePath: z7.string(),
-  fileName: z7.string(),
-  patchContent: z7.string(),
-  oldContent: z7.string().optional(),
-  newContent: z7.string().optional()
-}).passthrough();
-var McpToolConfirmationDetailsSchema = z7.object({
-  type: z7.literal("mcp_tool" /* McpTool */),
-  toolName: z7.string(),
-  impactLevel: z7.string()
-}).passthrough();
-var ToolConfirmationDetailsSchema = z7.discriminatedUnion("type", [
+var ExitSpecModeConfirmationDetailsSchema = z8.object({
+  type: z8.literal("exit_spec_mode" /* ExitSpecMode */),
+  plan: z8.string(),
+  title: z8.string().optional(),
+  optionNames: z8.array(z8.string()).optional()
+}).passthrough();
+var ProposeMissionConfirmationDetailsSchema = z8.object({
+  type: z8.literal("propose_mission" /* ProposeMission */),
+  proposal: z8.string(),
+  title: z8.string().optional()
+}).passthrough();
+var StartMissionRunConfirmationDetailsSchema = z8.object({
+  type: z8.literal("start_mission_run" /* StartMissionRun */),
+  runningMissionCount: z8.number(),
+  runningMissionSessionIds: z8.array(z8.string())
+}).passthrough();
+var ApplyPatchToolConfirmationDetailsSchema = z8.object({
+  type: z8.literal("apply_patch" /* ApplyPatch */),
+  filePath: z8.string(),
+  fileName: z8.string(),
+  patchContent: z8.string(),
+  oldContent: z8.string().optional(),
+  newContent: z8.string().optional()
+}).passthrough();
+var McpToolConfirmationDetailsSchema = z8.object({
+  type: z8.literal("mcp_tool" /* McpTool */),
+  toolName: z8.string(),
+  impactLevel: z8.string()
+}).passthrough();
+var ToolConfirmationDetailsSchema = z8.discriminatedUnion("type", [
   EditToolConfirmationDetailsSchema,
   ExecuteToolConfirmationDetailsSchema,
   CreateToolConfirmationDetailsSchema,
@@ -1512,51 +1592,45 @@ var ToolConfirmationDetailsSchema = z7.discriminatedUnion("type", [
   ApplyPatchToolConfirmationDetailsSchema,
   McpToolConfirmationDetailsSchema
 ]);
-var ToolConfirmationInfoSchema = z7.object({
+var ToolConfirmationInfoSchema = z8.object({
   toolUse: ToolUseSchema,
-  confirmationType: z7.nativeEnum(ToolConfirmationType),
+  confirmationType: z8.nativeEnum(ToolConfirmationType),
   details: ToolConfirmationDetailsSchema
 }).passthrough();
-var RequestPermissionRequestParamsSchema = z7.object({
-  toolUses: z7.array(ToolConfirmationInfoSchema),
-  options: z7.array(ToolConfirmationListItemSchema)
+var RequestPermissionRequestParamsSchema = z8.object({
+  toolUses: z8.array(ToolConfirmationInfoSchema),
+  options: z8.array(ToolConfirmationListItemSchema)
 }).passthrough();
 var RequestPermissionRequestSchema = JsonRpcRequestSchema.extend({
-  method: z7.literal("droid.request_permission" /* REQUEST_PERMISSION */),
+  method: z8.literal("droid.request_permission" /* REQUEST_PERMISSION */),
   params: RequestPermissionRequestParamsSchema
 });
-var RequestPermissionResultSchema = z7.object({
-  selectedOption: z7.nativeEnum(ToolConfirmationOutcome),
-  comment: z7.string().optional()
+var RequestPermissionResultSchema = z8.object({
+  selectedOption: z8.nativeEnum(ToolConfirmationOutcome),
+  comment: z8.string().optional()
 }).strict();
-var RequestPermissionResponseSchema = z7.union([
-  JsonRpcResponseSuccessSchema.extend({
-    result: RequestPermissionResultSchema
-  }),
-  JsonRpcResponseFailureSchema
-]);
-var AskUserRequestParamsSchema = z7.object({
-  toolCallId: z7.string(),
-  questions: z7.array(AskUserQuestionSchema)
+var RequestPermissionResponseSchema = createResponseSchema(
+  RequestPermissionResultSchema
+);
+var AskUserRequestParamsSchema = z8.object({
+  toolCallId: z8.string(),
+  questions: z8.array(AskUserQuestionSchema)
 }).passthrough();
 var AskUserRequestSchema = JsonRpcRequestSchema.extend({
-  method: z7.literal("droid.ask_user" /* ASK_USER */),
+  method: z8.literal("droid.ask_user" /* ASK_USER */),
   params: AskUserRequestParamsSchema
 });
-var AskUserCollectedAnswerSchema = z7.object({
-  index: z7.number(),
-  question: z7.string(),
-  answer: z7.string()
+var AskUserCollectedAnswerSchema = z8.object({
+  index: z8.number(),
+  question: z8.string(),
+  answer: z8.string()
 }).strict();
-var AskUserResultSchema = z7.object({
-  cancelled: z7.boolean().optional(),
-  answers: z7.array(AskUserCollectedAnswerSchema)
+var AskUserResultSchema = z8.object({
+  cancelled: z8.boolean().optional(),
+  answers: z8.array(AskUserCollectedAnswerSchema)
 }).strict();
-var AskUserResponseSchema = z7.union([
-  JsonRpcResponseSuccessSchema.extend({ result: AskUserResultSchema }),
-  JsonRpcResponseFailureSchema
-]);
-var _CliRequestOrNotificationSchema = z7.union([
+var AskUserResponseSchema = createResponseSchema(AskUserResultSchema);
+var _CliRequestOrNotificationSchema = z8.union([
   SessionNotificationSchema,
   RequestPermissionRequestSchema,
   AskUserRequestSchema
@@ -1564,7 +1638,7 @@ var _CliRequestOrNotificationSchema = z7.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 }
@@ -1880,6 +1954,24 @@ var ProcessTransport = class {
 
 // src/protocol.ts
 import { v4 as uuidv4 } from "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;
@@ -2044,22 +2136,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 */) {
@@ -2180,10 +2257,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;
@@ -2257,6 +2330,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 */,
@@ -2445,23 +2525,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;
@@ -2495,14 +2559,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",
@@ -2515,8 +2583,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);
@@ -2532,6 +2601,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,
@@ -2539,6 +2614,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,
@@ -2578,22 +2665,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 */:
@@ -2672,42 +2770,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 "";
@@ -2720,6 +2981,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) {
@@ -2740,10 +3004,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;
@@ -2752,10 +3026,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();
         }
       }
@@ -2769,7 +3047,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;
         }
       }
@@ -2781,6 +3059,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) {
@@ -2790,7 +3074,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;
@@ -2873,7 +3161,7 @@ import { once } from "events";
 import http from "http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function tool(name, description, inputSchemaOrHandler, handler) {
   if (typeof inputSchemaOrHandler === "function") {
     const actualHandler = inputSchemaOrHandler;
@@ -2886,7 +3174,7 @@ function tool(name, description, inputSchemaOrHandler, handler) {
   if (!handler) {
     throw new Error(`Missing handler for SDK MCP tool "${name}"`);
   }
-  const inputObjectSchema = z8.object(inputSchemaOrHandler);
+  const inputObjectSchema = z9.object(inputSchemaOrHandler);
   return {
     name,
     description,
@@ -3063,162 +3351,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) {
@@ -3233,24 +3365,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;
@@ -3258,6 +3372,7 @@ var DroidSession = class {
   _closed = false;
   _cleanupAbortSignal = null;
   _cleanupCallbacks = [];
+  _activeBridges = /* @__PURE__ */ new Set();
   /** @internal */
   constructor(client, sessionId, initResult) {
     this._client = client;
@@ -3278,11 +3393,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 = () => {
     };
@@ -3298,11 +3424,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);
@@ -3314,62 +3441,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();
@@ -3381,7 +3455,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);
@@ -3520,10 +3599,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();
   }
@@ -3769,6 +3856,7 @@ export {
   AskUserRequestSchema,
   AskUserResponseSchema,
   AskUserResultSchema,
+  AssistantTextCompleteNotificationSchema,
   AssistantTextDeltaNotificationSchema,
   AuthenticateMcpServerRequestParamsSchema,
   AuthenticateMcpServerRequestSchema,
@@ -3793,6 +3881,10 @@ export {
   ClearMcpAuthResultSchema,
   CliRequestOrNotificationSchema,
   ClientRequestSchema,
+  CloseSessionRequestParamsSchema,
+  CloseSessionRequestSchema,
+  CloseSessionResponseSchema,
+  CloseSessionResultSchema,
   CompactSessionRequestParamsSchema,
   CompactSessionRequestSchema,
   CompactSessionResponseSchema,
@@ -3813,6 +3905,10 @@ export {
   DroidClient,
   DroidClientMethod,
   DroidErrorType,
+  DroidHookEventSchema,
+  DroidHookExecutionResultSchema,
+  DroidHookOutputSchema,
+  DroidHookSpecificOutputSchema,
   DroidInteractionMode,
   DroidMessageType,
   DroidServerMethod,
@@ -3853,6 +3949,10 @@ export {
   GitRepoInfoSchema,
   HandoffItemsDismissedEntrySchema,
   HandoffSchema,
+  HookCommandSchema,
+  HookExecutionCompletedNotificationSchema,
+  HookExecutionStartedNotificationSchema,
+  HookResultSchema,
   HttpHeaderSchema,
   HttpMcpConfigSchema,
   ImageBlockSchema,
@@ -4001,6 +4101,8 @@ export {
   StartMissionRunConfirmationDetailsSchema,
   StdioMcpConfigSchema,
   StreamStateTracker,
+  StructuredOutputErrorSchema,
+  StructuredOutputNotificationSchema,
   SubmitBugReportRequestParamsSchema,
   SubmitBugReportRequestSchema,
   SubmitBugReportResponseSchema,
@@ -4015,6 +4117,7 @@ export {
   TestsSchema,
   TextBlockSchema,
   ThinkingBlockSchema,
+  ThinkingTextCompleteNotificationSchema,
   ThinkingTextDeltaNotificationSchema,
   TimeoutError,
   ToggleMcpServerRequestParamsSchema,
@@ -4026,6 +4129,7 @@ export {
   ToggleMcpToolResponseSchema,
   ToggleMcpToolResultSchema,
   TokenUsageSchema,
+  ToolCallNotificationSchema,
   ToolConfirmationDetailsSchema,
   ToolConfirmationInfoSchema,
   ToolConfirmationListItemSchema,
@@ -4052,10 +4156,11 @@ export {
   WorkerStartedEntrySchema,
   WorkerStateInfoSchema,
   convertNotificationToStreamMessage,
+  createResponseSchema,
   createSdkMcpServer,
   createSession,
+  dispatchNotification,
   listSessions,
-  query,
   resumeSession,
   run,
   tool