@factory/droid-sdk 0.1.4 → 0.2.0

package/dist/index.cjs

@@ -59,6 +59,7 @@ __export(index_exports, {
   BaseRequestSchema: () => BaseRequestSchema,
   BaseResponseFailureSchema: () => BaseResponseFailureSchema,
   BaseResponseSuccessSchema: () => BaseResponseSuccessSchema,
+  COMPACTION_TIMEOUT: () => COMPACTION_TIMEOUT,
   CancelMcpAuthRequestParamsSchema: () => CancelMcpAuthRequestParamsSchema,
   CancelMcpAuthRequestSchema: () => CancelMcpAuthRequestSchema,
   CancelMcpAuthResponseSchema: () => CancelMcpAuthResponseSchema,
@@ -69,8 +70,14 @@ __export(index_exports, {
   ClearMcpAuthResultSchema: () => ClearMcpAuthResultSchema,
   CliRequestOrNotificationSchema: () => CliRequestOrNotificationSchema,
   ClientRequestSchema: () => ClientRequestSchema,
+  CompactSessionRequestParamsSchema: () => CompactSessionRequestParamsSchema,
+  CompactSessionRequestSchema: () => CompactSessionRequestSchema,
+  CompactSessionResponseSchema: () => CompactSessionResponseSchema,
+  CompactSessionResultSchema: () => CompactSessionResultSchema,
   ConnectionError: () => ConnectionError,
   ContentBlockSchema: () => ContentBlockSchema,
+  ContextStatsAccuracy: () => ContextStatsAccuracy,
+  ContextStatsSchema: () => ContextStatsSchema,
   CreateMessageNotificationSchema: () => CreateMessageNotificationSchema,
   CreateToolConfirmationDetailsSchema: () => CreateToolConfirmationDetailsSchema,
   DEFAULT_REQUEST_TIMEOUT: () => DEFAULT_REQUEST_TIMEOUT,
@@ -84,22 +91,42 @@ __export(index_exports, {
   DroidClientMethod: () => DroidClientMethod,
   DroidErrorType: () => DroidErrorType,
   DroidInteractionMode: () => DroidInteractionMode,
+  DroidMessageType: () => DroidMessageType,
   DroidServerMethod: () => DroidServerMethod,
   DroidSession: () => DroidSession,
   DroidWorkingState: () => DroidWorkingState,
   DroidWorkingStateChangedNotificationSchema: () => DroidWorkingStateChangedNotificationSchema,
   EditToolConfirmationDetailsSchema: () => EditToolConfirmationDetailsSchema,
+  EmptyResultSchema: () => EmptyResultSchema,
   ErrorDetailSchema: () => ErrorDetailSchema,
   ErrorNotificationSchema: () => ErrorNotificationSchema,
+  ExecToolInfoSchema: () => ExecToolInfoSchema,
+  ExecuteRewindRequestParamsSchema: () => ExecuteRewindRequestParamsSchema,
+  ExecuteRewindRequestSchema: () => ExecuteRewindRequestSchema,
+  ExecuteRewindResponseSchema: () => ExecuteRewindResponseSchema,
+  ExecuteRewindResultSchema: () => ExecuteRewindResultSchema,
   ExecuteToolConfirmationDetailsSchema: () => ExecuteToolConfirmationDetailsSchema,
   ExitSpecModeConfirmationDetailsSchema: () => ExitSpecModeConfirmationDetailsSchema,
   FACTORY_CLIENT_HEADER: () => FACTORY_CLIENT_HEADER,
   FACTORY_CLIENT_VERSION: () => FACTORY_CLIENT_VERSION,
   FACTORY_PROTOCOL_VERSION: () => FACTORY_PROTOCOL_VERSION,
+  FactoryDroidMessageRole: () => FactoryDroidMessageRole,
   FactoryDroidMessageSchema: () => FactoryDroidMessageSchema,
   FeatureStatus: () => FeatureStatus,
   FeatureSuccessState: () => FeatureSuccessState,
   FeatureSuccessStateSchema: () => FeatureSuccessStateSchema,
+  ForkSessionRequestParamsSchema: () => ForkSessionRequestParamsSchema,
+  ForkSessionRequestSchema: () => ForkSessionRequestSchema,
+  ForkSessionResponseSchema: () => ForkSessionResponseSchema,
+  ForkSessionResultSchema: () => ForkSessionResultSchema,
+  GetContextStatsRequestParamsSchema: () => GetContextStatsRequestParamsSchema,
+  GetContextStatsRequestSchema: () => GetContextStatsRequestSchema,
+  GetContextStatsResponseSchema: () => GetContextStatsResponseSchema,
+  GetContextStatsResultSchema: () => GetContextStatsResultSchema,
+  GetRewindInfoRequestParamsSchema: () => GetRewindInfoRequestParamsSchema,
+  GetRewindInfoRequestSchema: () => GetRewindInfoRequestSchema,
+  GetRewindInfoResponseSchema: () => GetRewindInfoResponseSchema,
+  GetRewindInfoResultSchema: () => GetRewindInfoResultSchema,
   GitRepoInfoSchema: () => GitRepoInfoSchema,
   HandoffItemsDismissedEntrySchema: () => HandoffItemsDismissedEntrySchema,
   HandoffSchema: () => HandoffSchema,
@@ -117,6 +144,8 @@ __export(index_exports, {
   InterruptSessionResultSchema: () => InterruptSessionResultSchema,
   IssueSeverity: () => IssueSeverity,
   JSONRPC_VERSION: () => JSONRPC_VERSION,
+  JsonArraySchema: () => JsonArraySchema,
+  JsonObjectSchema: () => JsonObjectSchema,
   JsonRpcEnvelopeSchema: () => JsonRpcEnvelopeSchema,
   JsonRpcErrorCode: () => JsonRpcErrorCode,
   JsonRpcErrorSchema: () => JsonRpcErrorSchema,
@@ -127,6 +156,7 @@ __export(index_exports, {
   JsonRpcResponseFailureSchema: () => JsonRpcResponseFailureSchema,
   JsonRpcResponseSchema: () => JsonRpcResponseSchema,
   JsonRpcResponseSuccessSchema: () => JsonRpcResponseSuccessSchema,
+  JsonValueSchema: () => JsonValueSchema,
   KillWorkerSessionRequestParamsSchema: () => KillWorkerSessionRequestParamsSchema,
   KillWorkerSessionRequestSchema: () => KillWorkerSessionRequestSchema,
   KillWorkerSessionResponseSchema: () => KillWorkerSessionResponseSchema,
@@ -148,6 +178,10 @@ __export(index_exports, {
   ListSkillsRequestSchema: () => ListSkillsRequestSchema,
   ListSkillsResponseSchema: () => ListSkillsResponseSchema,
   ListSkillsResultSchema: () => ListSkillsResultSchema,
+  ListToolsRequestParamsSchema: () => ListToolsRequestParamsSchema,
+  ListToolsRequestSchema: () => ListToolsRequestSchema,
+  ListToolsResponseSchema: () => ListToolsResponseSchema,
+  ListToolsResultSchema: () => ListToolsResultSchema,
   LoadSessionRequestParamsSchema: () => LoadSessionRequestParamsSchema,
   LoadSessionRequestSchema: () => LoadSessionRequestSchema,
   LoadSessionResponseSchema: () => LoadSessionResponseSchema,
@@ -185,6 +219,8 @@ __export(index_exports, {
   MissionWorkerCompletedNotificationSchema: () => MissionWorkerCompletedNotificationSchema,
   MissionWorkerStartedNotificationSchema: () => MissionWorkerStartedNotificationSchema,
   ModelProvider: () => ModelProvider,
+  OutputFormatSchema: () => OutputFormatSchema,
+  OutputFormatType: () => OutputFormatType,
   PermissionResolvedNotificationSchema: () => PermissionResolvedNotificationSchema,
   ProcessExitError: () => ProcessExitError,
   ProcessTransport: () => ProcessTransport,
@@ -193,26 +229,40 @@ __export(index_exports, {
   ProposeMissionConfirmationDetailsSchema: () => ProposeMissionConfirmationDetailsSchema,
   ProtocolEngine: () => ProtocolEngine,
   ProtocolError: () => ProtocolError,
+  REWIND_TIMEOUT: () => REWIND_TIMEOUT,
   ReasoningEffort: () => ReasoningEffort,
   RedactedThinkingBlockSchema: () => RedactedThinkingBlockSchema,
   RemoveMcpServerRequestParamsSchema: () => RemoveMcpServerRequestParamsSchema,
   RemoveMcpServerRequestSchema: () => RemoveMcpServerRequestSchema,
   RemoveMcpServerResponseSchema: () => RemoveMcpServerResponseSchema,
   RemoveMcpServerResultSchema: () => RemoveMcpServerResultSchema,
+  RenameSessionRequestParamsSchema: () => RenameSessionRequestParamsSchema,
+  RenameSessionRequestSchema: () => RenameSessionRequestSchema,
+  RenameSessionResponseSchema: () => RenameSessionResponseSchema,
+  RenameSessionResultSchema: () => RenameSessionResultSchema,
   RequestPermissionRequestParamsSchema: () => RequestPermissionRequestParamsSchema,
   RequestPermissionRequestSchema: () => RequestPermissionRequestSchema,
   RequestPermissionResponseSchema: () => RequestPermissionResponseSchema,
   RequestPermissionResultSchema: () => RequestPermissionResultSchema,
+  RewindEvictedFileSchema: () => RewindEvictedFileSchema,
+  RewindFileCreationSchema: () => RewindFileCreationSchema,
+  RewindFileSnapshotSchema: () => RewindFileSnapshotSchema,
+  SDK_TAG: () => SDK_TAG,
+  SDK_VERSION: () => SDK_VERSION,
   SESSION_INIT_TIMEOUT: () => SESSION_INIT_TIMEOUT,
+  SdkMcpServer: () => SdkMcpServer,
   SessionError: () => SessionError,
+  SessionMetadataSchema: () => SessionMetadataSchema,
   SessionNotFoundError: () => SessionNotFoundError,
   SessionNotificationParamsSchema: () => SessionNotificationParamsSchema,
   SessionNotificationPayloadSchema: () => SessionNotificationPayloadSchema,
   SessionNotificationSchema: () => SessionNotificationSchema,
   SessionNotificationSchemaList: () => SessionNotificationSchemaList,
   SessionNotificationType: () => SessionNotificationType,
+  SessionSettingsFileSchema: () => SessionSettingsFileSchema,
   SessionSettingsSchema: () => SessionSettingsSchema,
   SessionSourceSchema: () => SessionSourceSchema,
+  SessionStartEventSchema: () => SessionStartEventSchema,
   SessionTagSchema: () => SessionTagSchema,
   SessionTitleUpdatedNotificationSchema: () => SessionTitleUpdatedNotificationSchema,
   SessionTokenUsageChangedNotificationSchema: () => SessionTokenUsageChangedNotificationSchema,
@@ -236,6 +286,7 @@ __export(index_exports, {
   SubmitMcpAuthCodeRequestSchema: () => SubmitMcpAuthCodeRequestSchema,
   SubmitMcpAuthCodeResponseSchema: () => SubmitMcpAuthCodeResponseSchema,
   SubmitMcpAuthCodeResultSchema: () => SubmitMcpAuthCodeResultSchema,
+  SuccessResultSchema: () => SuccessResultSchema,
   TestCaseSchema: () => TestCaseSchema,
   TestFileSchema: () => TestFileSchema,
   TestsSchema: () => TestsSchema,
@@ -261,6 +312,7 @@ __export(index_exports, {
   ToolProgressUpdateSchema: () => ToolProgressUpdateSchema,
   ToolResultBlockSchema: () => ToolResultBlockSchema,
   ToolResultNotificationSchema: () => ToolResultNotificationSchema,
+  ToolSelectionOverridesSchema: () => ToolSelectionOverridesSchema,
   ToolUseBlockSchema: () => ToolUseBlockSchema,
   ToolUseSchema: () => ToolUseSchema,
   TraceContextMetaSchema: () => TraceContextMetaSchema,
@@ -277,9 +329,13 @@ __export(index_exports, {
   WorkerStartedEntrySchema: () => WorkerStartedEntrySchema,
   WorkerStateInfoSchema: () => WorkerStateInfoSchema,
   convertNotificationToStreamMessage: () => convertNotificationToStreamMessage,
+  createSdkMcpServer: () => createSdkMcpServer,
   createSession: () => createSession,
+  listSessions: () => listSessions,
   query: () => query,
-  resumeSession: () => resumeSession
+  resumeSession: () => resumeSession,
+  run: () => run,
+  tool: () => tool
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -299,11 +355,18 @@ var DroidServerMethod = /* @__PURE__ */ ((DroidServerMethod2) => {
   DroidServerMethod2["REMOVE_MCP_SERVER"] = "droid.remove_mcp_server";
   DroidServerMethod2["LIST_MCP_REGISTRY"] = "droid.list_mcp_registry";
   DroidServerMethod2["LIST_MCP_TOOLS"] = "droid.list_mcp_tools";
+  DroidServerMethod2["LIST_TOOLS"] = "droid.list_tools";
   DroidServerMethod2["LIST_MCP_SERVERS"] = "droid.list_mcp_servers";
   DroidServerMethod2["TOGGLE_MCP_TOOL"] = "droid.toggle_mcp_tool";
   DroidServerMethod2["SUBMIT_MCP_AUTH_CODE"] = "droid.submit_mcp_auth_code";
   DroidServerMethod2["LIST_SKILLS"] = "droid.list_skills";
   DroidServerMethod2["SUBMIT_BUG_REPORT"] = "droid.submit_bug_report";
+  DroidServerMethod2["GET_REWIND_INFO"] = "droid.get_rewind_info";
+  DroidServerMethod2["EXECUTE_REWIND"] = "droid.execute_rewind";
+  DroidServerMethod2["COMPACT_SESSION"] = "droid.compact_session";
+  DroidServerMethod2["FORK_SESSION"] = "droid.fork_session";
+  DroidServerMethod2["RENAME_SESSION"] = "droid.rename_session";
+  DroidServerMethod2["GET_CONTEXT_STATS"] = "droid.get_context_stats";
   return DroidServerMethod2;
 })(DroidServerMethod || {});
 var DroidClientMethod = /* @__PURE__ */ ((DroidClientMethod2) => {
@@ -342,6 +405,10 @@ var ToolConfirmationOutcome = /* @__PURE__ */ ((ToolConfirmationOutcome3) => {
   ToolConfirmationOutcome3["ProceedAutoRunLow"] = "proceed_auto_run_low";
   ToolConfirmationOutcome3["ProceedAutoRunMedium"] = "proceed_auto_run_medium";
   ToolConfirmationOutcome3["ProceedAutoRunHigh"] = "proceed_auto_run_high";
+  ToolConfirmationOutcome3["ProceedNewSession"] = "proceed_new_session";
+  ToolConfirmationOutcome3["ProceedNewSessionLow"] = "proceed_new_session_low";
+  ToolConfirmationOutcome3["ProceedNewSessionMedium"] = "proceed_new_session_medium";
+  ToolConfirmationOutcome3["ProceedNewSessionHigh"] = "proceed_new_session_high";
   ToolConfirmationOutcome3["ProceedEdit"] = "proceed_edit";
   ToolConfirmationOutcome3["Cancel"] = "cancel";
   return ToolConfirmationOutcome3;
@@ -366,6 +433,11 @@ var DroidWorkingState = /* @__PURE__ */ ((DroidWorkingState2) => {
   DroidWorkingState2["CompactingConversation"] = "compacting_conversation";
   return DroidWorkingState2;
 })(DroidWorkingState || {});
+var ContextStatsAccuracy = /* @__PURE__ */ ((ContextStatsAccuracy2) => {
+  ContextStatsAccuracy2["Exact"] = "exact";
+  ContextStatsAccuracy2["Estimated"] = "estimated";
+  return ContextStatsAccuracy2;
+})(ContextStatsAccuracy || {});
 var DroidErrorType = /* @__PURE__ */ ((DroidErrorType2) => {
   DroidErrorType2["CONNECTION_ERROR"] = "ConnectionError";
   DroidErrorType2["PROTOCOL_ERROR"] = "ProtocolError";
@@ -537,19 +609,39 @@ var SkillLocation = /* @__PURE__ */ ((SkillLocation2) => {
 // src/schemas/constants.ts
 var JSONRPC_VERSION = "2.0";
 var LEGACY_FACTORY_API_VERSION = "1.0.0";
-var FACTORY_PROTOCOL_VERSION = "1.2.0";
+var FACTORY_PROTOCOL_VERSION = "1.3.0";
 var FACTORY_CLIENT_HEADER = "X-Factory-Client";
 var FACTORY_CLIENT_VERSION = "X-Client-Version";
 var DEFAULT_REQUEST_TIMEOUT = 3e4;
 var SESSION_INIT_TIMEOUT = 6e4;
 var MCP_AUTH_TIMEOUT = 3e5;
+var COMPACTION_TIMEOUT = 24e4;
+var REWIND_TIMEOUT = 6e4;
 
 // src/schemas/shared.ts
 var import_zod = require("zod");
+var JsonValueSchema = import_zod.z.lazy(
+  () => import_zod.z.union([
+    import_zod.z.string(),
+    import_zod.z.number(),
+    import_zod.z.boolean(),
+    import_zod.z.null(),
+    import_zod.z.array(JsonValueSchema),
+    import_zod.z.record(JsonValueSchema)
+  ])
+);
+var JsonObjectSchema = import_zod.z.record(JsonValueSchema);
+var JsonArraySchema = import_zod.z.array(JsonValueSchema);
 var TraceContextMetaSchema = import_zod.z.object({
   traceparent: import_zod.z.string().optional(),
   tracestate: import_zod.z.string().optional()
 });
+var ToolSelectionOverridesSchema = import_zod.z.object({
+  enabledToolIds: import_zod.z.array(import_zod.z.string()).optional(),
+  disabledToolIds: import_zod.z.array(import_zod.z.string()).optional()
+});
+var EmptyResultSchema = import_zod.z.object({}).passthrough();
+var SuccessResultSchema = import_zod.z.object({ success: import_zod.z.boolean() }).passthrough();
 var JsonRpcEnvelopeSchema = import_zod.z.object({
   jsonrpc: import_zod.z.literal(JSONRPC_VERSION),
   factoryApiVersion: import_zod.z.literal(LEGACY_FACTORY_API_VERSION),
@@ -559,18 +651,18 @@ var JsonRpcEnvelopeSchema = import_zod.z.object({
 var JsonRpcErrorSchema = import_zod.z.object({
   code: import_zod.z.nativeEnum(JsonRpcErrorCode),
   message: import_zod.z.string(),
-  data: import_zod.z.unknown().optional()
+  data: JsonValueSchema.optional()
 });
 var BaseRequestSchema = import_zod.z.object({
   type: import_zod.z.literal("request"),
   id: import_zod.z.string(),
   method: import_zod.z.string(),
-  params: import_zod.z.unknown().optional()
+  params: JsonValueSchema.optional()
 });
 var BaseResponseSuccessSchema = import_zod.z.object({
   type: import_zod.z.literal("response"),
   id: import_zod.z.string(),
-  result: import_zod.z.unknown()
+  result: JsonValueSchema
 });
 var BaseResponseFailureSchema = import_zod.z.object({
   type: import_zod.z.literal("response"),
@@ -580,7 +672,7 @@ var BaseResponseFailureSchema = import_zod.z.object({
 var BaseNotificationSchema = import_zod.z.object({
   type: import_zod.z.literal("notification"),
   method: import_zod.z.string(),
-  params: import_zod.z.unknown().optional()
+  params: JsonValueSchema.optional()
 });
 var JsonRpcRequestSchema = JsonRpcEnvelopeSchema.extend(
   BaseRequestSchema.shape
@@ -603,61 +695,128 @@ var JsonRpcMessageSchema = import_zod.z.discriminatedUnion("type", [
   JsonRpcEnvelopeSchema.extend({
     type: import_zod.z.literal("response"),
     id: import_zod.z.string().nullable(),
-    result: import_zod.z.unknown().optional(),
+    result: JsonValueSchema.optional(),
     error: JsonRpcErrorSchema.optional()
   }),
   JsonRpcNotificationSchema
 ]);
 
-// src/schemas/messages.ts
+// src/schemas/session-metadata.ts
+var import_zod6 = require("zod");
+
+// src/schemas/client.ts
+var import_zod5 = require("zod");
+
+// src/schemas/mcp.ts
 var import_zod2 = require("zod");
-var TextBlockSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("text"),
-  text: import_zod2.z.string(),
-  id: import_zod2.z.string().optional()
-}).passthrough();
-var Base64ImageSourceSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("base64"),
-  data: import_zod2.z.string(),
-  mediaType: import_zod2.z.enum(["image/jpeg", "image/png", "image/gif", "image/webp"])
-}).passthrough();
-var ImageBlockSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("image"),
-  source: Base64ImageSourceSchema,
-  id: import_zod2.z.string().optional()
-}).passthrough();
-var ThinkingBlockSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("thinking"),
-  signature: import_zod2.z.string(),
-  thinking: import_zod2.z.string(),
-  id: import_zod2.z.string().optional(),
-  signatureProvider: import_zod2.z.string().optional()
-}).passthrough();
-var RedactedThinkingBlockSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("redacted_thinking"),
-  data: import_zod2.z.string(),
-  id: import_zod2.z.string().optional()
-}).passthrough();
-var ToolUseBlockSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("tool_use"),
-  id: import_zod2.z.string(),
-  input: import_zod2.z.record(import_zod2.z.unknown()),
+var McpStdioServerConfigFieldsSchema = import_zod2.z.object({
+  command: import_zod2.z.string().optional(),
+  args: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var McpHttpServerConfigFieldsSchema = import_zod2.z.object({
+  url: import_zod2.z.string().optional()
+});
+var McpSseServerConfigFieldsSchema = import_zod2.z.object({
+  url: import_zod2.z.string(),
+  headers: import_zod2.z.record(import_zod2.z.string()).optional()
+});
+var McpServerStatusInfoSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  status: import_zod2.z.nativeEnum(McpServerStatus),
+  source: import_zod2.z.nativeEnum(SettingsLevel),
+  isManaged: import_zod2.z.boolean(),
+  error: import_zod2.z.string().optional(),
+  toolCount: import_zod2.z.number().optional(),
+  serverType: import_zod2.z.nativeEnum(McpServerType).optional(),
+  hasAuthTokens: import_zod2.z.boolean().optional()
+}).passthrough();
+var McpStatusSummarySchema = import_zod2.z.object({
+  total: import_zod2.z.number(),
+  connected: import_zod2.z.number(),
+  connecting: import_zod2.z.number(),
+  failed: import_zod2.z.number(),
+  disabled: import_zod2.z.number().optional()
+}).passthrough();
+var McpRegistryServerSchema = import_zod2.z.object({
   name: import_zod2.z.string(),
-  thoughtSignature: import_zod2.z.string().optional()
+  description: import_zod2.z.string(),
+  type: import_zod2.z.nativeEnum(McpServerType),
+  // Stdio config fields
+  command: import_zod2.z.string().optional(),
+  args: import_zod2.z.array(import_zod2.z.string()).optional(),
+  // HTTP config fields
+  url: import_zod2.z.string().optional(),
+  // Additional metadata
+  note: import_zod2.z.string().optional(),
+  logoUrl: import_zod2.z.string().optional()
+}).passthrough();
+var McpToolInputSchemaSchema = import_zod2.z.object({
+  type: import_zod2.z.string().optional(),
+  properties: JsonObjectSchema.optional(),
+  required: import_zod2.z.array(import_zod2.z.string()).optional()
+}).passthrough();
+var McpToolInfoSchema = import_zod2.z.object({
+  serverName: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  description: import_zod2.z.string().optional(),
+  isEnabled: import_zod2.z.boolean(),
+  isReadOnly: import_zod2.z.boolean().optional(),
+  inputSchema: McpToolInputSchemaSchema.optional()
+}).passthrough();
+var ToolConfirmationListItemSchema = import_zod2.z.object({
+  label: import_zod2.z.string(),
+  value: import_zod2.z.nativeEnum(ToolConfirmationOutcome)
+}).passthrough();
+
+// src/schemas/messages.ts
+var import_zod3 = require("zod");
+var TextBlockSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("text"),
+  text: import_zod3.z.string(),
+  id: import_zod3.z.string().optional()
+}).passthrough();
+var Base64ImageSourceSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("base64"),
+  data: import_zod3.z.string(),
+  mediaType: import_zod3.z.enum(["image/jpeg", "image/png", "image/gif", "image/webp"])
+}).passthrough();
+var ImageBlockSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("image"),
+  source: Base64ImageSourceSchema,
+  id: import_zod3.z.string().optional()
+}).passthrough();
+var ThinkingBlockSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("thinking"),
+  signature: import_zod3.z.string(),
+  thinking: import_zod3.z.string(),
+  id: import_zod3.z.string().optional(),
+  signatureProvider: import_zod3.z.string().optional()
 }).passthrough();
-var ToolResultBlockSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("tool_result"),
-  toolUseId: import_zod2.z.string(),
-  content: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.array(import_zod2.z.unknown())]).optional(),
-  isError: import_zod2.z.boolean().optional(),
-  id: import_zod2.z.string().optional()
+var RedactedThinkingBlockSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("redacted_thinking"),
+  data: import_zod3.z.string(),
+  id: import_zod3.z.string().optional()
 }).passthrough();
-var DocumentBlockSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("document"),
-  source: import_zod2.z.record(import_zod2.z.unknown()),
-  id: import_zod2.z.string().optional()
+var ToolUseBlockSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("tool_use"),
+  id: import_zod3.z.string(),
+  input: JsonObjectSchema,
+  name: import_zod3.z.string(),
+  thoughtSignature: import_zod3.z.string().optional()
+}).passthrough();
+var ToolResultBlockSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("tool_result"),
+  toolUseId: import_zod3.z.string(),
+  content: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.array(JsonValueSchema)]).optional(),
+  isError: import_zod3.z.boolean().optional(),
+  id: import_zod3.z.string().optional()
 }).passthrough();
-var ContentBlockSchema = import_zod2.z.discriminatedUnion("type", [
+var DocumentBlockSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("document"),
+  source: JsonObjectSchema,
+  id: import_zod3.z.string().optional()
+}).passthrough();
+var ContentBlockSchema = import_zod3.z.discriminatedUnion("type", [
   TextBlockSchema,
   ImageBlockSchema,
   ThinkingBlockSchema,
@@ -666,83 +825,33 @@ var ContentBlockSchema = import_zod2.z.discriminatedUnion("type", [
   ToolResultBlockSchema,
   DocumentBlockSchema
 ]);
-var FactoryDroidMessageSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  role: import_zod2.z.enum(["user", "assistant", "tool", "system"]),
-  content: import_zod2.z.array(ContentBlockSchema),
-  createdAt: import_zod2.z.number(),
-  updatedAt: import_zod2.z.number(),
-  parentId: import_zod2.z.string().optional(),
-  visibility: import_zod2.z.enum(["both", "llm_only", "user_only"]).optional(),
-  isError: import_zod2.z.boolean().optional()
-}).passthrough();
-var DocumentSourceSchema = import_zod2.z.object({
-  type: import_zod2.z.string(),
-  mediaType: import_zod2.z.string(),
-  data: import_zod2.z.string(),
-  name: import_zod2.z.string().optional(),
-  mime: import_zod2.z.string().optional()
-}).strict();
-
-// src/schemas/mcp.ts
-var import_zod3 = require("zod");
-var McpStdioServerConfigFieldsSchema = import_zod3.z.object({
-  command: import_zod3.z.string().optional(),
-  args: import_zod3.z.array(import_zod3.z.string()).optional()
-});
-var McpHttpServerConfigFieldsSchema = import_zod3.z.object({
-  url: import_zod3.z.string().optional()
-});
-var McpSseServerConfigFieldsSchema = import_zod3.z.object({
-  url: import_zod3.z.string(),
-  headers: import_zod3.z.record(import_zod3.z.string()).optional()
-});
-var McpServerStatusInfoSchema = import_zod3.z.object({
-  name: import_zod3.z.string(),
-  status: import_zod3.z.nativeEnum(McpServerStatus),
-  source: import_zod3.z.nativeEnum(SettingsLevel),
-  isManaged: import_zod3.z.boolean(),
-  error: import_zod3.z.string().optional(),
-  toolCount: import_zod3.z.number().optional(),
-  serverType: import_zod3.z.nativeEnum(McpServerType).optional(),
-  hasAuthTokens: import_zod3.z.boolean().optional()
-}).passthrough();
-var McpStatusSummarySchema = import_zod3.z.object({
-  total: import_zod3.z.number(),
-  connected: import_zod3.z.number(),
-  connecting: import_zod3.z.number(),
-  failed: import_zod3.z.number(),
-  disabled: import_zod3.z.number().optional()
-}).passthrough();
-var McpRegistryServerSchema = import_zod3.z.object({
-  name: import_zod3.z.string(),
-  description: import_zod3.z.string(),
-  type: import_zod3.z.nativeEnum(McpServerType),
-  // Stdio config fields
-  command: import_zod3.z.string().optional(),
-  args: import_zod3.z.array(import_zod3.z.string()).optional(),
-  // HTTP config fields
-  url: import_zod3.z.string().optional(),
-  // Additional metadata
-  note: import_zod3.z.string().optional(),
-  logoUrl: import_zod3.z.string().optional()
-}).passthrough();
-var McpToolInputSchemaSchema = import_zod3.z.object({
-  type: import_zod3.z.string().optional(),
-  properties: import_zod3.z.record(import_zod3.z.unknown()).optional(),
-  required: import_zod3.z.array(import_zod3.z.string()).optional()
-}).passthrough();
-var McpToolInfoSchema = import_zod3.z.object({
-  serverName: import_zod3.z.string(),
-  name: import_zod3.z.string(),
-  description: import_zod3.z.string().optional(),
-  isEnabled: import_zod3.z.boolean(),
-  isReadOnly: import_zod3.z.boolean().optional(),
-  inputSchema: McpToolInputSchemaSchema.optional()
+var FactoryDroidMessageRole = {
+  User: "user",
+  Assistant: "assistant",
+  Tool: "tool",
+  System: "system"
+};
+var FactoryDroidMessageSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  role: import_zod3.z.enum([
+    FactoryDroidMessageRole.User,
+    FactoryDroidMessageRole.Assistant,
+    FactoryDroidMessageRole.Tool,
+    FactoryDroidMessageRole.System
+  ]),
+  content: import_zod3.z.array(ContentBlockSchema),
+  createdAt: import_zod3.z.number(),
+  updatedAt: import_zod3.z.number(),
+  parentId: import_zod3.z.string().optional(),
+  visibility: import_zod3.z.enum(["both", "llm_only", "user_only"]).optional(),
+  isError: import_zod3.z.boolean().optional()
 }).passthrough();
-var ToolConfirmationListItemSchema = import_zod3.z.object({
-  label: import_zod3.z.string(),
-  value: import_zod3.z.nativeEnum(ToolConfirmationOutcome)
+var DocumentSourceSchema = import_zod3.z.object({
+  type: import_zod3.z.string(),
+  mediaType: import_zod3.z.string(),
+  data: import_zod3.z.string(),
+  name: import_zod3.z.string().optional(),
+  mime: import_zod3.z.string().optional()
 }).passthrough();
 
 // src/schemas/mission.ts
@@ -893,7 +1002,12 @@ var ProgressLogEntrySchema = import_zod4.z.discriminatedUnion("type", [
 ]);
 
 // src/schemas/client.ts
-var import_zod5 = require("zod");
+var SessionModeRequestFieldsShape = {
+  modelId: import_zod5.z.string().optional(),
+  autonomyMode: import_zod5.z.nativeEnum(AutonomyMode).optional(),
+  interactionMode: import_zod5.z.nativeEnum(DroidInteractionMode).optional(),
+  autonomyLevel: import_zod5.z.nativeEnum(AutonomyLevel).optional()
+};
 var SessionTagSchema = import_zod5.z.object({
   name: import_zod5.z.string(),
   metadata: import_zod5.z.record(import_zod5.z.string()).optional()
@@ -935,7 +1049,8 @@ var SessionSettingsSchema = import_zod5.z.object({
   interactionMode: import_zod5.z.nativeEnum(DroidInteractionMode).optional().catch(void 0),
   autonomyLevel: import_zod5.z.nativeEnum(AutonomyLevel).optional().catch(void 0),
   specModeModelId: import_zod5.z.string().optional(),
-  specModeReasoningEffort: import_zod5.z.nativeEnum(ReasoningEffort).optional()
+  specModeReasoningEffort: import_zod5.z.nativeEnum(ReasoningEffort).optional(),
+  ...ToolSelectionOverridesSchema.shape
 }).passthrough();
 var GitRepoInfoSchema = import_zod5.z.object({
   owner: import_zod5.z.string().optional(),
@@ -955,7 +1070,7 @@ var AvailableModelConfigSchema = import_zod5.z.object({
   tier: import_zod5.z.string().optional(),
   tokenMultiplier: import_zod5.z.number().optional(),
   promoLabel: import_zod5.z.string().optional(),
-  featureFlag: import_zod5.z.record(import_zod5.z.unknown()).optional(),
+  featureFlag: JsonObjectSchema.optional(),
   usesUSBasedInference: import_zod5.z.boolean().optional()
 }).passthrough();
 var TokenUsageSchema = import_zod5.z.object({
@@ -965,6 +1080,13 @@ var TokenUsageSchema = import_zod5.z.object({
   cacheReadTokens: import_zod5.z.number(),
   thinkingTokens: import_zod5.z.number()
 }).passthrough();
+var ContextStatsSchema = import_zod5.z.object({
+  used: import_zod5.z.number(),
+  remaining: import_zod5.z.number(),
+  limit: import_zod5.z.number(),
+  accuracy: import_zod5.z.nativeEnum(ContextStatsAccuracy),
+  updatedAt: import_zod5.z.string()
+}).passthrough();
 var WorkerStateInfoSchema = import_zod5.z.object({
   startedAt: import_zod5.z.string(),
   completedAt: import_zod5.z.string().optional(),
@@ -992,17 +1114,14 @@ var InitializeSessionRequestParamsSchema = import_zod5.z.object({
   workspaceId: import_zod5.z.string().optional(),
   sessionId: import_zod5.z.string().optional(),
   mcpServers: import_zod5.z.array(McpServerConfigSchema).optional(),
-  autonomyMode: import_zod5.z.nativeEnum(AutonomyMode).optional(),
-  interactionMode: import_zod5.z.nativeEnum(DroidInteractionMode).optional().catch(void 0),
-  autonomyLevel: import_zod5.z.nativeEnum(AutonomyLevel).optional().catch(void 0),
-  modelId: import_zod5.z.string().optional(),
+  ...SessionModeRequestFieldsShape,
   reasoningEffort: import_zod5.z.nativeEnum(ReasoningEffort).optional(),
   specModeModelId: import_zod5.z.string().optional(),
   specModeReasoningEffort: import_zod5.z.nativeEnum(ReasoningEffort).optional(),
   decompSessionType: import_zod5.z.nativeEnum(DecompSessionType).optional(),
   decompMissionId: import_zod5.z.string().optional(),
   skipPermissionsUnsafe: import_zod5.z.boolean().optional(),
-  enabledToolIds: import_zod5.z.array(import_zod5.z.string()).optional(),
+  ...ToolSelectionOverridesSchema.shape,
   sessionLocation: import_zod5.z.string().optional(),
   sessionSource: SessionSourceSchema.optional(),
   tags: import_zod5.z.array(SessionTagSchema).optional(),
@@ -1013,24 +1132,30 @@ var LoadSessionRequestParamsSchema = import_zod5.z.object({
   mcpServers: import_zod5.z.array(McpServerConfigSchema).optional(),
   mcpOAuthCallbackUri: import_zod5.z.string().optional()
 }).strict();
+var OutputFormatType = {
+  JsonSchema: "json_schema"
+};
+var OutputFormatSchema = import_zod5.z.object({
+  type: import_zod5.z.literal(OutputFormatType.JsonSchema),
+  schema: JsonObjectSchema
+}).strict();
 var AddUserMessageRequestParamsSchema = import_zod5.z.object({
   messageId: import_zod5.z.string().optional(),
   text: import_zod5.z.string(),
   images: import_zod5.z.array(Base64ImageSourceSchema).optional(),
-  files: import_zod5.z.array(DocumentSourceSchema).optional()
+  files: import_zod5.z.array(DocumentSourceSchema).optional(),
+  outputFormat: OutputFormatSchema.optional()
 }).strict();
 var InterruptSessionRequestParamsSchema = import_zod5.z.object({}).strict();
 var KillWorkerSessionRequestParamsSchema = import_zod5.z.object({
   workerSessionId: import_zod5.z.string()
 }).strict();
 var UpdateSessionSettingsRequestParamsSchema = import_zod5.z.object({
-  modelId: import_zod5.z.string().optional(),
+  ...SessionModeRequestFieldsShape,
   reasoningEffort: import_zod5.z.nativeEnum(ReasoningEffort).optional(),
-  autonomyMode: import_zod5.z.nativeEnum(AutonomyMode).optional(),
-  interactionMode: import_zod5.z.nativeEnum(DroidInteractionMode).optional().catch(void 0),
-  autonomyLevel: import_zod5.z.nativeEnum(AutonomyLevel).optional().catch(void 0),
   specModeModelId: import_zod5.z.string().nullable().optional(),
-  specModeReasoningEffort: import_zod5.z.nativeEnum(ReasoningEffort).nullable().optional()
+  specModeReasoningEffort: import_zod5.z.nativeEnum(ReasoningEffort).nullable().optional(),
+  ...ToolSelectionOverridesSchema.shape
 }).strict();
 var ToggleMcpServerRequestParamsSchema = import_zod5.z.object({
   serverName: import_zod5.z.string(),
@@ -1066,6 +1191,22 @@ var RemoveMcpServerRequestParamsSchema = import_zod5.z.object({
 }).strict();
 var ListMcpRegistryRequestParamsSchema = import_zod5.z.object({}).strict();
 var ListMcpToolsRequestParamsSchema = import_zod5.z.object({}).strict();
+var ExecToolInfoSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  llmId: import_zod5.z.string(),
+  displayName: import_zod5.z.string(),
+  description: import_zod5.z.string(),
+  category: import_zod5.z.enum(["read", "edit", "execute", "other"]),
+  defaultAllowed: import_zod5.z.boolean(),
+  currentlyAllowed: import_zod5.z.boolean()
+}).passthrough();
+var ListToolsRequestParamsSchema = import_zod5.z.object({
+  ...SessionModeRequestFieldsShape,
+  specModeModelId: import_zod5.z.string().nullable().optional(),
+  skipPermissionsUnsafe: import_zod5.z.boolean().optional(),
+  ...ToolSelectionOverridesSchema.shape,
+  depth: import_zod5.z.number().int().min(0).optional()
+}).strict();
 var ListMcpServersRequestParamsSchema = import_zod5.z.object({}).strict();
 var ToggleMcpToolRequestParamsSchema = import_zod5.z.object({
   serverName: import_zod5.z.string(),
@@ -1077,6 +1218,35 @@ var SubmitBugReportRequestParamsSchema = import_zod5.z.object({
   userComment: import_zod5.z.string(),
   clientLogs: import_zod5.z.string().optional()
 }).strict();
+var RewindFileSnapshotSchema = import_zod5.z.object({
+  filePath: import_zod5.z.string(),
+  contentHash: import_zod5.z.string(),
+  size: import_zod5.z.number()
+}).passthrough();
+var RewindFileCreationSchema = import_zod5.z.object({
+  filePath: import_zod5.z.string()
+}).passthrough();
+var RewindEvictedFileSchema = import_zod5.z.object({
+  filePath: import_zod5.z.string(),
+  reason: import_zod5.z.string()
+}).passthrough();
+var GetRewindInfoRequestParamsSchema = import_zod5.z.object({
+  messageId: import_zod5.z.string()
+}).passthrough();
+var ExecuteRewindRequestParamsSchema = import_zod5.z.object({
+  messageId: import_zod5.z.string(),
+  filesToRestore: import_zod5.z.array(RewindFileSnapshotSchema),
+  filesToDelete: import_zod5.z.array(RewindFileCreationSchema),
+  forkTitle: import_zod5.z.string()
+}).passthrough();
+var CompactSessionRequestParamsSchema = import_zod5.z.object({
+  customInstructions: import_zod5.z.string().optional()
+}).passthrough();
+var RenameSessionRequestParamsSchema = import_zod5.z.object({
+  title: import_zod5.z.string()
+}).passthrough();
+var ForkSessionRequestParamsSchema = import_zod5.z.object({}).passthrough();
+var GetContextStatsRequestParamsSchema = import_zod5.z.object({}).passthrough();
 var InitializeSessionRequestSchema = JsonRpcRequestSchema.extend({
   method: import_zod5.z.literal("droid.initialize_session" /* INITIALIZE_SESSION */),
   params: InitializeSessionRequestParamsSchema
@@ -1137,6 +1307,10 @@ var ListMcpToolsRequestSchema = JsonRpcRequestSchema.extend({
   method: import_zod5.z.literal("droid.list_mcp_tools" /* LIST_MCP_TOOLS */),
   params: ListMcpToolsRequestParamsSchema
 });
+var ListToolsRequestSchema = JsonRpcRequestSchema.extend({
+  method: import_zod5.z.literal("droid.list_tools" /* LIST_TOOLS */),
+  params: ListToolsRequestParamsSchema
+});
 var ListMcpServersRequestSchema = JsonRpcRequestSchema.extend({
   method: import_zod5.z.literal("droid.list_mcp_servers" /* LIST_MCP_SERVERS */),
   params: ListMcpServersRequestParamsSchema
@@ -1153,6 +1327,30 @@ var SubmitBugReportRequestSchema = JsonRpcRequestSchema.extend({
   method: import_zod5.z.literal("droid.submit_bug_report" /* SUBMIT_BUG_REPORT */),
   params: SubmitBugReportRequestParamsSchema
 });
+var GetRewindInfoRequestSchema = JsonRpcRequestSchema.extend({
+  method: import_zod5.z.literal("droid.get_rewind_info" /* GET_REWIND_INFO */),
+  params: GetRewindInfoRequestParamsSchema
+});
+var ExecuteRewindRequestSchema = JsonRpcRequestSchema.extend({
+  method: import_zod5.z.literal("droid.execute_rewind" /* EXECUTE_REWIND */),
+  params: ExecuteRewindRequestParamsSchema
+});
+var CompactSessionRequestSchema = JsonRpcRequestSchema.extend({
+  method: import_zod5.z.literal("droid.compact_session" /* COMPACT_SESSION */),
+  params: CompactSessionRequestParamsSchema
+});
+var ForkSessionRequestSchema = JsonRpcRequestSchema.extend({
+  method: import_zod5.z.literal("droid.fork_session" /* FORK_SESSION */),
+  params: ForkSessionRequestParamsSchema
+});
+var GetContextStatsRequestSchema = JsonRpcRequestSchema.extend({
+  method: import_zod5.z.literal("droid.get_context_stats" /* GET_CONTEXT_STATS */),
+  params: GetContextStatsRequestParamsSchema
+});
+var RenameSessionRequestSchema = JsonRpcRequestSchema.extend({
+  method: import_zod5.z.literal("droid.rename_session" /* RENAME_SESSION */),
+  params: RenameSessionRequestParamsSchema
+});
 var ClientRequestSchema = import_zod5.z.discriminatedUnion("method", [
   InitializeSessionRequestSchema,
   LoadSessionRequestSchema,
@@ -1169,10 +1367,17 @@ var ClientRequestSchema = import_zod5.z.discriminatedUnion("method", [
   RemoveMcpServerRequestSchema,
   ListMcpRegistryRequestSchema,
   ListMcpToolsRequestSchema,
+  ListToolsRequestSchema,
   ListMcpServersRequestSchema,
   ToggleMcpToolRequestSchema,
   ListSkillsRequestSchema,
-  SubmitBugReportRequestSchema
+  SubmitBugReportRequestSchema,
+  GetRewindInfoRequestSchema,
+  ExecuteRewindRequestSchema,
+  CompactSessionRequestSchema,
+  ForkSessionRequestSchema,
+  GetContextStatsRequestSchema,
+  RenameSessionRequestSchema
 ]);
 var MissionSnapshotSchema = import_zod5.z.object({
   state: import_zod5.z.nativeEnum(MissionState),
@@ -1185,20 +1390,20 @@ var MissionSnapshotSchema = import_zod5.z.object({
 }).passthrough();
 var InitializeSessionResultSchema = import_zod5.z.object({
   sessionId: import_zod5.z.string(),
-  session: import_zod5.z.record(import_zod5.z.unknown()),
+  session: JsonObjectSchema,
   mcpServers: import_zod5.z.array(McpServerConfigSchema).optional(),
   settings: SessionSettingsSchema,
   gitRepo: GitRepoInfoSchema.optional(),
   availableModels: import_zod5.z.array(AvailableModelConfigSchema).optional()
 }).passthrough();
 var LoadSessionResultSchema = import_zod5.z.object({
-  session: import_zod5.z.record(import_zod5.z.unknown()),
+  session: JsonObjectSchema,
   mcpServers: import_zod5.z.array(McpServerConfigSchema).optional(),
-  pendingPermissions: import_zod5.z.array(import_zod5.z.record(import_zod5.z.unknown())).optional(),
-  pendingAskUserRequests: import_zod5.z.array(import_zod5.z.record(import_zod5.z.unknown())).optional(),
+  pendingPermissions: import_zod5.z.array(JsonObjectSchema).optional(),
+  pendingAskUserRequests: import_zod5.z.array(JsonObjectSchema).optional(),
   settings: SessionSettingsSchema,
   isAgentLoopInProgress: import_zod5.z.boolean().optional(),
-  queuedMessages: import_zod5.z.array(import_zod5.z.record(import_zod5.z.unknown())).optional(),
+  queuedMessages: import_zod5.z.array(JsonObjectSchema).optional(),
   gitRepo: GitRepoInfoSchema.optional(),
   cwd: import_zod5.z.string().optional(),
   callingSessionId: import_zod5.z.string().optional(),
@@ -1208,26 +1413,48 @@ var LoadSessionResultSchema = import_zod5.z.object({
   mission: MissionSnapshotSchema.optional(),
   decompSessionType: import_zod5.z.nativeEnum(DecompSessionType).optional()
 }).passthrough();
-var AddUserMessageResultSchema = import_zod5.z.object({}).passthrough();
-var InterruptSessionResultSchema = import_zod5.z.object({}).passthrough();
-var KillWorkerSessionResultSchema = import_zod5.z.object({}).passthrough();
-var UpdateSessionSettingsResultSchema = import_zod5.z.object({}).passthrough();
-var ToggleMcpServerResultSchema = import_zod5.z.object({ success: import_zod5.z.boolean() }).passthrough();
-var AuthenticateMcpServerResultSchema = import_zod5.z.object({ success: import_zod5.z.boolean() }).passthrough();
-var CancelMcpAuthResultSchema = import_zod5.z.object({ success: import_zod5.z.boolean() }).passthrough();
-var ClearMcpAuthResultSchema = import_zod5.z.object({ success: import_zod5.z.boolean() }).passthrough();
-var SubmitMcpAuthCodeResultSchema = import_zod5.z.object({ success: import_zod5.z.boolean() }).passthrough();
-var AddMcpServerResultSchema = import_zod5.z.object({ success: import_zod5.z.boolean() }).passthrough();
-var RemoveMcpServerResultSchema = import_zod5.z.object({ success: import_zod5.z.boolean() }).passthrough();
+var AddUserMessageResultSchema = EmptyResultSchema;
+var InterruptSessionResultSchema = EmptyResultSchema;
+var KillWorkerSessionResultSchema = EmptyResultSchema;
+var UpdateSessionSettingsResultSchema = EmptyResultSchema;
+var ToggleMcpServerResultSchema = SuccessResultSchema;
+var AuthenticateMcpServerResultSchema = SuccessResultSchema;
+var CancelMcpAuthResultSchema = SuccessResultSchema;
+var ClearMcpAuthResultSchema = SuccessResultSchema;
+var SubmitMcpAuthCodeResultSchema = SuccessResultSchema;
+var AddMcpServerResultSchema = SuccessResultSchema;
+var RemoveMcpServerResultSchema = SuccessResultSchema;
 var ListMcpRegistryResultSchema = import_zod5.z.object({ servers: import_zod5.z.array(McpRegistryServerSchema) }).passthrough();
 var ListMcpToolsResultSchema = import_zod5.z.object({ tools: import_zod5.z.array(McpToolInfoSchema) }).passthrough();
+var ListToolsResultSchema = import_zod5.z.object({ tools: import_zod5.z.array(ExecToolInfoSchema) }).passthrough();
 var ListMcpServersResultSchema = import_zod5.z.object({
   servers: import_zod5.z.array(McpServerStatusInfoSchema),
   summary: McpStatusSummarySchema
 }).passthrough();
-var ToggleMcpToolResultSchema = import_zod5.z.object({ success: import_zod5.z.boolean() }).passthrough();
+var ToggleMcpToolResultSchema = SuccessResultSchema;
 var ListSkillsResultSchema = import_zod5.z.object({ skills: import_zod5.z.array(SkillInfoSchema) }).passthrough();
 var SubmitBugReportResultSchema = import_zod5.z.object({ bugReportId: import_zod5.z.string() }).passthrough();
+var GetRewindInfoResultSchema = import_zod5.z.object({
+  availableFiles: import_zod5.z.array(RewindFileSnapshotSchema),
+  createdFiles: import_zod5.z.array(RewindFileCreationSchema),
+  evictedFiles: import_zod5.z.array(RewindEvictedFileSchema)
+}).passthrough();
+var ExecuteRewindResultSchema = import_zod5.z.object({
+  newSessionId: import_zod5.z.string(),
+  restoredCount: import_zod5.z.number(),
+  deletedCount: import_zod5.z.number(),
+  failedRestoreCount: import_zod5.z.number(),
+  failedDeleteCount: import_zod5.z.number()
+}).passthrough();
+var CompactSessionResultSchema = import_zod5.z.object({
+  newSessionId: import_zod5.z.string(),
+  removedCount: import_zod5.z.number()
+}).passthrough();
+var ForkSessionResultSchema = import_zod5.z.object({
+  newSessionId: import_zod5.z.string()
+}).passthrough();
+var GetContextStatsResultSchema = ContextStatsSchema;
+var RenameSessionResultSchema = SuccessResultSchema;
 var InitializeSessionResponseSchema = import_zod5.z.union([
   JsonRpcResponseSuccessSchema.extend({
     result: InitializeSessionResultSchema
@@ -1305,6 +1532,10 @@ 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
@@ -1321,145 +1552,194 @@ 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
+]);
 
-// src/schemas/server.ts
-var import_zod6 = require("zod");
-var ToolUseSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("tool_use"),
+// src/schemas/session-metadata.ts
+var SessionMetadataSchema = import_zod6.z.object({
   id: import_zod6.z.string(),
-  input: import_zod6.z.record(import_zod6.z.unknown()),
-  name: import_zod6.z.string(),
-  thoughtSignature: import_zod6.z.string().optional()
-}).passthrough();
-var ErrorDetailSchema = import_zod6.z.object({
-  name: import_zod6.z.string(),
-  message: import_zod6.z.string()
-}).passthrough();
-var ToolProgressUpdateSchema = import_zod6.z.object({
-  type: import_zod6.z.enum(["tool_call", "tool_result", "error", "status", "message"]),
-  toolName: import_zod6.z.string().optional(),
-  status: import_zod6.z.string().optional(),
-  details: import_zod6.z.string().optional(),
-  text: import_zod6.z.string().optional(),
-  error: import_zod6.z.string().optional(),
-  timestamp: import_zod6.z.number().optional(),
-  parameters: import_zod6.z.record(import_zod6.z.unknown()).optional(),
-  valueSnippet: import_zod6.z.string().optional(),
-  subagentSessionId: import_zod6.z.string().optional()
-}).passthrough();
-var SettingsUpdatedPayloadSchema = import_zod6.z.object({
-  autonomyMode: import_zod6.z.nativeEnum(AutonomyMode).optional(),
-  interactionMode: import_zod6.z.nativeEnum(DroidInteractionMode).optional().catch(void 0),
-  autonomyLevel: import_zod6.z.nativeEnum(AutonomyLevel).optional().catch(void 0),
-  modelId: import_zod6.z.string().optional(),
-  reasoningEffort: import_zod6.z.nativeEnum(ReasoningEffort).optional(),
-  specModeModelId: import_zod6.z.string().optional(),
-  specModeReasoningEffort: import_zod6.z.nativeEnum(ReasoningEffort).optional()
-}).passthrough();
-var ToolResultNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("tool_result" /* TOOL_RESULT */),
-  messageId: import_zod6.z.string(),
-  toolUseId: import_zod6.z.string(),
-  content: import_zod6.z.unknown().optional(),
-  isError: import_zod6.z.boolean().optional(),
-  id: import_zod6.z.string().optional()
-}).passthrough();
-var ToolProgressUpdateNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("tool_progress_update" /* TOOL_PROGRESS_UPDATE */),
-  toolUseId: import_zod6.z.string(),
-  toolName: import_zod6.z.string(),
+  title: import_zod6.z.string(),
+  sessionTitle: import_zod6.z.string().optional(),
+  owner: import_zod6.z.string(),
+  messageCount: import_zod6.z.number(),
+  modifiedTime: import_zod6.z.date(),
+  createdTime: import_zod6.z.date(),
+  isFavorite: import_zod6.z.boolean().optional(),
+  cwd: import_zod6.z.string().optional(),
+  decompSessionType: import_zod6.z.nativeEnum(DecompSessionType).optional(),
+  decompMissionId: import_zod6.z.string().optional()
+}).passthrough();
+var SessionStartEventSchema = import_zod6.z.object({
+  type: import_zod6.z.literal("session_start"),
+  sessionId: import_zod6.z.string().optional(),
+  title: import_zod6.z.string().optional(),
+  sessionTitle: import_zod6.z.string().optional(),
+  owner: import_zod6.z.string().optional(),
+  cwd: import_zod6.z.string().optional(),
+  decompSessionType: import_zod6.z.nativeEnum(DecompSessionType).optional().catch(void 0),
+  decompMissionId: import_zod6.z.string().optional()
+}).passthrough();
+var SessionSettingsFileSchema = import_zod6.z.object({
+  archivedAt: import_zod6.z.string().optional(),
+  tags: import_zod6.z.array(SessionTagSchema).optional()
+}).passthrough();
+
+// src/schemas/server.ts
+var import_zod7 = require("zod");
+var ToolUseBlockSchema2 = ToolUseBlockSchema;
+var ToolUseSchema = ToolUseBlockSchema2;
+var ErrorDetailSchema = import_zod7.z.object({
+  name: import_zod7.z.string(),
+  message: import_zod7.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(),
+  parameters: JsonObjectSchema.optional(),
+  valueSnippet: import_zod7.z.string().optional(),
+  subagentSessionId: import_zod7.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(),
+  ...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(),
+  content: JsonValueSchema.optional(),
+  isError: import_zod7.z.boolean().optional(),
+  id: import_zod7.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(),
   update: ToolProgressUpdateSchema
 }).passthrough();
-var CreateMessageNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("create_message" /* CREATE_MESSAGE */),
+var CreateMessageNotificationSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("create_message" /* CREATE_MESSAGE */),
   message: FactoryDroidMessageSchema,
-  parentId: import_zod6.z.string().optional(),
-  requestId: import_zod6.z.string().optional()
-}).passthrough();
-var ErrorNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("error" /* ERROR */),
-  message: import_zod6.z.string(),
-  errorType: import_zod6.z.nativeEnum(DroidErrorType),
-  timestamp: import_zod6.z.string(),
+  parentId: import_zod7.z.string().optional(),
+  requestId: import_zod7.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(),
   error: ErrorDetailSchema.optional()
 }).passthrough();
-var DroidWorkingStateChangedNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */),
-  newState: import_zod6.z.nativeEnum(DroidWorkingState)
+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)
 }).passthrough();
-var PermissionResolvedNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("permission_resolved" /* PERMISSION_RESOLVED */),
-  requestId: import_zod6.z.string(),
-  toolUseIds: import_zod6.z.array(import_zod6.z.string()),
-  selectedOption: import_zod6.z.nativeEnum(ToolConfirmationOutcome)
+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)
 }).passthrough();
-var SettingsUpdatedNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("settings_updated" /* SETTINGS_UPDATED */),
+var SettingsUpdatedNotificationSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("settings_updated" /* SETTINGS_UPDATED */),
   settings: SettingsUpdatedPayloadSchema
 }).passthrough();
-var SessionTitleUpdatedNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("session_title_updated" /* SESSION_TITLE_UPDATED */),
-  title: import_zod6.z.string()
+var SessionTitleUpdatedNotificationSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("session_title_updated" /* SESSION_TITLE_UPDATED */),
+  title: import_zod7.z.string()
 }).passthrough();
-var McpStatusChangedNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("mcp_status_changed" /* MCP_STATUS_CHANGED */),
-  servers: import_zod6.z.array(McpServerStatusInfoSchema),
+var McpStatusChangedNotificationSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("mcp_status_changed" /* MCP_STATUS_CHANGED */),
+  servers: import_zod7.z.array(McpServerStatusInfoSchema),
   summary: McpStatusSummarySchema
 }).passthrough();
-var AssistantTextDeltaNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("assistant_text_delta" /* ASSISTANT_TEXT_DELTA */),
-  messageId: import_zod6.z.string(),
-  blockIndex: import_zod6.z.number(),
-  textDelta: import_zod6.z.string()
-}).passthrough();
-var ThinkingTextDeltaNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("thinking_text_delta" /* THINKING_TEXT_DELTA */),
-  messageId: import_zod6.z.string(),
-  blockIndex: import_zod6.z.number(),
-  textDelta: import_zod6.z.string()
-}).passthrough();
-var SessionTokenUsageChangedNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("session_token_usage_changed" /* SESSION_TOKEN_USAGE_CHANGED */),
-  sessionId: import_zod6.z.string(),
+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()
+}).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()
+}).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(),
   tokenUsage: TokenUsageSchema
 }).passthrough();
-var MissionStateChangedNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("mission_state_changed" /* MISSION_STATE_CHANGED */),
-  state: import_zod6.z.nativeEnum(MissionState)
+var MissionStateChangedNotificationSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("mission_state_changed" /* MISSION_STATE_CHANGED */),
+  state: import_zod7.z.nativeEnum(MissionState)
 }).passthrough();
-var MissionFeaturesChangedNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("mission_features_changed" /* MISSION_FEATURES_CHANGED */),
-  features: import_zod6.z.array(MissionFeatureSchema)
+var MissionFeaturesChangedNotificationSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("mission_features_changed" /* MISSION_FEATURES_CHANGED */),
+  features: import_zod7.z.array(MissionFeatureSchema)
 }).passthrough();
-var MissionProgressEntryNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("mission_progress_entry" /* MISSION_PROGRESS_ENTRY */),
-  progressLog: import_zod6.z.array(ProgressLogEntrySchema)
+var MissionProgressEntryNotificationSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("mission_progress_entry" /* MISSION_PROGRESS_ENTRY */),
+  progressLog: import_zod7.z.array(ProgressLogEntrySchema)
 }).passthrough();
-var MissionHeartbeatNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("mission_heartbeat" /* MISSION_HEARTBEAT */),
-  timestamp: import_zod6.z.string()
+var MissionHeartbeatNotificationSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("mission_heartbeat" /* MISSION_HEARTBEAT */),
+  timestamp: import_zod7.z.string()
 }).passthrough();
-var MissionWorkerStartedNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("mission_worker_started" /* MISSION_WORKER_STARTED */),
-  workerSessionId: import_zod6.z.string()
+var MissionWorkerStartedNotificationSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("mission_worker_started" /* MISSION_WORKER_STARTED */),
+  workerSessionId: import_zod7.z.string()
 }).passthrough();
-var MissionWorkerCompletedNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("mission_worker_completed" /* MISSION_WORKER_COMPLETED */),
-  workerSessionId: import_zod6.z.string(),
-  exitCode: import_zod6.z.number()
+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()
 }).passthrough();
-var McpAuthRequiredNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("mcp_auth_required" /* MCP_AUTH_REQUIRED */),
-  serverName: import_zod6.z.string(),
-  authUrl: import_zod6.z.string(),
-  message: import_zod6.z.string(),
-  state: import_zod6.z.string()
+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()
 }).passthrough();
-var McpAuthCompletedNotificationSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("mcp_auth_completed" /* MCP_AUTH_COMPLETED */),
-  serverName: import_zod6.z.string(),
-  outcome: import_zod6.z.nativeEnum(McpAuthOutcome),
-  message: import_zod6.z.string()
+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()
 }).passthrough();
 var SessionNotificationSchemaList = [
   ToolResultNotificationSchema,
@@ -1483,84 +1763,86 @@ var SessionNotificationSchemaList = [
   McpAuthRequiredNotificationSchema,
   McpAuthCompletedNotificationSchema
 ];
-var SessionNotificationPayloadSchema = import_zod6.z.discriminatedUnion(
+var SessionNotificationPayloadSchema = import_zod7.z.discriminatedUnion(
   "type",
   SessionNotificationSchemaList
 );
-var SessionNotificationParamsSchema = import_zod6.z.object({
+var _SessionNotificationParamsSchema = import_zod7.z.object({
   notification: SessionNotificationPayloadSchema
 }).passthrough();
-var SessionNotificationSchema = JsonRpcNotificationSchema.extend({
-  method: import_zod6.z.literal("droid.session_notification" /* SESSION_NOTIFICATION */),
+var SessionNotificationParamsSchema = _SessionNotificationParamsSchema;
+var _SessionNotificationSchema = JsonRpcNotificationSchema.extend({
+  method: import_zod7.z.literal("droid.session_notification" /* SESSION_NOTIFICATION */),
   params: SessionNotificationParamsSchema
 });
-var EditToolConfirmationDetailsSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("edit" /* Edit */),
-  filePath: import_zod6.z.string(),
-  fileName: import_zod6.z.string(),
-  oldContent: import_zod6.z.string().optional(),
-  newContent: import_zod6.z.string().optional()
-}).passthrough();
-var ExecuteToolConfirmationDetailsSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("exec" /* Execute */),
-  fullCommand: import_zod6.z.string(),
-  command: import_zod6.z.string(),
-  extractedCommands: import_zod6.z.array(import_zod6.z.string()).optional(),
-  impactLevel: import_zod6.z.string().optional()
-}).passthrough();
-var CreateToolConfirmationDetailsSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("create" /* Create */),
-  filePath: import_zod6.z.string(),
-  fileName: import_zod6.z.string(),
-  content: import_zod6.z.string()
-}).passthrough();
-var AskUserQuestionSchema = import_zod6.z.object({
-  index: import_zod6.z.number(),
-  topic: import_zod6.z.string(),
-  question: import_zod6.z.string(),
-  options: import_zod6.z.array(import_zod6.z.string())
-}).passthrough();
-var AskUserConfirmationDetailsSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("ask_user" /* AskUser */),
-  questionnaire: import_zod6.z.string(),
-  parsed: import_zod6.z.object({
-    questions: import_zod6.z.array(AskUserQuestionSchema)
+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()
+}).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()
+}).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()
+}).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())
+}).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)
   }).optional(),
-  parseError: import_zod6.z.object({
-    message: import_zod6.z.string(),
-    line: import_zod6.z.number().optional()
+  parseError: import_zod7.z.object({
+    message: import_zod7.z.string(),
+    line: import_zod7.z.number().optional()
   }).optional()
 }).passthrough();
-var ExitSpecModeConfirmationDetailsSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("exit_spec_mode" /* ExitSpecMode */),
-  plan: import_zod6.z.string(),
-  title: import_zod6.z.string().optional(),
-  optionNames: import_zod6.z.array(import_zod6.z.string()).optional()
-}).passthrough();
-var ProposeMissionConfirmationDetailsSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("propose_mission" /* ProposeMission */),
-  proposal: import_zod6.z.string(),
-  title: import_zod6.z.string().optional()
-}).passthrough();
-var StartMissionRunConfirmationDetailsSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("start_mission_run" /* StartMissionRun */),
-  runningMissionCount: import_zod6.z.number(),
-  runningMissionSessionIds: import_zod6.z.array(import_zod6.z.string())
-}).passthrough();
-var ApplyPatchToolConfirmationDetailsSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("apply_patch" /* ApplyPatch */),
-  filePath: import_zod6.z.string(),
-  fileName: import_zod6.z.string(),
-  patchContent: import_zod6.z.string(),
-  oldContent: import_zod6.z.string().optional(),
-  newContent: import_zod6.z.string().optional()
-}).passthrough();
-var McpToolConfirmationDetailsSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("mcp_tool" /* McpTool */),
-  toolName: import_zod6.z.string(),
-  impactLevel: import_zod6.z.string()
-}).passthrough();
-var ToolConfirmationDetailsSchema = import_zod6.z.discriminatedUnion("type", [
+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()
+}).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()
+}).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())
+}).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()
+}).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()
+}).passthrough();
+var ToolConfirmationDetailsSchema = import_zod7.z.discriminatedUnion("type", [
   EditToolConfirmationDetailsSchema,
   ExecuteToolConfirmationDetailsSchema,
   CreateToolConfirmationDetailsSchema,
@@ -1571,60 +1853,67 @@ var ToolConfirmationDetailsSchema = import_zod6.z.discriminatedUnion("type", [
   ApplyPatchToolConfirmationDetailsSchema,
   McpToolConfirmationDetailsSchema
 ]);
-var ToolConfirmationInfoSchema = import_zod6.z.object({
+var ToolConfirmationInfoSchema = import_zod7.z.object({
   toolUse: ToolUseSchema,
-  confirmationType: import_zod6.z.nativeEnum(ToolConfirmationType),
+  confirmationType: import_zod7.z.nativeEnum(ToolConfirmationType),
   details: ToolConfirmationDetailsSchema
 }).passthrough();
-var RequestPermissionRequestParamsSchema = import_zod6.z.object({
-  toolUses: import_zod6.z.array(ToolConfirmationInfoSchema),
-  options: import_zod6.z.array(ToolConfirmationListItemSchema)
+var RequestPermissionRequestParamsSchema = import_zod7.z.object({
+  toolUses: import_zod7.z.array(ToolConfirmationInfoSchema),
+  options: import_zod7.z.array(ToolConfirmationListItemSchema)
 }).passthrough();
 var RequestPermissionRequestSchema = JsonRpcRequestSchema.extend({
-  method: import_zod6.z.literal("droid.request_permission" /* REQUEST_PERMISSION */),
+  method: import_zod7.z.literal("droid.request_permission" /* REQUEST_PERMISSION */),
   params: RequestPermissionRequestParamsSchema
 });
-var RequestPermissionResultSchema = import_zod6.z.object({
-  selectedOption: import_zod6.z.nativeEnum(ToolConfirmationOutcome)
+var RequestPermissionResultSchema = import_zod7.z.object({
+  selectedOption: import_zod7.z.nativeEnum(ToolConfirmationOutcome),
+  comment: import_zod7.z.string().optional()
 }).strict();
-var RequestPermissionResponseSchema = import_zod6.z.union([
+var RequestPermissionResponseSchema = import_zod7.z.union([
   JsonRpcResponseSuccessSchema.extend({
     result: RequestPermissionResultSchema
   }),
   JsonRpcResponseFailureSchema
 ]);
-var AskUserRequestParamsSchema = import_zod6.z.object({
-  toolCallId: import_zod6.z.string(),
-  questions: import_zod6.z.array(AskUserQuestionSchema)
+var AskUserRequestParamsSchema = import_zod7.z.object({
+  toolCallId: import_zod7.z.string(),
+  questions: import_zod7.z.array(AskUserQuestionSchema)
 }).passthrough();
 var AskUserRequestSchema = JsonRpcRequestSchema.extend({
-  method: import_zod6.z.literal("droid.ask_user" /* ASK_USER */),
+  method: import_zod7.z.literal("droid.ask_user" /* ASK_USER */),
   params: AskUserRequestParamsSchema
 });
-var AskUserCollectedAnswerSchema = import_zod6.z.object({
-  index: import_zod6.z.number(),
-  question: import_zod6.z.string(),
-  answer: import_zod6.z.string()
+var AskUserCollectedAnswerSchema = import_zod7.z.object({
+  index: import_zod7.z.number(),
+  question: import_zod7.z.string(),
+  answer: import_zod7.z.string()
 }).strict();
-var AskUserResultSchema = import_zod6.z.object({
-  cancelled: import_zod6.z.boolean().optional(),
-  answers: import_zod6.z.array(AskUserCollectedAnswerSchema)
+var AskUserResultSchema = import_zod7.z.object({
+  cancelled: import_zod7.z.boolean().optional(),
+  answers: import_zod7.z.array(AskUserCollectedAnswerSchema)
 }).strict();
-var AskUserResponseSchema = import_zod6.z.union([
+var AskUserResponseSchema = import_zod7.z.union([
   JsonRpcResponseSuccessSchema.extend({ result: AskUserResultSchema }),
   JsonRpcResponseFailureSchema
 ]);
-var CliRequestOrNotificationSchema = import_zod6.z.union([
+var _CliRequestOrNotificationSchema = import_zod7.z.union([
   SessionNotificationSchema,
   RequestPermissionRequestSchema,
   AskUserRequestSchema
 ]);
+var CliRequestOrNotificationSchema = _CliRequestOrNotificationSchema;
+
+// src/constants.ts
+var SDK_VERSION = "0.2.0";
+var SDK_TAG = {
+  name: "sdk",
+  metadata: { language: "typescript", version: SDK_VERSION }
+};
 
 // src/errors.ts
 var ConnectionError = class _ConnectionError extends Error {
-  /** The working directory used when spawning the process. */
   cwd;
-  /** The executable path used when spawning the process. */
   execPath;
   constructor(message, options) {
     super(message);
@@ -1635,9 +1924,7 @@ var ConnectionError = class _ConnectionError extends Error {
   }
 };
 var ProtocolError = class _ProtocolError extends Error {
-  /** The JSON-RPC error code, if available. */
   code;
-  /** Additional error data from the JSON-RPC response. */
   data;
   constructor(message, options) {
     super(message);
@@ -1655,7 +1942,6 @@ var SessionError = class _SessionError extends Error {
   }
 };
 var SessionNotFoundError = class _SessionNotFoundError extends SessionError {
-  /** The ID of the session that was not found. */
   sessionId;
   constructor(sessionId) {
     super(`Session not found: ${sessionId}`);
@@ -1672,9 +1958,7 @@ var TimeoutError = class _TimeoutError extends Error {
   }
 };
 var ProcessExitError = class _ProcessExitError extends Error {
-  /** The exit code of the process, or null if terminated by signal. */
   exitCode;
-  /** The signal that terminated the process, or null if exited normally. */
   signal;
   constructor(message, options) {
     super(message);
@@ -1688,6 +1972,13 @@ var ProcessExitError = class _ProcessExitError extends Error {
 // src/transport.ts
 var import_node_child_process = require("child_process");
 var readline = __toESM(require("readline"), 1);
+
+// src/utils.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/transport.ts
 var DEFAULT_EXEC_ARGS = [
   "exec",
   "--input-format",
@@ -1706,12 +1997,9 @@ var ProcessTransport = class {
   readlineInterface = null;
   messageHandler = null;
   errorHandler = null;
-  /**
-   * Sticky error from a process error or unexpected exit. Once set,
-   * all subsequent `send()` calls throw immediately.
-   */
+  /** Once set, all subsequent `send()` calls throw immediately. */
   processError = null;
-  /** Promise-chain serializer for stdin writes. */
+  /** Serializes stdin writes to prevent interleaving. */
   writeChain = Promise.resolve();
   _isConnected = false;
   isClosing = false;
@@ -1722,9 +2010,6 @@ var ProcessTransport = class {
     this.env = options.env;
     this.gracePeriodMs = (options.gracePeriod ?? DEFAULT_GRACE_PERIOD_MS / 1e3) * 1e3;
   }
-  // -----------------------------------------------------------------------
-  // DroidClientTransport interface
-  // -----------------------------------------------------------------------
   get isConnected() {
     return this._isConnected;
   }
@@ -1776,7 +2061,7 @@ var ProcessTransport = class {
       if (this.processError) {
         throw this.processError;
       }
-      await new Promise((resolve, reject) => {
+      await new Promise((resolve2, reject) => {
         if (!this.childProcess || !this.childProcess.stdin) {
           reject(
             new ConnectionError("Process stdin unavailable", {
@@ -1812,7 +2097,7 @@ var ProcessTransport = class {
               );
             }
           } else {
-            resolve();
+            resolve2();
           }
         });
       });
@@ -1837,7 +2122,7 @@ var ProcessTransport = class {
       this.readlineInterface = null;
     }
     if (proc && proc.exitCode === null && !proc.killed) {
-      await new Promise((resolve) => {
+      await new Promise((resolve2) => {
         const timeout = setTimeout(() => {
           if (proc.exitCode === null && !proc.killed) {
             try {
@@ -1848,7 +2133,7 @@ var ProcessTransport = class {
         }, this.gracePeriodMs);
         proc.once("exit", () => {
           clearTimeout(timeout);
-          resolve();
+          resolve2();
         });
         if (proc.stdin) {
           try {
@@ -1860,15 +2145,12 @@ var ProcessTransport = class {
           proc.kill("SIGTERM");
         } catch {
           clearTimeout(timeout);
-          resolve();
+          resolve2();
         }
       });
     }
     this.isClosing = false;
   }
-  // -----------------------------------------------------------------------
-  // Private helpers
-  // -----------------------------------------------------------------------
   setupHandlers() {
     const proc = this.childProcess;
     if (!proc || !proc.stdout) {
@@ -1883,10 +2165,10 @@ var ProcessTransport = class {
       if (!trimmed) {
         return;
       }
-      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      if (trimmed.startsWith("{")) {
         try {
           const parsed = JSON.parse(trimmed);
-          if (this.messageHandler && typeof parsed === "object" && parsed !== null) {
+          if (this.messageHandler && isRecord(parsed)) {
             this.messageHandler(parsed);
           }
         } catch {
@@ -1942,23 +2224,12 @@ var import_uuid = require("uuid");
 var ProtocolEngine = class {
   _transport;
   _defaultTimeout;
-  /** Pending requests keyed by UUID string. */
   _pendingRequests = /* @__PURE__ */ new Map();
-  /** Notification listener registry. */
   _notificationListeners = /* @__PURE__ */ new Set();
-  /** Server→client request handlers. */
   _permissionHandler = null;
   _askUserHandler = null;
-  /** Sticky transport error — once set, all requests fail immediately. */
   _transportError = null;
-  /** Closed flag — once true, new requests are rejected. */
   _closed = false;
-  /**
-   * Create a new ProtocolEngine.
-   *
-   * @param options.transport - A connected DroidClientTransport implementation.
-   * @param options.defaultTimeout - Default timeout in ms for sendRequest (default 30 000).
-   */
   constructor(options) {
     this._transport = options.transport;
     this._defaultTimeout = options.defaultTimeout ?? DEFAULT_REQUEST_TIMEOUT;
@@ -1969,25 +2240,6 @@ var ProtocolEngine = class {
       this._handleTransportError(error);
     });
   }
-  // ------------------------------------------------------------------
-  // Public API: Sending requests
-  // ------------------------------------------------------------------
-  /**
-   * Send a JSON-RPC request and wait for the response.
-   *
-   * Constructs the full envelope, registers a pending promise, sends
-   * via transport, and returns the parsed response `result` field.
-   *
-   * @param method - The RPC method name (e.g. `"droid.list_skills"`).
-   * @param params - Method parameters object.
-   * @param timeout - Timeout in ms. Defaults to `defaultTimeout`.
-   * @returns The `result` field from the JSON-RPC success response.
-   * @throws {ConnectionError} If the engine is closed.
-   * @throws {ConnectionError} If the transport has a sticky error.
-   * @throws {TimeoutError} If no response arrives within the timeout.
-   * @throws {ProtocolError} If the response contains a protocol error.
-   * @throws {SessionNotFoundError} If error code is ENTITY_NOT_FOUND.
-   */
   async sendRequest(method, params, timeout) {
     if (this._closed) {
       throw new ConnectionError("Protocol engine is closed");
@@ -2003,12 +2255,12 @@ var ProtocolEngine = class {
       jsonrpc: JSONRPC_VERSION,
       factoryApiVersion: LEGACY_FACTORY_API_VERSION,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
-      type: "request",
+      type: "request" /* Request */,
       id: requestId,
       method,
       params
     };
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         this._pendingRequests.delete(requestId);
         reject(
@@ -2021,7 +2273,7 @@ var ProtocolEngine = class {
         method,
         requestId,
         params,
-        resolve,
+        resolve: resolve2,
         reject,
         timer
       };
@@ -2041,19 +2293,6 @@ var ProtocolEngine = class {
       }
     });
   }
-  // ------------------------------------------------------------------
-  // Public API: Notification listeners
-  // ------------------------------------------------------------------
-  /**
-   * Register a callback for incoming notification messages.
-   *
-   * Multiple listeners can be registered. Each receives the full
-   * parsed notification object.
-   *
-   * @param callback - Invoked with the notification object.
-   * @param filter - Optional filter to only receive specific notification types.
-   * @returns An unsubscribe function. Calling it again is safe (no-op).
-   */
   onNotification(callback, filter) {
     const listener = { callback, filter };
     this._notificationListeners.add(listener);
@@ -2065,23 +2304,9 @@ var ProtocolEngine = class {
       }
     };
   }
-  // ------------------------------------------------------------------
-  // Public API: Server→client request handlers
-  // ------------------------------------------------------------------
-  /**
-   * Register a handler for server→client permission requests.
-   *
-   * The handler receives the request params and should return a
-   * ToolConfirmationOutcome string value.
-   *
-   * Replaces any previously registered handler.
-   */
   setPermissionHandler(handler) {
     this._permissionHandler = handler;
   }
-  /**
-   * Remove the permission request handler (restores default Cancel).
-   */
   clearPermissionHandler() {
     this._permissionHandler = null;
   }
@@ -2096,31 +2321,12 @@ var ProtocolEngine = class {
   setAskUserHandler(handler) {
     this._askUserHandler = handler;
   }
-  /**
-   * Remove the ask-user request handler (restores default cancelled=true).
-   */
   clearAskUserHandler() {
     this._askUserHandler = null;
   }
-  // ------------------------------------------------------------------
-  // Public API: Health check
-  // ------------------------------------------------------------------
-  /**
-   * Whether the engine is in a healthy state — not closed and no
-   * sticky transport error.
-   */
   get isHealthy() {
     return !this._closed && this._transportError === null;
   }
-  // ------------------------------------------------------------------
-  // Public API: Close
-  // ------------------------------------------------------------------
-  /**
-   * Close the protocol engine.
-   *
-   * Rejects all pending requests, closes the transport, and prevents
-   * new requests. Idempotent — safe to call multiple times.
-   */
   async close() {
     if (this._closed) {
       return;
@@ -2135,38 +2341,25 @@ var ProtocolEngine = class {
     this._notificationListeners.clear();
     await this._transport.close();
   }
-  // ------------------------------------------------------------------
-  // Internal: Message handling
-  // ------------------------------------------------------------------
-  /**
-   * Handle an incoming parsed message from the transport.
-   * Dispatches to response handler, notification handler, or
-   * server→client request handler based on message type.
-   */
-  _handleMessage(parsed) {
-    const msgType = parsed["type"];
-    if (msgType === "response") {
-      this._handleResponse(parsed);
-    } else if (msgType === "notification") {
-      this._handleNotification(parsed);
-    } else if (msgType === "request") {
-      void this._handleServerRequest(parsed);
-    } else {
-      if ("result" in parsed || "error" in parsed) {
-        this._handleResponse(parsed);
-      } else if ("method" in parsed && !("id" in parsed)) {
-        this._handleNotification(parsed);
-      } else if ("method" in parsed && "id" in parsed) {
-        void this._handleServerRequest(parsed);
-      }
+  _handleMessage(raw) {
+    const parsed = JsonRpcMessageSchema.safeParse(raw);
+    if (!parsed.success) {
+      return;
+    }
+    const msg = parsed.data;
+    switch (msg.type) {
+      case "response" /* Response */:
+        this._handleResponse(msg.id, msg.result, msg.error);
+        break;
+      case "notification" /* Notification */:
+        this._handleNotification(msg);
+        break;
+      case "request" /* Request */:
+        void this._handleServerRequest(msg.method, msg.id, msg.params);
+        break;
     }
   }
-  /**
-   * Handle an incoming response message.
-   * Matches by ID to resolve the correct pending Promise.
-   */
-  _handleResponse(response) {
-    const responseId = response["id"];
+  _handleResponse(responseId, result, error) {
     if (responseId == null) {
       return;
     }
@@ -2176,32 +2369,29 @@ var ProtocolEngine = class {
     }
     this._pendingRequests.delete(responseId);
     clearTimeout(pending.timer);
-    const errorObj = response["error"];
-    if (errorObj != null && typeof errorObj === "object") {
-      const error = errorObj;
-      const code = error["code"];
-      const message = error["message"] ?? "Unknown error";
-      const data = error["data"];
-      if (code === -32004 /* ENTITY_NOT_FOUND */) {
+    if (error != null) {
+      if (error.code === -32004 /* ENTITY_NOT_FOUND */) {
         const sessionId = String(
           pending.params["sessionId"] ?? pending.requestId
         );
         pending.reject(new SessionNotFoundError(sessionId));
         return;
       }
-      pending.reject(new ProtocolError(message, { code, data }));
+      pending.reject(
+        new ProtocolError(error.message, { code: error.code, data: error.data })
+      );
       return;
     }
-    pending.resolve(response);
+    pending.resolve(result);
   }
-  /**
-   * Handle an incoming notification message.
-   * Dispatches to all registered notification listeners that match.
-   */
   _handleNotification(notification) {
-    const params = notification["params"];
-    const innerNotification = params?.["notification"];
-    const notificationType = innerNotification?.["type"];
+    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;
@@ -2212,32 +2402,32 @@ var ProtocolEngine = class {
       }
     }
   }
-  /**
-   * Handle an incoming server→client request.
-   * Dispatches to the appropriate handler based on the method field.
-   */
-  async _handleServerRequest(request) {
-    const method = request["method"];
-    const requestId = request["id"];
-    const params = request["params"] ?? {};
+  async _handleServerRequest(method, requestId, params) {
     if (method === "droid.request_permission" /* REQUEST_PERMISSION */) {
       await this._handlePermissionRequest(requestId, params);
     } else if (method === "droid.ask_user" /* ASK_USER */) {
       await this._handleAskUserRequest(requestId, params);
     }
   }
-  /**
-   * Handle droid.request_permission server→client request.
-   */
   async _handlePermissionRequest(requestId, params) {
     const handler = this._permissionHandler;
     if (handler == null) {
-      this._sendResponse(requestId, { selectedOption: "cancel" });
+      this._sendResponse(
+        requestId,
+        RequestPermissionResultSchema.parse({
+          selectedOption: "cancel" /* Cancel */
+        })
+      );
       return;
     }
     try {
-      const selectedOption = await Promise.resolve(handler(params));
-      this._sendResponse(requestId, { selectedOption });
+      const parsedParams = RequestPermissionRequestParamsSchema.parse(params);
+      const selection = await Promise.resolve(handler(parsedParams));
+      const result = typeof selection === "string" ? { selectedOption: selection } : selection;
+      this._sendResponse(
+        requestId,
+        RequestPermissionResultSchema.parse(result)
+      );
     } catch (exc) {
       const errorMessage = exc instanceof Error ? exc.message : String(exc);
       this._sendErrorResponse(
@@ -2248,18 +2438,19 @@ var ProtocolEngine = class {
       );
     }
   }
-  /**
-   * Handle droid.ask_user server→client request.
-   */
   async _handleAskUserRequest(requestId, params) {
     const handler = this._askUserHandler;
     if (handler == null) {
-      this._sendResponse(requestId, { cancelled: true, answers: [] });
+      this._sendResponse(
+        requestId,
+        AskUserResultSchema.parse({ cancelled: true, answers: [] })
+      );
       return;
     }
     try {
-      const result = await Promise.resolve(handler(params));
-      this._sendResponse(requestId, result);
+      const parsedParams = AskUserRequestParamsSchema.parse(params);
+      const result = await Promise.resolve(handler(parsedParams));
+      this._sendResponse(requestId, AskUserResultSchema.parse(result));
     } catch (exc) {
       const errorMessage = exc instanceof Error ? exc.message : String(exc);
       this._sendErrorResponse(
@@ -2270,9 +2461,6 @@ var ProtocolEngine = class {
       );
     }
   }
-  // ------------------------------------------------------------------
-  // Internal: Transport error handling
-  // ------------------------------------------------------------------
   /**
    * Handle a transport error.
    * Sets the sticky transport error and rejects all pending requests.
@@ -2286,29 +2474,17 @@ var ProtocolEngine = class {
     connectionError.cause = error;
     this._rejectAllPending(connectionError);
   }
-  // ------------------------------------------------------------------
-  // Internal: Response helpers
-  // ------------------------------------------------------------------
-  /**
-   * Send a JSON-RPC success response back to the server.
-   */
   _sendResponse(requestId, result) {
     const response = {
       jsonrpc: JSONRPC_VERSION,
       factoryApiVersion: LEGACY_FACTORY_API_VERSION,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
-      type: "response",
+      type: "response" /* Response */,
       id: requestId,
       result
     };
-    try {
-      this._transport.send(response);
-    } catch {
-    }
+    this._sendBestEffort(response);
   }
-  /**
-   * Send a JSON-RPC error response back to the server.
-   */
   _sendErrorResponse(requestId, code, message, data) {
     const errorObj = { code, message };
     if (data !== void 0) {
@@ -2318,18 +2494,18 @@ var ProtocolEngine = class {
       jsonrpc: JSONRPC_VERSION,
       factoryApiVersion: LEGACY_FACTORY_API_VERSION,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
-      type: "response",
+      type: "response" /* Response */,
       id: requestId,
       error: errorObj
     };
+    this._sendBestEffort(response);
+  }
+  _sendBestEffort(message) {
     try {
-      this._transport.send(response);
+      this._transport.send(message);
     } catch {
     }
   }
-  /**
-   * Reject all pending requests with the given error.
-   */
   _rejectAllPending(error) {
     const pending = new Map(this._pendingRequests);
     this._pendingRequests.clear();
@@ -2347,7 +2523,7 @@ var DroidClient = class {
   _closed = false;
   /**
    * Client-level notification listeners.
-   * Each entry is [callback, optional type filter string].
+   * Each entry is [callback, optional notification filter].
    */
   _notificationListeners = [];
   /** Client-level permission handler. */
@@ -2369,329 +2545,212 @@ var DroidClient = class {
       (params) => this._dispatchAskUserRequest(params)
     );
   }
-  // ------------------------------------------------------------------
-  // Properties
-  // ------------------------------------------------------------------
-  /**
-   * Current session ID, or `null` if no session is active.
-   */
+  async _rpc(method, params, schema, timeout) {
+    const raw = await this._engine.sendRequest(method, params, timeout);
+    return schema.parse(raw);
+  }
+  async _sessionRpc(method, params, schema, timeout) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    return this._rpc(method, params, schema, timeout);
+  }
+  async _sessionRpcWithoutParams(method, schema, timeout) {
+    return this._sessionRpc(method, {}, schema, timeout);
+  }
   get sessionId() {
     return this._sessionId;
   }
-  /**
-   * Whether the client is in a healthy state — not closed and no
-   * transport errors have occurred. Returns false after transport
-   * disconnect/error.
-   */
   get isConnected() {
     return !this._closed && this._engine.isHealthy;
   }
-  // ------------------------------------------------------------------
-  // Session lifecycle methods
-  // ------------------------------------------------------------------
-  /**
-   * Initialize a new session.
-   *
-   * Sends `droid.initialize_session` with extended timeout. On success,
-   * stores the session ID internally and returns the typed result.
-   */
   async initializeSession(params) {
     this._ensureNotClosed();
-    const response = await this._engine.sendRequest(
+    const result = await this._rpc(
       "droid.initialize_session" /* INITIALIZE_SESSION */,
       params,
+      InitializeSessionResultSchema,
       SESSION_INIT_TIMEOUT
     );
-    const result = response["result"];
-    if (result) {
-      this._sessionId = result.sessionId;
-      return result;
-    }
-    if ("sessionId" in response) {
-      this._sessionId = response["sessionId"];
-      return response;
-    }
-    return response;
+    this._sessionId = result.sessionId;
+    return result;
   }
-  /**
-   * Load an existing session.
-   *
-   * Sends `droid.load_session`. SessionNotFoundError is thrown for
-   * non-existent sessions (mapped from ENTITY_NOT_FOUND by the protocol engine).
-   */
   async loadSession(params) {
     this._ensureNotClosed();
-    const response = await this._engine.sendRequest(
+    const result = await this._rpc(
       "droid.load_session" /* LOAD_SESSION */,
       params,
+      LoadSessionResultSchema,
       SESSION_INIT_TIMEOUT
     );
-    const result = response["result"];
-    if (result) {
-      this._sessionId = params.sessionId;
-      return result;
-    }
     this._sessionId = params.sessionId;
-    return response;
+    return result;
   }
-  /**
-   * Add a user message to the active session.
-   *
-   * Sends `droid.add_user_message` with text and optional images/files.
-   */
   async addUserMessage(params) {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpc(
       "droid.add_user_message" /* ADD_USER_MESSAGE */,
-      params
+      params,
+      AddUserMessageResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * Interrupt the current session.
-   *
-   * Sends `droid.interrupt_session` with empty params.
-   */
   async interruptSession() {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpcWithoutParams(
       "droid.interrupt_session" /* INTERRUPT_SESSION */,
-      {}
+      InterruptSessionResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * Kill a worker session.
-   *
-   * Sends `droid.kill_worker_session`.
-   */
   async killWorkerSession(params) {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpc(
       "droid.kill_worker_session" /* KILL_WORKER_SESSION */,
-      params
+      params,
+      KillWorkerSessionResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * Update session settings.
-   *
-   * Sends `droid.update_session_settings` with the provided partial settings.
-   */
   async updateSessionSettings(params) {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpc(
       "droid.update_session_settings" /* UPDATE_SESSION_SETTINGS */,
-      params
+      params,
+      UpdateSessionSettingsResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  // ------------------------------------------------------------------
-  // MCP methods
-  // ------------------------------------------------------------------
-  /**
-   * Toggle an MCP server on or off.
-   */
   async toggleMcpServer(params) {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpc(
       "droid.toggle_mcp_server" /* TOGGLE_MCP_SERVER */,
-      params
+      params,
+      ToggleMcpServerResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * Authenticate an MCP server (OAuth flow).
-   * Uses extended timeout (300s) since OAuth requires user interaction.
-   */
   async authenticateMcpServer(params) {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpc(
       "droid.authenticate_mcp_server" /* AUTHENTICATE_MCP_SERVER */,
       params,
+      AuthenticateMcpServerResultSchema,
       MCP_AUTH_TIMEOUT
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * Cancel an in-progress MCP authentication.
-   */
   async cancelMcpAuth(params) {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpc(
       "droid.cancel_mcp_auth" /* CANCEL_MCP_AUTH */,
-      params
+      params,
+      CancelMcpAuthResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * Clear stored MCP authentication tokens.
-   */
   async clearMcpAuth(params) {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpc(
       "droid.clear_mcp_auth" /* CLEAR_MCP_AUTH */,
-      params
+      params,
+      ClearMcpAuthResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * Submit an MCP authentication code (OAuth callback).
-   */
   async submitMcpAuthCode(params) {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpc(
       "droid.submit_mcp_auth_code" /* SUBMIT_MCP_AUTH_CODE */,
-      params
+      params,
+      SubmitMcpAuthCodeResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * Add an MCP server.
-   */
   async addMcpServer(params) {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpc(
       "droid.add_mcp_server" /* ADD_MCP_SERVER */,
-      params
+      params,
+      AddMcpServerResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * Remove an MCP server.
-   */
   async removeMcpServer(params) {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpc(
       "droid.remove_mcp_server" /* REMOVE_MCP_SERVER */,
-      params
+      params,
+      RemoveMcpServerResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * List available MCP registry servers.
-   */
   async listMcpRegistry() {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpcWithoutParams(
       "droid.list_mcp_registry" /* LIST_MCP_REGISTRY */,
-      {}
+      ListMcpRegistryResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * List available MCP tools.
-   */
   async listMcpTools() {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpcWithoutParams(
       "droid.list_mcp_tools" /* LIST_MCP_TOOLS */,
-      {}
+      ListMcpToolsResultSchema
+    );
+  }
+  async listTools(params = {}) {
+    return this._sessionRpc(
+      "droid.list_tools" /* LIST_TOOLS */,
+      params,
+      ListToolsResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * List MCP servers with status and summary.
-   */
   async listMcpServers() {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpcWithoutParams(
       "droid.list_mcp_servers" /* LIST_MCP_SERVERS */,
-      {}
+      ListMcpServersResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * Toggle an MCP tool on or off.
-   */
   async toggleMcpTool(params) {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpc(
       "droid.toggle_mcp_tool" /* TOGGLE_MCP_TOOL */,
-      params
+      params,
+      ToggleMcpToolResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  // ------------------------------------------------------------------
-  // Skills and bug report methods
-  // ------------------------------------------------------------------
-  /**
-   * List available skills.
-   */
   async listSkills() {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpcWithoutParams(
       "droid.list_skills" /* LIST_SKILLS */,
-      {}
+      ListSkillsResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  /**
-   * Submit a bug report.
-   */
   async submitBugReport(params) {
-    this._ensureNotClosed();
-    this._ensureSession();
-    const response = await this._engine.sendRequest(
+    return this._sessionRpc(
       "droid.submit_bug_report" /* SUBMIT_BUG_REPORT */,
-      params
+      params,
+      SubmitBugReportResultSchema
+    );
+  }
+  async getRewindInfo(params) {
+    return this._sessionRpc(
+      "droid.get_rewind_info" /* GET_REWIND_INFO */,
+      params,
+      GetRewindInfoResultSchema
+    );
+  }
+  async executeRewind(params) {
+    return this._sessionRpc(
+      "droid.execute_rewind" /* EXECUTE_REWIND */,
+      params,
+      ExecuteRewindResultSchema,
+      REWIND_TIMEOUT
+    );
+  }
+  async compactSession(params) {
+    return this._sessionRpc(
+      "droid.compact_session" /* COMPACT_SESSION */,
+      params,
+      CompactSessionResultSchema,
+      COMPACTION_TIMEOUT
+    );
+  }
+  async forkSession() {
+    return this._sessionRpcWithoutParams(
+      "droid.fork_session" /* FORK_SESSION */,
+      ForkSessionResultSchema
+    );
+  }
+  async getContextStats() {
+    return this._sessionRpcWithoutParams(
+      "droid.get_context_stats" /* GET_CONTEXT_STATS */,
+      GetContextStatsResultSchema
+    );
+  }
+  async renameSession(params) {
+    return this._sessionRpc(
+      "droid.rename_session" /* RENAME_SESSION */,
+      params,
+      RenameSessionResultSchema
     );
-    const result = response["result"];
-    return result ?? response;
   }
-  // ------------------------------------------------------------------
-  // Notification subscription
-  // ------------------------------------------------------------------
-  /**
-   * Register a callback for incoming notification messages.
-   *
-   * Multiple listeners can be registered. Each receives the full parsed
-   * notification object. Optionally filter by notification type.
-   *
-   * Listener exceptions are isolated — if one raises, others still receive
-   * the event and the engine continues.
-   *
-   * @param callback - Invoked with the notification object.
-   * @param filter - Optional filter to only receive specific notification types.
-   * @returns An unsubscribe function. Calling it again is safe (no-op).
-   */
   onNotification(callback, filter) {
-    const entry = {
-      callback,
-      typeFilter: filter?.type
-    };
+    const entry = { callback, filter };
     this._notificationListeners.push(entry);
     let unsubscribed = false;
     return () => {
@@ -2704,54 +2763,18 @@ var DroidClient = class {
       }
     };
   }
-  // ------------------------------------------------------------------
-  // Permission/ask-user handler registration
-  // ------------------------------------------------------------------
-  /**
-   * Register a handler for server→client permission requests.
-   *
-   * The handler receives the request params and should return a
-   * ToolConfirmationOutcome string value. Async handlers are awaited.
-   * Replaces any previously registered handler.
-   */
   setPermissionHandler(handler) {
     this._permissionHandler = handler;
   }
-  /**
-   * Remove the permission request handler.
-   * Restores default behavior: return "cancel".
-   */
   clearPermissionHandler() {
     this._permissionHandler = null;
   }
-  /**
-   * Register a handler for server→client ask-user requests.
-   *
-   * The handler receives the request params and should return a result
-   * object with `cancelled` and `answers` keys. Async handlers are awaited.
-   * Replaces any previously registered handler.
-   */
   setAskUserHandler(handler) {
     this._askUserHandler = handler;
   }
-  /**
-   * Remove the ask-user request handler.
-   * Restores default behavior: return `{ cancelled: true, answers: [] }`.
-   */
   clearAskUserHandler() {
     this._askUserHandler = null;
   }
-  // ------------------------------------------------------------------
-  // Lifecycle
-  // ------------------------------------------------------------------
-  /**
-   * Close the client and release all resources.
-   *
-   * Rejects pending requests, clears handlers and listeners, and closes
-   * the protocol engine. Idempotent — safe to call multiple times.
-   *
-   * After close, all method calls throw ConnectionError immediately.
-   */
   async close() {
     if (this._closed) {
       return;
@@ -2762,21 +2785,17 @@ var DroidClient = class {
     this._askUserHandler = null;
     await this._engine.close();
   }
-  // ------------------------------------------------------------------
-  // Internal: dispatch methods
-  // ------------------------------------------------------------------
-  /**
-   * Dispatch a notification to all registered client-level listeners.
-   * Filters by notification type if a type filter is set.
-   * Exception in one listener does not affect others.
-   */
   _dispatchNotification(notification) {
-    const params = notification["params"];
-    const innerNotification = params?.["notification"];
-    const notificationType = innerNotification?.["type"];
+    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.typeFilter != null && listener.typeFilter !== notificationType) {
+      if (listener.filter?.type != null && listener.filter.type !== notificationType) {
         continue;
       }
       try {
@@ -2785,25 +2804,13 @@ var DroidClient = class {
       }
     }
   }
-  /**
-   * Dispatch to the client-level permission handler.
-   * If no handler is set, returns the default "cancel" outcome.
-   * If handler throws, the error propagates to the protocol engine
-   * which sends an error response.
-   */
   _dispatchPermissionRequest(params) {
     const handler = this._permissionHandler;
     if (handler == null) {
-      return "cancel";
+      return "cancel" /* Cancel */;
     }
     return handler(params);
   }
-  /**
-   * Dispatch to the client-level ask-user handler.
-   * If no handler is set, returns the default cancelled response.
-   * If handler throws, the error propagates to the protocol engine
-   * which sends an error response.
-   */
   _dispatchAskUserRequest(params) {
     const handler = this._askUserHandler;
     if (handler == null) {
@@ -2811,12 +2818,6 @@ var DroidClient = class {
     }
     return handler(params);
   }
-  // ------------------------------------------------------------------
-  // Internal: guards
-  // ------------------------------------------------------------------
-  /**
-   * Throw ConnectionError if the client has been closed.
-   */
   _ensureNotClosed() {
     if (this._closed) {
       throw new ConnectionError(
@@ -2824,9 +2825,6 @@ var DroidClient = class {
       );
     }
   }
-  /**
-   * Throw SessionError if no active session.
-   */
   _ensureSession() {
     if (this._sessionId == null) {
       throw new SessionError(
@@ -2837,26 +2835,56 @@ var DroidClient = class {
 };
 
 // src/stream.ts
-function convertNotificationToStreamMessage(notification) {
+var DroidMessageType = {
+  AssistantTextDelta: "assistant_text_delta",
+  ThinkingTextDelta: "thinking_text_delta",
+  ToolUse: "tool_use",
+  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",
+  McpStatusChanged: "mcp_status_changed",
+  MissionStateChanged: "mission_state_changed",
+  MissionFeaturesChanged: "mission_features_changed",
+  MissionProgressEntry: "mission_progress_entry",
+  MissionHeartbeat: "mission_heartbeat",
+  MissionWorkerStarted: "mission_worker_started",
+  MissionWorkerCompleted: "mission_worker_completed",
+  McpAuthRequired: "mcp_auth_required",
+  McpAuthCompleted: "mcp_auth_completed",
+  Error: "error",
+  TurnComplete: "turn_complete"
+};
+function convertNotificationToStreamMessage(raw) {
+  const parsed = SessionNotificationPayloadSchema.safeParse(raw);
+  if (!parsed.success) {
+    return null;
+  }
+  const notification = parsed.data;
   switch (notification.type) {
     case "assistant_text_delta" /* ASSISTANT_TEXT_DELTA */:
       return {
-        type: "assistant_text_delta",
+        type: DroidMessageType.AssistantTextDelta,
         messageId: notification.messageId,
         blockIndex: notification.blockIndex,
         text: notification.textDelta
       };
     case "thinking_text_delta" /* THINKING_TEXT_DELTA */:
       return {
-        type: "thinking_text_delta",
+        type: DroidMessageType.ThinkingTextDelta,
         messageId: notification.messageId,
         blockIndex: notification.blockIndex,
         text: notification.textDelta
       };
     case "tool_result" /* TOOL_RESULT */:
       return {
-        type: "tool_result",
+        type: DroidMessageType.ToolResult,
         toolUseId: notification.toolUseId,
+        toolName: "",
         content: normalizeToolResultContent(notification.content),
         isError: Boolean(notification.isError)
       };
@@ -2864,7 +2892,7 @@ function convertNotificationToStreamMessage(notification) {
       const update = notification.update;
       const text = update?.text ?? update?.status ?? update?.details ?? "";
       return {
-        type: "tool_progress",
+        type: DroidMessageType.ToolProgress,
         toolUseId: notification.toolUseId,
         toolName: notification.toolName,
         content: text,
@@ -2873,108 +2901,106 @@ function convertNotificationToStreamMessage(notification) {
     }
     case "droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */:
       return {
-        type: "working_state_changed",
+        type: DroidMessageType.WorkingStateChanged,
         state: notification.newState
       };
     case "session_token_usage_changed" /* SESSION_TOKEN_USAGE_CHANGED */: {
       const tu = notification.tokenUsage;
       return {
-        type: "token_usage_update",
+        type: DroidMessageType.TokenUsageUpdate,
         inputTokens: tu.inputTokens,
         outputTokens: tu.outputTokens,
         cacheReadTokens: tu.cacheReadTokens,
-        cacheWriteTokens: tu.cacheCreationTokens,
+        cacheCreationTokens: tu.cacheCreationTokens,
         thinkingTokens: tu.thinkingTokens
       };
     }
     case "create_message" /* CREATE_MESSAGE */: {
       const msg = notification.message;
       const messages = [];
-      if (msg.content && Array.isArray(msg.content)) {
-        for (const block of msg.content) {
-          if (block.type === "tool_use") {
-            messages.push({
-              type: "tool_use",
-              toolName: block.name,
-              toolInput: block.input ?? {},
-              toolUseId: block.id
-            });
-          }
+      for (const block of msg.content) {
+        if (block.type === DroidMessageType.ToolUse) {
+          messages.push({
+            type: DroidMessageType.ToolUse,
+            toolName: block.name,
+            toolInput: block.input,
+            toolUseId: block.id
+          });
         }
       }
       messages.push({
-        type: "create_message",
+        type: DroidMessageType.CreateMessage,
         messageId: msg.id,
         role: msg.role,
-        content: msg.content ?? [],
+        content: msg.content,
         parentId: notification.parentId
       });
       return messages;
     }
     case "error" /* ERROR */:
       return {
-        type: "error",
+        type: DroidMessageType.Error,
         message: notification.message,
         errorType: notification.errorType,
         timestamp: notification.timestamp
       };
     case "permission_resolved" /* PERMISSION_RESOLVED */:
       return {
-        type: "permission_resolved",
+        type: DroidMessageType.PermissionResolved,
         requestId: notification.requestId,
         toolUseIds: notification.toolUseIds,
         selectedOption: notification.selectedOption
       };
     case "settings_updated" /* SETTINGS_UPDATED */:
       return {
-        type: "settings_updated",
+        type: DroidMessageType.SettingsUpdated,
         settings: notification.settings
       };
     case "session_title_updated" /* SESSION_TITLE_UPDATED */:
       return {
-        type: "session_title_updated",
+        type: DroidMessageType.SessionTitleUpdated,
         title: notification.title
       };
     case "mcp_status_changed" /* MCP_STATUS_CHANGED */:
       return {
-        type: "mcp_status_changed",
+        type: DroidMessageType.McpStatusChanged,
         servers: notification.servers,
         summary: notification.summary
       };
     case "mission_state_changed" /* MISSION_STATE_CHANGED */:
       return {
-        type: "mission_state_changed",
+        type: DroidMessageType.MissionStateChanged,
         state: notification.state
       };
     case "mission_features_changed" /* MISSION_FEATURES_CHANGED */:
       return {
-        type: "mission_features_changed",
+        type: DroidMessageType.MissionFeaturesChanged,
         features: notification.features
       };
     case "mission_progress_entry" /* MISSION_PROGRESS_ENTRY */:
       return {
-        type: "mission_progress_entry",
+        type: DroidMessageType.MissionProgressEntry,
         progressLog: notification.progressLog
       };
     case "mission_heartbeat" /* MISSION_HEARTBEAT */:
       return {
-        type: "mission_heartbeat",
+        type: DroidMessageType.MissionHeartbeat,
         timestamp: notification.timestamp
       };
     case "mission_worker_started" /* MISSION_WORKER_STARTED */:
       return {
-        type: "mission_worker_started",
+        type: DroidMessageType.MissionWorkerStarted,
         workerSessionId: notification.workerSessionId
       };
     case "mission_worker_completed" /* MISSION_WORKER_COMPLETED */:
       return {
-        type: "mission_worker_completed",
+        type: DroidMessageType.MissionWorkerCompleted,
         workerSessionId: notification.workerSessionId,
         exitCode: notification.exitCode
       };
     case "mcp_auth_required" /* MCP_AUTH_REQUIRED */:
       return {
-        type: "mcp_auth_required",
+        type: DroidMessageType.McpAuthRequired,
         serverName: notification.serverName,
         authUrl: notification.authUrl,
         message: notification.message,
@@ -2982,54 +3008,45 @@ function convertNotificationToStreamMessage(notification) {
       };
     case "mcp_auth_completed" /* MCP_AUTH_COMPLETED */:
       return {
-        type: "mcp_auth_completed",
+        type: DroidMessageType.McpAuthCompleted,
         serverName: notification.serverName,
         outcome: notification.outcome,
         message: notification.message
       };
     default:
-      console.warn(
-        `[droid-sdk] Unknown notification type: ${String(notification.type)}`
-      );
       return null;
   }
 }
 var StreamStateTracker = class {
-  /** Whether we have ever seen a non-idle state. */
   hasBeenNonIdle = false;
-  /** Last-seen token usage update (to attach to TurnComplete). */
   lastTokenUsage = null;
-  /**
-   * Process a DroidMessage and return any additional messages that should be
-   * emitted (e.g. TurnComplete sentinel).
-   *
-   * @param message - The DroidMessage to process.
-   * @returns An array of additional messages to emit (may be empty).
-   */
+  toolNameMap = /* @__PURE__ */ new Map();
+  getToolName(toolUseId) {
+    return this.toolNameMap.get(toolUseId) ?? "";
+  }
   processMessage(message) {
     const additional = [];
-    if (message.type === "token_usage_update") {
+    if (message.type === DroidMessageType.ToolUse) {
+      this.toolNameMap.set(message.toolUseId, message.toolName);
+    }
+    if (message.type === DroidMessageType.ToolResult) {
+      message = { ...message, toolName: this.getToolName(message.toolUseId) };
+    }
+    if (message.type === DroidMessageType.TokenUsageUpdate) {
       this.lastTokenUsage = message;
     }
-    if (message.type === "working_state_changed") {
+    if (message.type === DroidMessageType.WorkingStateChanged) {
       if (message.state !== "idle" /* Idle */) {
         this.hasBeenNonIdle = true;
       } else if (this.hasBeenNonIdle) {
         additional.push({
-          type: "turn_complete",
+          type: DroidMessageType.TurnComplete,
           tokenUsage: this.lastTokenUsage
         });
         this.hasBeenNonIdle = false;
       }
     }
-    return additional;
-  }
-  /**
-   * Reset the tracker for a new turn/stream call.
-   */
-  reset() {
-    this.hasBeenNonIdle = false;
-    this.lastTokenUsage = null;
+    return { message, additional };
   }
 };
 function normalizeToolResultContent(content) {
@@ -3045,124 +3062,469 @@ function normalizeToolResultContent(content) {
   return String(content);
 }
 
-// src/query.ts
-function query(options) {
-  let transport = null;
-  let client = null;
-  let sessionId = null;
-  let aborted = false;
-  const messageQueue = [];
-  let resolveWaiting = null;
-  let streamDone = false;
-  function enqueueMessage(msg) {
-    messageQueue.push(msg);
-    if (resolveWaiting) {
-      const resolve = resolveWaiting;
-      resolveWaiting = null;
-      resolve();
-    }
+// src/helpers.ts
+function wireAbortSignal(signal, onAbort) {
+  if (!signal) return () => {
+  };
+  if (signal.aborted) {
+    onAbort();
+    return () => {
+    };
+  } else {
+    const listener = () => onAbort();
+    signal.addEventListener("abort", listener, { once: true });
+    return () => signal.removeEventListener("abort", listener);
   }
-  function signalDone() {
-    streamDone = true;
-    if (resolveWaiting) {
-      const resolve = resolveWaiting;
-      resolveWaiting = null;
-      resolve();
+}
+function extractInnerNotification(notification) {
+  const parsed = SessionNotificationSchema.safeParse(notification);
+  return parsed.success ? parsed.data.params.notification : null;
+}
+var MessageBridge = class {
+  _queue = [];
+  _resolveWaiting = null;
+  _done = false;
+  _stateTracker = new StreamStateTracker();
+  notificationHandler = (notification) => {
+    const inner = extractInnerNotification(notification);
+    if (!inner) return;
+    const converted = convertNotificationToStreamMessage(inner);
+    if (converted === null) return;
+    const messages = Array.isArray(converted) ? converted : [converted];
+    for (const msg of messages) {
+      const { message, additional } = this._stateTracker.processMessage(msg);
+      this._enqueue(message);
+      for (const extra of additional) {
+        this._enqueue(extra);
+        if (extra.type === DroidMessageType.TurnComplete) {
+          this._signalDone();
+        }
+      }
     }
+  };
+  signalDone() {
+    this._signalDone();
   }
-  async function* generateMessages() {
-    if (options.transport) {
-      transport = options.transport;
-    } else {
-      const transportOptions = {
-        execPath: options.execPath,
-        execArgs: options.execArgs,
-        cwd: options.cwd,
-        env: options.env
-      };
-      const processTransport = new ProcessTransport(transportOptions);
-      await processTransport.connect();
-      transport = processTransport;
-    }
-    client = new DroidClient({ transport });
-    if (options.permissionHandler) {
-      client.setPermissionHandler(options.permissionHandler);
-    }
-    if (options.askUserHandler) {
-      client.setAskUserHandler(options.askUserHandler);
-    }
-    const stateTracker = new StreamStateTracker();
-    client.onNotification((notification) => {
-      const params = notification["params"];
-      const innerNotification = params?.["notification"];
-      if (!innerNotification) {
-        return;
+  async *messages() {
+    while (true) {
+      while (this._queue.length > 0) {
+        const msg = this._queue.shift();
+        yield msg;
+        if (msg.type === DroidMessageType.TurnComplete) {
+          return;
+        }
       }
-      const converted = convertNotificationToStreamMessage(
-        innerNotification
-      );
-      if (converted === null) {
+      if (this._done && this._queue.length === 0) {
         return;
       }
-      const messages = Array.isArray(converted) ? converted : [converted];
-      for (const msg of messages) {
-        enqueueMessage(msg);
-        const additional = stateTracker.processMessage(msg);
-        for (const extra of additional) {
-          enqueueMessage(extra);
-          if (extra.type === "turn_complete") {
-            signalDone();
-          }
-        }
-      }
-    });
-    const initParams = {
-      machineId: options.machineId ?? "default",
-      cwd: options.cwd ?? "."
+      await new Promise((resolve2) => {
+        this._resolveWaiting = resolve2;
+      });
+    }
+  }
+  _enqueue(msg) {
+    this._queue.push(msg);
+    if (this._resolveWaiting) {
+      const resolve2 = this._resolveWaiting;
+      this._resolveWaiting = null;
+      resolve2();
+    }
+  }
+  _signalDone() {
+    this._done = true;
+    if (this._resolveWaiting) {
+      const resolve2 = this._resolveWaiting;
+      this._resolveWaiting = null;
+      resolve2();
+    }
+  }
+};
+async function createTransport(options) {
+  if (options.transport) {
+    return options.transport;
+  }
+  const transportOptions = {
+    execPath: options.execPath,
+    execArgs: options.execArgs,
+    cwd: options.cwd,
+    env: options.env
+  };
+  const processTransport = new ProcessTransport(transportOptions);
+  await processTransport.connect();
+  return processTransport;
+}
+function setupClientHandlers(client, options) {
+  if (options.permissionHandler) {
+    client.setPermissionHandler(options.permissionHandler);
+  }
+  if (options.askUserHandler) {
+    client.setAskUserHandler(options.askUserHandler);
+  }
+}
+async function createConfiguredClient(options) {
+  const transport = await createTransport(options);
+  const client = new DroidClient({ transport });
+  setupClientHandlers(client, options);
+  return { transport, client };
+}
+async function closeQuietly(resource) {
+  if (!resource) {
+    return;
+  }
+  try {
+    await resource.close();
+  } catch {
+  }
+}
+function buildInitParams(options) {
+  return {
+    machineId: options.machineId ?? "default",
+    cwd: options.cwd ?? ".",
+    ...options.modelId !== void 0 && { modelId: options.modelId },
+    ...options.autonomyLevel !== void 0 && {
+      autonomyLevel: options.autonomyLevel
+    },
+    ...options.interactionMode !== void 0 && {
+      interactionMode: options.interactionMode
+    },
+    ...options.reasoningEffort !== void 0 && {
+      reasoningEffort: options.reasoningEffort
+    },
+    ...options.specModeModelId !== void 0 && {
+      specModeModelId: options.specModeModelId
+    },
+    ...options.specModeReasoningEffort !== void 0 && {
+      specModeReasoningEffort: options.specModeReasoningEffort
+    },
+    ...options.mcpServers !== void 0 && {
+      mcpServers: options.mcpServers
+    },
+    ...options.enabledToolIds !== void 0 && {
+      enabledToolIds: options.enabledToolIds
+    },
+    ...options.disabledToolIds !== void 0 && {
+      disabledToolIds: options.disabledToolIds
+    },
+    tags: [...options.tags ?? [], SDK_TAG]
+  };
+}
+
+// src/mcp.ts
+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");
+function tool(name, description, inputSchemaOrHandler, handler) {
+  if (typeof inputSchemaOrHandler === "function") {
+    const actualHandler = inputSchemaOrHandler;
+    return {
+      name,
+      description,
+      handler: (input) => actualHandler(input)
+    };
+  }
+  if (!handler) {
+    throw new Error(`Missing handler for SDK MCP tool "${name}"`);
+  }
+  const inputObjectSchema = import_zod8.z.object(inputSchemaOrHandler);
+  return {
+    name,
+    description,
+    inputSchema: inputSchemaOrHandler,
+    handler: (input) => handler(inputObjectSchema.parse(input))
+  };
+}
+function isSdkMcpServer(server) {
+  return server instanceof SdkMcpServer;
+}
+function toCallToolResult(result) {
+  if (typeof result === "string") {
+    return {
+      content: [{ type: "text", text: result }]
     };
-    if (options.modelId !== void 0) {
-      initParams.modelId = options.modelId;
+  }
+  return result;
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  if (chunks.length === 0) {
+    return void 0;
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function writeJsonError(res, statusCode, message) {
+  if (res.headersSent) {
+    return;
+  }
+  res.writeHead(statusCode, { "content-type": "application/json" });
+  res.end(
+    JSON.stringify({
+      jsonrpc: JSONRPC_VERSION,
+      error: { code: -32603 /* INTERNAL_ERROR */, message },
+      id: null
+    })
+  );
+}
+var SdkMcpServer = class {
+  name;
+  version;
+  tools;
+  _httpServer = null;
+  _url = null;
+  constructor(options) {
+    this.name = options.name;
+    this.version = options.version ?? "1.0.0";
+    this.tools = options.tools;
+  }
+  get config() {
+    if (!this._url) {
+      return null;
     }
-    if (options.autonomyLevel !== void 0) {
-      initParams.autonomyLevel = options.autonomyLevel;
+    return {
+      type: "http" /* Http */,
+      name: this.name,
+      url: this._url,
+      headers: []
+    };
+  }
+  async start() {
+    if (this.config) {
+      return this.config;
     }
-    if (options.interactionMode !== void 0) {
-      initParams.interactionMode = options.interactionMode;
+    this._httpServer = import_node_http.default.createServer((req, res) => {
+      void this.handleRequest(req, res);
+    });
+    this._httpServer.listen(0, "127.0.0.1");
+    await (0, import_node_events.once)(this._httpServer, "listening");
+    const address = this._httpServer.address();
+    if (!address || typeof address === "string") {
+      throw new Error("Unable to determine SDK MCP server address");
     }
-    if (options.reasoningEffort !== void 0) {
-      initParams.reasoningEffort = options.reasoningEffort;
+    this._url = `http://127.0.0.1:${address.port}/mcp`;
+    const config = this.config;
+    if (!config) {
+      throw new Error("Unable to start SDK MCP server");
     }
-    if (options.mcpServers !== void 0) {
-      initParams.mcpServers = options.mcpServers;
+    return config;
+  }
+  async close() {
+    const server = this._httpServer;
+    this._httpServer = null;
+    this._url = null;
+    if (!server) {
+      return;
     }
-    if (options.enabledToolIds !== void 0) {
-      initParams.enabledToolIds = options.enabledToolIds;
+    server.closeAllConnections?.();
+    server.close();
+    await (0, import_node_events.once)(server, "close");
+  }
+  createMcpServer() {
+    const server = new import_mcp4.McpServer({
+      name: this.name,
+      version: this.version
+    });
+    for (const sdkTool of this.tools) {
+      server.registerTool(
+        sdkTool.name,
+        {
+          description: sdkTool.description,
+          ...sdkTool.inputSchema && {
+            inputSchema: sdkTool.inputSchema
+          }
+        },
+        async (input) => toCallToolResult(await sdkTool.handler(input))
+      );
     }
-    const initResult = await client.initializeSession(
-      initParams
-    );
-    sessionId = initResult.sessionId;
-    await client.addUserMessage({ text: options.prompt });
+    return server;
+  }
+  async handleRequest(req, res) {
+    if (req.url !== "/mcp") {
+      res.writeHead(404).end();
+      return;
+    }
+    if (req.method !== "POST") {
+      res.writeHead(405).end();
+      return;
+    }
+    const server = this.createMcpServer();
+    const transport = new import_streamableHttp.StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0
+    });
+    res.on("close", () => {
+      void transport.close();
+      void server.close();
+    });
     try {
-      while (true) {
+      const body = await readJsonBody(req);
+      await server.connect(transport);
+      await transport.handleRequest(req, res, body);
+    } catch (error) {
+      writeJsonError(
+        res,
+        500,
+        error instanceof Error ? error.message : "Internal server error"
+      );
+      await transport.close();
+      await server.close();
+    }
+  }
+};
+function createSdkMcpServer(options) {
+  return new SdkMcpServer(options);
+}
+async function startSdkMcpServers(servers) {
+  if (!servers) {
+    return { cleanup: async () => {
+    } };
+  }
+  const startedServers = [];
+  const mcpServers = [];
+  try {
+    for (const server of servers) {
+      if (isSdkMcpServer(server)) {
+        mcpServers.push(await server.start());
+        startedServers.push(server);
+      } else {
+        mcpServers.push(server);
+      }
+    }
+  } catch (error) {
+    await Promise.all(startedServers.map((server) => server.close()));
+    throw error;
+  }
+  return {
+    mcpServers,
+    cleanup: async () => {
+      await Promise.all(startedServers.map((server) => server.close()));
+    }
+  };
+}
+
+// src/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) {
-          return;
+          throw new Error("Query aborted before initialization");
         }
-        while (messageQueue.length > 0) {
-          const msg = messageQueue.shift();
-          yield msg;
-          if (msg.type === "turn_complete") {
-            return;
-          }
-        }
-        if (streamDone && messageQueue.length === 0) {
-          return;
+        const configuredClient = await createConfiguredClient(options);
+        transport = configuredClient.transport;
+        client = configuredClient.client;
+        client.onNotification(bridge.notificationHandler);
+        if (aborted) {
+          throw new Error("Query aborted before initialization");
         }
-        await new Promise((resolve) => {
-          resolveWaiting = resolve;
-        });
+        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;
       }
-    } finally {
+    })();
+    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();
@@ -3170,310 +3532,273 @@ function query(options) {
     try {
       yield* generator;
     } finally {
-      if (client) {
-        try {
-          await client.close();
-        } catch {
-        }
-        client = null;
-      } else if (transport) {
-        try {
-          await transport.close();
-        } catch {
-        }
-      }
-      transport = null;
+      cleanupAbortSignal();
+      await closeActiveResources();
     }
   }
-  const wrapped = wrappedGenerator();
-  const droidQuery = wrapped;
-  Object.defineProperties(droidQuery, {
-    interrupt: {
-      value: async function interrupt() {
-        if (client && !aborted) {
-          await client.interruptSession();
-        }
-      },
-      writable: false,
-      enumerable: true
-    },
-    abort: {
-      value: function abort() {
-        aborted = true;
-        signalDone();
-        if (client) {
-          void client.close().catch(() => {
-          });
-          client = null;
-        } else if (transport) {
-          void transport.close().catch(() => {
-          });
-        }
-        transport = null;
-      },
-      writable: false,
-      enumerable: true
+  const droidQuery = new DroidQueryImpl(
+    wrappedGenerator(),
+    () => sessionId,
+    () => initResult,
+    () => ensureInitialized(),
+    async () => {
+      if (client && !aborted) {
+        await client.interruptSession();
+      }
     },
-    sessionId: {
-      get() {
-        return sessionId;
-      },
-      enumerable: true
+    () => {
+      aborted = true;
+      bridge.signalDone();
+      cleanupAbortSignal();
+      void closeActiveResources();
     }
-  });
+  );
+  cleanupAbortSignal = wireAbortSignal(
+    options.abortSignal,
+    () => droidQuery.abort()
+  );
   return droidQuery;
 }
 
 // src/session.ts
+function getAbortError(signal) {
+  if (signal.reason instanceof Error) {
+    return signal.reason;
+  }
+  return new Error(
+    typeof signal.reason === "string" ? signal.reason : "Operation aborted"
+  );
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw getAbortError(signal);
+  }
+}
+function parseJsonObject(text) {
+  try {
+    const parsed = JSON.parse(text);
+    const result = JsonObjectSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}
+function extractAssistantText(message) {
+  if (message.type !== DroidMessageType.CreateMessage) {
+    return "";
+  }
+  if (message.role !== FactoryDroidMessageRole.Assistant) {
+    return "";
+  }
+  return message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
 var DroidSession = class {
   _client;
   _sessionId;
   _initResult;
   _closed = false;
+  _cleanupAbortSignal = null;
+  _cleanupCallbacks = [];
   /** @internal */
   constructor(client, sessionId, initResult) {
     this._client = client;
     this._sessionId = sessionId;
     this._initResult = initResult;
   }
-  // ------------------------------------------------------------------
-  // Properties
-  // ------------------------------------------------------------------
-  /** The session ID. */
   get sessionId() {
     return this._sessionId;
   }
-  /** The result from session initialization or loading. */
   get initResult() {
     return this._initResult;
   }
-  // ------------------------------------------------------------------
-  // Messaging
-  // ------------------------------------------------------------------
-  /**
-   * Send a message and return a streaming async generator of DroidMessage events.
-   *
-   * The generator yields messages until a TurnComplete event is received,
-   * signaling the end of the agent's turn.
-   *
-   * @param text - The user message text.
-   * @param options - Optional images/files to include.
-   * @returns An async generator yielding DroidMessage events.
-   */
+  /** @internal */
+  setAbortSignalCleanup(cleanup) {
+    this._cleanupAbortSignal = cleanup;
+  }
+  /** @internal */
+  addCleanup(cleanup) {
+    this._cleanupCallbacks.push(cleanup);
+  }
+  /** Yields {@link DroidMessage} events until `turn_complete`. */
   async *stream(text, options) {
     this._ensureNotClosed();
-    const messageQueue = [];
-    let resolveWaiting = null;
-    let streamDone = false;
-    function enqueueMessage(msg) {
-      messageQueue.push(msg);
-      if (resolveWaiting) {
-        const resolve = resolveWaiting;
-        resolveWaiting = null;
-        resolve();
-      }
-    }
-    function signalDone() {
-      streamDone = true;
-      if (resolveWaiting) {
-        const resolve = resolveWaiting;
-        resolveWaiting = null;
-        resolve();
-      }
-    }
-    const stateTracker = new StreamStateTracker();
-    const unsubscribe = this._client.onNotification((notification) => {
-      const params = notification["params"];
-      const innerNotification = params?.["notification"];
-      if (!innerNotification) {
-        return;
-      }
-      const converted = convertNotificationToStreamMessage(
-        innerNotification
-      );
-      if (converted === null) {
-        return;
-      }
-      const messages = Array.isArray(converted) ? converted : [converted];
-      for (const msg of messages) {
-        enqueueMessage(msg);
-        const additional = stateTracker.processMessage(msg);
-        for (const extra of additional) {
-          enqueueMessage(extra);
-          if (extra.type === "turn_complete") {
-            signalDone();
-          }
-        }
-      }
+    throwIfAborted(options?.abortSignal);
+    const bridge = new MessageBridge();
+    const unsubscribe = this._client.onNotification(bridge.notificationHandler);
+    let resolveAbort = () => {
+    };
+    const abortPromise = new Promise((resolve2) => {
+      resolveAbort = resolve2;
     });
-    try {
-      await this._client.addUserMessage({
-        text,
-        images: options?.images,
-        files: options?.files
+    const cleanupAbortSignal = wireAbortSignal(options?.abortSignal, () => {
+      bridge.signalDone();
+      resolveAbort();
+      void this._client.interruptSession().catch(() => {
       });
-      while (true) {
-        while (messageQueue.length > 0) {
-          const msg = messageQueue.shift();
-          yield msg;
-          if (msg.type === "turn_complete") {
-            return;
-          }
-        }
-        if (streamDone && messageQueue.length === 0) {
-          return;
-        }
-        await new Promise((resolve) => {
-          resolveWaiting = resolve;
-        });
+    });
+    try {
+      await Promise.race([
+        this._client.addUserMessage({
+          text,
+          images: options?.images,
+          files: options?.files,
+          outputFormat: options?.outputFormat
+        }),
+        abortPromise
+      ]);
+      throwIfAborted(options?.abortSignal);
+      for await (const msg of bridge.messages()) {
+        throwIfAborted(options?.abortSignal);
+        yield msg;
       }
+      throwIfAborted(options?.abortSignal);
     } finally {
+      cleanupAbortSignal();
       unsubscribe();
     }
   }
-  /**
-   * Send a message and collect the complete response (non-streaming).
-   *
-   * Internally consumes all stream messages and returns an aggregated
-   * {@link DroidResult} with the concatenated text, all messages, and
-   * final token usage.
-   *
-   * @param text - The user message text.
-   * @param options - Optional images/files to include.
-   * @returns Aggregated result with text, messages, and token usage.
-   */
+  /** 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 === "assistant_text_delta") {
+      if (msg.type === DroidMessageType.AssistantTextDelta) {
         fullText += msg.text;
       }
-      if (msg.type === "token_usage_update") {
+      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 === "turn_complete" && msg.tokenUsage) {
-        lastTokenUsage = msg.tokenUsage;
+      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
+      tokenUsage: lastTokenUsage,
+      durationMs: Date.now() - startedAt,
+      turnCount,
+      error: firstError,
+      structuredOutput,
+      success: firstError === null
     };
   }
-  // ------------------------------------------------------------------
-  // Session control
-  // ------------------------------------------------------------------
-  /**
-   * Interrupt the current agent turn.
-   *
-   * Sends an interrupt request. The agent will stop after completing
-   * its current operation.
-   */
   async interrupt() {
     this._ensureNotClosed();
     await this._client.interruptSession();
   }
-  /**
-   * Close the session and release all resources.
-   *
-   * Closes the underlying transport and rejects any pending requests.
-   * After close, the session cannot be used.
-   */
   async close() {
     if (this._closed) {
       return;
     }
     this._closed = true;
-    await this._client.close();
+    this._cleanupAbortSignal?.();
+    this._cleanupAbortSignal = null;
+    try {
+      await this._client.close();
+    } finally {
+      const cleanups = this._cleanupCallbacks.splice(0);
+      await Promise.all(cleanups.map((cleanup) => cleanup()));
+    }
   }
-  // ------------------------------------------------------------------
-  // Settings
-  // ------------------------------------------------------------------
-  /**
-   * Update session settings (model, reasoning effort, autonomy, etc.).
-   *
-   * @param params - Partial settings to update.
-   */
   async updateSettings(params) {
     this._ensureNotClosed();
     return this._client.updateSessionSettings(params);
   }
-  // ------------------------------------------------------------------
-  // MCP methods
-  // ------------------------------------------------------------------
-  /**
-   * Add an MCP server to the session.
-   */
+  async enterSpecMode(params = {}) {
+    this._ensureNotClosed();
+    return this._client.updateSessionSettings({
+      interactionMode: "spec" /* Spec */,
+      ...params
+    });
+  }
   async addMcpServer(params) {
     this._ensureNotClosed();
     return this._client.addMcpServer(params);
   }
-  /**
-   * Remove an MCP server from the session.
-   */
   async removeMcpServer(params) {
     this._ensureNotClosed();
     return this._client.removeMcpServer(params);
   }
-  /**
-   * Toggle an MCP server on or off.
-   */
   async toggleMcpServer(params) {
     this._ensureNotClosed();
     return this._client.toggleMcpServer(params);
   }
-  /**
-   * List MCP servers and their status.
-   */
   async listMcpServers() {
     this._ensureNotClosed();
     return this._client.listMcpServers();
   }
-  /**
-   * List available MCP tools.
-   */
   async listMcpTools() {
     this._ensureNotClosed();
     return this._client.listMcpTools();
   }
-  /**
-   * Authenticate an MCP server (OAuth flow).
-   */
+  async listTools(params = {}) {
+    this._ensureNotClosed();
+    return this._client.listTools(params);
+  }
   async authenticateMcpServer(params) {
     this._ensureNotClosed();
     return this._client.authenticateMcpServer(params);
   }
-  // ------------------------------------------------------------------
-  // Skills
-  // ------------------------------------------------------------------
-  /**
-   * List available skills.
-   */
   async listSkills() {
     this._ensureNotClosed();
     return this._client.listSkills();
   }
-  // ------------------------------------------------------------------
-  // Notification subscription
-  // ------------------------------------------------------------------
-  /**
-   * Register a callback for incoming notification messages.
-   *
-   * @param callback - Invoked with the notification object.
-   * @param filter - Optional filter to only receive specific notification types.
-   * @returns An unsubscribe function.
-   */
+  async getRewindInfo(params) {
+    this._ensureNotClosed();
+    return this._client.getRewindInfo(params);
+  }
+  async executeRewind(params) {
+    this._ensureNotClosed();
+    return this._client.executeRewind(params);
+  }
+  async compactSession(params) {
+    this._ensureNotClosed();
+    return this._client.compactSession(params ?? {});
+  }
+  async forkSession() {
+    this._ensureNotClosed();
+    return this._client.forkSession();
+  }
+  async getContextStats() {
+    this._ensureNotClosed();
+    return this._client.getContextStats();
+  }
+  async renameSession(params) {
+    this._ensureNotClosed();
+    return this._client.renameSession(params);
+  }
   onNotification(callback, filter) {
     return this._client.onNotification(callback, filter);
   }
-  // ------------------------------------------------------------------
-  // Internal
-  // ------------------------------------------------------------------
   _ensureNotClosed() {
     if (this._closed) {
       throw new ConnectionError(
@@ -3483,98 +3808,290 @@ var DroidSession = class {
   }
 };
 async function createSession(options = {}) {
-  let transport;
-  if (options.transport) {
-    transport = options.transport;
-  } else {
-    const transportOptions = {
-      execPath: options.execPath,
-      execArgs: options.execArgs,
-      cwd: options.cwd,
-      env: options.env
+  const { client } = await createConfiguredClient(options);
+  let cleanupInitAbortSignal = options.abortSignal?.aborted ? () => {
+  } : wireAbortSignal(options.abortSignal, () => {
+    void closeQuietly(client);
+  });
+  let sdkMcpServers;
+  try {
+    sdkMcpServers = await startSdkMcpServers(options.mcpServers);
+    const initParams = buildInitParams({
+      ...options,
+      mcpServers: sdkMcpServers.mcpServers
+    });
+    const initResult = await client.initializeSession(initParams);
+    const session = new DroidSession(client, initResult.sessionId, initResult);
+    session.addCleanup(sdkMcpServers.cleanup);
+    cleanupInitAbortSignal();
+    cleanupInitAbortSignal = () => {
     };
-    const processTransport = new ProcessTransport(transportOptions);
-    await processTransport.connect();
-    transport = processTransport;
-  }
-  const client = new DroidClient({ transport });
-  if (options.permissionHandler) {
-    client.setPermissionHandler(options.permissionHandler);
-  }
-  if (options.askUserHandler) {
-    client.setAskUserHandler(options.askUserHandler);
+    session.setAbortSignalCleanup(
+      wireAbortSignal(options.abortSignal, () => void session.close())
+    );
+    return session;
+  } catch (error) {
+    cleanupInitAbortSignal();
+    await sdkMcpServers?.cleanup();
+    await closeQuietly(client);
+    throw error;
   }
-  const initParams = {
-    machineId: options.machineId ?? "default",
-    cwd: options.cwd ?? "."
-  };
-  if (options.modelId !== void 0) {
-    initParams.modelId = options.modelId;
+}
+async function resumeSession(sessionId, options = {}) {
+  const { client } = await createConfiguredClient(options);
+  let sdkMcpServers;
+  try {
+    sdkMcpServers = await startSdkMcpServers(options.mcpServers);
+    const loadParams = {
+      sessionId,
+      mcpServers: sdkMcpServers.mcpServers
+    };
+    const loadResult = await client.loadSession(loadParams);
+    const session = new DroidSession(client, sessionId, loadResult);
+    session.addCleanup(sdkMcpServers.cleanup);
+    session.setAbortSignalCleanup(
+      wireAbortSignal(options.abortSignal, () => void session.close())
+    );
+    return session;
+  } catch (error) {
+    await sdkMcpServers?.cleanup();
+    await closeQuietly(client);
+    throw error;
   }
-  if (options.autonomyLevel !== void 0) {
-    initParams.autonomyLevel = options.autonomyLevel;
+}
+
+// src/run.ts
+async function run(text, options = {}) {
+  const session = await createSession(options);
+  try {
+    return await session.send(text, options);
+  } finally {
+    await session.close();
   }
-  if (options.interactionMode !== void 0) {
-    initParams.interactionMode = options.interactionMode;
+}
+
+// src/session-discovery.ts
+var fs = __toESM(require("fs"), 1);
+var os = __toESM(require("os"), 1);
+var path = __toESM(require("path"), 1);
+var FAVORITES_FILE = ".favorites";
+var SESSION_EXTENSION = ".jsonl";
+var SETTINGS_SUFFIX = ".settings.json";
+var MISSION_TAG_PREFIX = "mission:";
+var MISSION_ID_METADATA_KEY = "missionId";
+var DECOMP_SESSION_TYPE_TAG = "decompSessionType";
+var DECOMP_SESSION_TYPE_METADATA_KEY = "value";
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+var TAB = 9;
+var PARSE_OVERSAMPLE = 20;
+function readFileBuffer(filePath) {
+  try {
+    return fs.readFileSync(filePath);
+  } catch {
+    return null;
   }
-  if (options.reasoningEffort !== void 0) {
-    initParams.reasoningEffort = options.reasoningEffort;
+}
+function parseJsonBuffer(buf) {
+  try {
+    return JSON.parse(buf.toString("utf-8"));
+  } catch {
+    return null;
   }
-  if (options.mcpServers !== void 0) {
-    initParams.mcpServers = options.mcpServers;
+}
+function scanBufferForLines(buf) {
+  let nonEmptyLineCount = 0;
+  let firstLineEnd = -1;
+  let currentLineHasContent = false;
+  for (let i = 0; i < buf.length; i++) {
+    const ch = buf[i];
+    if (ch === LF) {
+      if (currentLineHasContent) nonEmptyLineCount++;
+      if (firstLineEnd === -1) firstLineEnd = i;
+      currentLineHasContent = false;
+    } else if (ch !== CR && ch !== SPACE && ch !== TAB) {
+      currentLineHasContent = true;
+    }
   }
-  if (options.enabledToolIds !== void 0) {
-    initParams.enabledToolIds = options.enabledToolIds;
+  if (currentLineHasContent) nonEmptyLineCount++;
+  const end = firstLineEnd === -1 ? buf.length : firstLineEnd > 0 && buf[firstLineEnd - 1] === CR ? firstLineEnd - 1 : firstLineEnd;
+  return {
+    firstLine: buf.subarray(0, end),
+    nonEmptyLineCount
+  };
+}
+function loadFavorites(sessionsDir) {
+  const buf = readFileBuffer(path.join(sessionsDir, FAVORITES_FILE));
+  if (!buf) return /* @__PURE__ */ new Set();
+  const parsed = parseJsonBuffer(buf);
+  if (!Array.isArray(parsed)) return /* @__PURE__ */ new Set();
+  return new Set(parsed.filter((id) => typeof id === "string"));
+}
+function loadSettingsFile(directory, sessionId) {
+  const buf = readFileBuffer(
+    path.join(directory, `${sessionId}${SETTINGS_SUFFIX}`)
+  );
+  if (!buf) return null;
+  const parsed = parseJsonBuffer(buf);
+  if (parsed === null) return null;
+  const result = SessionSettingsFileSchema.safeParse(parsed);
+  return result.success ? result.data : null;
+}
+function getMissionMetadataFromTags(settings) {
+  if (!settings?.tags) return {};
+  const missionTag = settings.tags.find(
+    (tag) => tag.name.startsWith(MISSION_TAG_PREFIX)
+  );
+  const roleTag = settings.tags.find(
+    (tag) => tag.name === DECOMP_SESSION_TYPE_TAG
+  );
+  return {
+    decompMissionId: missionTag?.metadata?.[MISSION_ID_METADATA_KEY],
+    decompSessionType: roleTag?.metadata?.[DECOMP_SESSION_TYPE_METADATA_KEY]
+  };
+}
+function parseSessionFile(candidate, ctx) {
+  const buf = readFileBuffer(candidate.sessionPath);
+  if (!buf) return null;
+  const scanned = scanBufferForLines(buf);
+  const firstParsed = parseJsonBuffer(scanned.firstLine);
+  if (firstParsed === null) return null;
+  const firstResult = SessionStartEventSchema.safeParse(firstParsed);
+  if (!firstResult.success) return null;
+  const summary = firstResult.data;
+  if (ctx.requiredCwd !== void 0 && (summary.cwd === void 0 || path.resolve(summary.cwd) !== ctx.requiredCwd)) {
+    return null;
   }
+  const settingsName = `${candidate.sessionId}${SETTINGS_SUFFIX}`;
+  const settings = candidate.siblingNames.has(settingsName) ? loadSettingsFile(candidate.directory, candidate.sessionId) : null;
+  if (settings?.archivedAt) return null;
+  const tagMeta = getMissionMetadataFromTags(settings);
+  const decompSessionType = summary.decompSessionType ?? SessionStartEventSchema.shape.decompSessionType.safeParse(
+    tagMeta.decompSessionType
+  ).data;
+  const messageCount = Math.max(0, scanned.nonEmptyLineCount - 1);
+  return {
+    id: candidate.sessionId,
+    title: summary.title ?? "",
+    sessionTitle: summary.sessionTitle,
+    owner: summary.owner ?? "",
+    messageCount,
+    modifiedTime: candidate.stats.mtime,
+    createdTime: candidate.stats.birthtime || candidate.stats.ctime,
+    isFavorite: ctx.favorites.has(candidate.sessionId),
+    cwd: summary.cwd,
+    decompSessionType,
+    decompMissionId: tagMeta.decompMissionId ?? summary.decompMissionId
+  };
+}
+function readDirEntries(directory) {
   try {
-    const initResult = await client.initializeSession(
-      initParams
-    );
-    return new DroidSession(client, initResult.sessionId, initResult);
-  } catch (error) {
+    return fs.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function collectCandidates(directory, entries) {
+  const siblingNames = new Set(entries.map((e) => e.name));
+  const candidates = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) continue;
+    if (!entry.name.endsWith(SESSION_EXTENSION)) continue;
+    const sessionPath = path.join(directory, entry.name);
+    let stats;
     try {
-      await client.close();
+      stats = fs.statSync(sessionPath);
     } catch {
+      continue;
     }
-    throw error;
+    candidates.push({
+      sessionId: entry.name.slice(0, -SESSION_EXTENSION.length),
+      sessionPath,
+      directory,
+      siblingNames,
+      stats
+    });
   }
+  return candidates;
 }
-async function resumeSession(sessionId, options = {}) {
-  let transport;
-  if (options.transport) {
-    transport = options.transport;
-  } else {
-    const transportOptions = {
-      execPath: options.execPath,
-      execArgs: options.execArgs,
-      cwd: options.cwd,
-      env: options.env
-    };
-    const processTransport = new ProcessTransport(transportOptions);
-    await processTransport.connect();
-    transport = processTransport;
+function parseUpTo(candidates, ctx, limit) {
+  const out = [];
+  for (const candidate of candidates) {
+    if (limit !== void 0 && out.length >= limit) break;
+    const metadata = parseSessionFile(candidate, ctx);
+    if (metadata) out.push(metadata);
   }
-  const client = new DroidClient({ transport });
-  if (options.permissionHandler) {
-    client.setPermissionHandler(options.permissionHandler);
-  }
-  if (options.askUserHandler) {
-    client.setAskUserHandler(options.askUserHandler);
+  return out;
+}
+function sanitizePathToDirectoryName(cwd) {
+  let expandedPath = cwd;
+  if (cwd.startsWith("~/") || cwd === "~") {
+    expandedPath = path.join(os.homedir(), cwd.slice(1));
   }
-  const loadParams = {
-    sessionId,
-    mcpServers: options.mcpServers
-  };
+  const absolutePath = path.resolve(expandedPath);
+  let canonicalPath = absolutePath;
   try {
-    const loadResult = await client.loadSession(loadParams);
-    return new DroidSession(client, sessionId, loadResult);
-  } catch (error) {
-    try {
-      await client.close();
-    } catch {
+    canonicalPath = fs.realpathSync(absolutePath);
+  } catch {
+    canonicalPath = absolutePath;
+  }
+  const normalized = canonicalPath.replace(/[\\/]+$/, "");
+  if (process.platform === "win32") {
+    return `-${normalized.replace(/^([A-Z]):/i, "$1").replace(/[\\/]+/g, "-")}`;
+  }
+  return `-${normalized.replace(/^\/+/, "").replace(/\/+/g, "-")}`;
+}
+function getDefaultSessionsDir() {
+  return path.join(os.homedir(), ".factory", "sessions");
+}
+async function listSessions(options = {}) {
+  const sessionsDir = options.sessionsDir ?? getDefaultSessionsDir();
+  const favorites = loadFavorites(sessionsDir);
+  const rootEntries = readDirEntries(sessionsDir);
+  const legacyCandidates = collectCandidates(sessionsDir, rootEntries);
+  const projectCandidates = [];
+  let requiredCwd;
+  if (options.fetchOutsideCWD) {
+    for (const entry of rootEntries) {
+      if (!entry.isDirectory()) continue;
+      if (!entry.name.startsWith("-")) continue;
+      const dir = path.join(sessionsDir, entry.name);
+      projectCandidates.push(...collectCandidates(dir, readDirEntries(dir)));
     }
-    throw error;
+  } else {
+    const normalizedCwd = path.resolve(options.cwd ?? process.cwd());
+    requiredCwd = normalizedCwd;
+    const projectDir = path.join(
+      sessionsDir,
+      sanitizePathToDirectoryName(normalizedCwd)
+    );
+    projectCandidates.push(
+      ...collectCandidates(projectDir, readDirEntries(projectDir))
+    );
+  }
+  const byMtimeDesc = (a, b) => b.stats.mtime.getTime() - a.stats.mtime.getTime();
+  projectCandidates.sort(byMtimeDesc);
+  legacyCandidates.sort(byMtimeDesc);
+  const parseLimit = options.numSessions !== void 0 && options.numSessions >= 0 ? options.numSessions + PARSE_OVERSAMPLE : void 0;
+  const ctx = { favorites };
+  const legacyCtx = requiredCwd !== void 0 ? { favorites, requiredCwd } : ctx;
+  const projectSessions = parseUpTo(projectCandidates, ctx, parseLimit);
+  const legacySessions = parseUpTo(legacyCandidates, legacyCtx, parseLimit);
+  const byId = /* @__PURE__ */ new Map();
+  for (const session of [...projectSessions, ...legacySessions]) {
+    const existing = byId.get(session.id);
+    if (!existing || session.modifiedTime.getTime() > existing.modifiedTime.getTime()) {
+      byId.set(session.id, session);
+    }
+  }
+  const sorted = Array.from(byId.values()).sort(
+    (a, b) => b.modifiedTime.getTime() - a.modifiedTime.getTime()
+  );
+  if (options.numSessions !== void 0 && options.numSessions >= 0) {
+    return sorted.slice(0, options.numSessions);
   }
+  return sorted;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -3607,6 +4124,7 @@ async function resumeSession(sessionId, options = {}) {
   BaseRequestSchema,
   BaseResponseFailureSchema,
   BaseResponseSuccessSchema,
+  COMPACTION_TIMEOUT,
   CancelMcpAuthRequestParamsSchema,
   CancelMcpAuthRequestSchema,
   CancelMcpAuthResponseSchema,
@@ -3617,8 +4135,14 @@ async function resumeSession(sessionId, options = {}) {
   ClearMcpAuthResultSchema,
   CliRequestOrNotificationSchema,
   ClientRequestSchema,
+  CompactSessionRequestParamsSchema,
+  CompactSessionRequestSchema,
+  CompactSessionResponseSchema,
+  CompactSessionResultSchema,
   ConnectionError,
   ContentBlockSchema,
+  ContextStatsAccuracy,
+  ContextStatsSchema,
   CreateMessageNotificationSchema,
   CreateToolConfirmationDetailsSchema,
   DEFAULT_REQUEST_TIMEOUT,
@@ -3632,22 +4156,42 @@ async function resumeSession(sessionId, options = {}) {
   DroidClientMethod,
   DroidErrorType,
   DroidInteractionMode,
+  DroidMessageType,
   DroidServerMethod,
   DroidSession,
   DroidWorkingState,
   DroidWorkingStateChangedNotificationSchema,
   EditToolConfirmationDetailsSchema,
+  EmptyResultSchema,
   ErrorDetailSchema,
   ErrorNotificationSchema,
+  ExecToolInfoSchema,
+  ExecuteRewindRequestParamsSchema,
+  ExecuteRewindRequestSchema,
+  ExecuteRewindResponseSchema,
+  ExecuteRewindResultSchema,
   ExecuteToolConfirmationDetailsSchema,
   ExitSpecModeConfirmationDetailsSchema,
   FACTORY_CLIENT_HEADER,
   FACTORY_CLIENT_VERSION,
   FACTORY_PROTOCOL_VERSION,
+  FactoryDroidMessageRole,
   FactoryDroidMessageSchema,
   FeatureStatus,
   FeatureSuccessState,
   FeatureSuccessStateSchema,
+  ForkSessionRequestParamsSchema,
+  ForkSessionRequestSchema,
+  ForkSessionResponseSchema,
+  ForkSessionResultSchema,
+  GetContextStatsRequestParamsSchema,
+  GetContextStatsRequestSchema,
+  GetContextStatsResponseSchema,
+  GetContextStatsResultSchema,
+  GetRewindInfoRequestParamsSchema,
+  GetRewindInfoRequestSchema,
+  GetRewindInfoResponseSchema,
+  GetRewindInfoResultSchema,
   GitRepoInfoSchema,
   HandoffItemsDismissedEntrySchema,
   HandoffSchema,
@@ -3665,6 +4209,8 @@ async function resumeSession(sessionId, options = {}) {
   InterruptSessionResultSchema,
   IssueSeverity,
   JSONRPC_VERSION,
+  JsonArraySchema,
+  JsonObjectSchema,
   JsonRpcEnvelopeSchema,
   JsonRpcErrorCode,
   JsonRpcErrorSchema,
@@ -3675,6 +4221,7 @@ async function resumeSession(sessionId, options = {}) {
   JsonRpcResponseFailureSchema,
   JsonRpcResponseSchema,
   JsonRpcResponseSuccessSchema,
+  JsonValueSchema,
   KillWorkerSessionRequestParamsSchema,
   KillWorkerSessionRequestSchema,
   KillWorkerSessionResponseSchema,
@@ -3696,6 +4243,10 @@ async function resumeSession(sessionId, options = {}) {
   ListSkillsRequestSchema,
   ListSkillsResponseSchema,
   ListSkillsResultSchema,
+  ListToolsRequestParamsSchema,
+  ListToolsRequestSchema,
+  ListToolsResponseSchema,
+  ListToolsResultSchema,
   LoadSessionRequestParamsSchema,
   LoadSessionRequestSchema,
   LoadSessionResponseSchema,
@@ -3733,6 +4284,8 @@ async function resumeSession(sessionId, options = {}) {
   MissionWorkerCompletedNotificationSchema,
   MissionWorkerStartedNotificationSchema,
   ModelProvider,
+  OutputFormatSchema,
+  OutputFormatType,
   PermissionResolvedNotificationSchema,
   ProcessExitError,
   ProcessTransport,
@@ -3741,26 +4294,40 @@ async function resumeSession(sessionId, options = {}) {
   ProposeMissionConfirmationDetailsSchema,
   ProtocolEngine,
   ProtocolError,
+  REWIND_TIMEOUT,
   ReasoningEffort,
   RedactedThinkingBlockSchema,
   RemoveMcpServerRequestParamsSchema,
   RemoveMcpServerRequestSchema,
   RemoveMcpServerResponseSchema,
   RemoveMcpServerResultSchema,
+  RenameSessionRequestParamsSchema,
+  RenameSessionRequestSchema,
+  RenameSessionResponseSchema,
+  RenameSessionResultSchema,
   RequestPermissionRequestParamsSchema,
   RequestPermissionRequestSchema,
   RequestPermissionResponseSchema,
   RequestPermissionResultSchema,
+  RewindEvictedFileSchema,
+  RewindFileCreationSchema,
+  RewindFileSnapshotSchema,
+  SDK_TAG,
+  SDK_VERSION,
   SESSION_INIT_TIMEOUT,
+  SdkMcpServer,
   SessionError,
+  SessionMetadataSchema,
   SessionNotFoundError,
   SessionNotificationParamsSchema,
   SessionNotificationPayloadSchema,
   SessionNotificationSchema,
   SessionNotificationSchemaList,
   SessionNotificationType,
+  SessionSettingsFileSchema,
   SessionSettingsSchema,
   SessionSourceSchema,
+  SessionStartEventSchema,
   SessionTagSchema,
   SessionTitleUpdatedNotificationSchema,
   SessionTokenUsageChangedNotificationSchema,
@@ -3784,6 +4351,7 @@ async function resumeSession(sessionId, options = {}) {
   SubmitMcpAuthCodeRequestSchema,
   SubmitMcpAuthCodeResponseSchema,
   SubmitMcpAuthCodeResultSchema,
+  SuccessResultSchema,
   TestCaseSchema,
   TestFileSchema,
   TestsSchema,
@@ -3809,6 +4377,7 @@ async function resumeSession(sessionId, options = {}) {
   ToolProgressUpdateSchema,
   ToolResultBlockSchema,
   ToolResultNotificationSchema,
+  ToolSelectionOverridesSchema,
   ToolUseBlockSchema,
   ToolUseSchema,
   TraceContextMetaSchema,
@@ -3825,8 +4394,12 @@ async function resumeSession(sessionId, options = {}) {
   WorkerStartedEntrySchema,
   WorkerStateInfoSchema,
   convertNotificationToStreamMessage,
+  createSdkMcpServer,
   createSession,
+  listSessions,
   query,
-  resumeSession
+  resumeSession,
+  run,
+  tool
 });
 //# sourceMappingURL=index.cjs.map