@factory/droid-sdk 0.6.0 → 0.7.0

package/dist/node.d.mts

@@ -0,0 +1,736 @@
+import { D as DaemonClientTransport, a as DaemonIpcMessageChannel, b as DaemonClientTransportKind, c as DaemonClientTransportEvents, I as InProcessDaemonClientTransportOptions, S as SessionNotificationEvent, R as RequestPermissionEvent, A as AskUserEvent, L as LogMetadata, d as DroidObservability, e as DroidClientOptions, f as InitializeSessionRequestParams, g as InitializeSessionResponse, h as LoadSessionRequestParams, i as LoadSessionResponse, j as AddUserMessageParams, k as AddUserMessageResponse, l as ResolveQueuedUserMessageParams, m as ResolveQueuedUserMessageResponse, n as InterruptSessionParams, o as InterruptSessionResponse, C as CloseSessionParams, p as CloseSessionResponse, K as KillWorkerSessionParams, q as KillWorkerSessionResponse, U as UpdateSessionSettingsRequestParams, r as UpdateSessionSettingsResponse, s as ChangeWorkingDirectoryParams, t as ChangeWorkingDirectoryResponse, u as SettingsLevel, T as ToggleMcpServerResponseSchema, v as AuthenticateMcpServerResponseSchema, w as CancelMcpAuthResponseSchema, x as ClearMcpAuthResponseSchema, y as AddMcpServerRequest, z as AddMcpServerResponseSchema, B as RemoveMcpServerResponseSchema, E as ListMcpRegistryResponseSchema, F as ListMcpToolsResponseSchema, G as ListToolsRequestParams, H as ListToolsResponseSchema, J as ListMcpServersResponseSchema, M as ToggleMcpToolResponseSchema, N as SubmitMcpAuthCodeRequestParamsSchema, O as SubmitMcpAuthCodeResponseSchema, P as SubmitMcpAuthErrorRequestParamsSchema, Q as SubmitMcpAuthErrorResponseSchema, V as ListSkillsResponseSchema, W as SetSkillDisabledRequest, X as SetSkillDisabledResponseSchema, Y as ListCommandsResponseSchema, Z as GetContextStatsResponseSchema, _ as GetContextBreakdownResponseSchema, $ as SubmitBugReportRequest, a0 as SubmitBugReportResponseSchema, a1 as GetRewindInfoResponseSchema, a2 as ExecuteRewindResponseSchema, a3 as CompactSessionResponseSchema, a4 as ForkSessionRequestParamsSchema, a5 as ForkSessionResponseSchema, a6 as RenameSessionRequestParams, a7 as RenameSessionResponseSchema, a8 as WarmupCacheResponseSchema, a9 as RequestPermissionHandlerResult, aa as ToolConfirmationOutcome, ab as RequestPermissionResult, ac as AskUserResult, ad as StringFramedDroidClientTransport, ae as ProcessTransportOptions, af as McpServerConfig, ag as HttpMcpConfig, ah as ToolSelectionOverrides, ai as AutonomyLevel, aj as DroidInteractionMode, ak as ReasoningEffort, al as SessionSource, am as SessionTag, an as HandlerOptions, ao as DroidResultMessage, ap as SessionSettings, aq as MessageOptions, ar as DroidStreamMessage, as as DroidStreamEvent, at as UpdateSessionSettingsResult, au as AddMcpServerRequestParams, av as AddMcpServerResult, aw as RemoveMcpServerRequestParams, ax as RemoveMcpServerResult, ay as ToggleMcpServerRequestParams, az as ToggleMcpServerResult, aA as ListMcpServersResult, aB as McpToolInfo, aC as ExecToolInfo, aD as AuthenticateMcpServerRequestParams, aE as AuthenticateMcpServerResult, aF as ListSkillsResult, aG as SetSkillDisabledRequestParams, aH as SetSkillDisabledResult, aI as GetRewindInfoRequestParams, aJ as GetRewindInfoResult, aK as ExecuteRewindRequestParams, aL as SessionRewindOutcome, aM as CompactSessionRequestParams, aN as SessionCompactionOutcome, aO as ForkSessionRequestParams, aP as GetContextStatsResult, aQ as RenameSessionRequestParams$1, aR as ListSessionsOptions, aS as SessionMetadata } from './index-D_SzTnFR.mjs';
+export { aT as AbortError, kv as AddMcpServerRequest, aU as AddMcpServerRequestParamsSchema, aV as AddMcpServerRequestSchema, kw as AddMcpServerResponse, aW as AddMcpServerResultSchema, jG as AddMessageResult, kx as AddUserMessageRequest, ky as AddUserMessageRequestParams, aX as AddUserMessageRequestParamsSchema, aY as AddUserMessageRequestSchema, kz as AddUserMessageResponse, aZ as AddUserMessageResponseSchema, kA as AddUserMessageResult, a_ as AddUserMessageResultSchema, mr as ApplyPatchToolConfirmationDetails, a$ as ApplyPatchToolConfirmationDetailsSchema, mG as AskUserCollectedAnswer, b0 as AskUserCollectedAnswerSchema, mn as AskUserConfirmationDetails, b1 as AskUserConfirmationDetailsSchema, mD as AskUserQuestion, b2 as AskUserQuestionSchema, mE as AskUserRequest, jT as AskUserRequestHandlerEvents, mF as AskUserRequestParams, b3 as AskUserRequestParamsSchema, b4 as AskUserRequestSchema, mI as AskUserResponse, b5 as AskUserResponseSchema, mH as AskUserResult, b6 as AskUserResultSchema, hw as AssistantTextComplete, m4 as AssistantTextCompleteNotification, b7 as AssistantTextCompleteNotificationSchema, hv as AssistantTextDelta, m3 as AssistantTextDeltaNotification, b8 as AssistantTextDeltaNotificationSchema, j9 as Attribute, ja as Attributes, kB as AuthenticateMcpServerRequest, b9 as AuthenticateMcpServerRequestParamsSchema, ba as AuthenticateMcpServerRequestSchema, kC as AuthenticateMcpServerResponse, bb as AuthenticateMcpServerResultSchema, i8 as AutomationsResource, kk as AvailableModelConfig, bc as AvailableModelConfigSchema, nl as Base64ImageSource, bd as Base64ImageSourceSchema, hd as BaseDroidHookInput, k8 as BaseNotification, be as BaseNotificationSchema, k5 as BaseRequest, bf as BaseRequestSchema, k7 as BaseResponseFailure, bg as BaseResponseFailureSchema, k6 as BaseResponseSuccess, bh as BaseResponseSuccessSchema, bi as COMPACTION_TIMEOUT, kD as CancelMcpAuthRequest, kE as CancelMcpAuthRequestParams, bj as CancelMcpAuthRequestParamsSchema, bk as CancelMcpAuthRequestSchema, kF as CancelMcpAuthResponse, kG as CancelMcpAuthResult, bl as CancelMcpAuthResultSchema, kH as ChangeWorkingDirectoryRequest, kI as ChangeWorkingDirectoryRequestParams, bm as ChangeWorkingDirectoryRequestParamsSchema, bn as ChangeWorkingDirectoryRequestSchema, kJ as ChangeWorkingDirectoryResponse, bo as ChangeWorkingDirectoryResponseSchema, kK as ChangeWorkingDirectoryResult, bp as ChangeWorkingDirectoryResultSchema, kL as ClearMcpAuthRequest, kM as ClearMcpAuthRequestParams, bq as ClearMcpAuthRequestParamsSchema, br as ClearMcpAuthRequestSchema, kN as ClearMcpAuthResponse, kO as ClearMcpAuthResult, bs as ClearMcpAuthResultSchema, mC as CliRequestOrNotification, bt as CliRequestOrNotificationSchema, g_ as ClientAskUserHandler, bu as ClientDestroyedError, g$ as ClientPermissionHandler, kP as ClientRequest, bv as ClientRequestSchema, bw as ClientUiSurface, kQ as CloseSessionRequest, kR as CloseSessionRequestParams, bx as CloseSessionRequestParamsSchema, by as CloseSessionRequestSchema, kS as CloseSessionResponse, bz as CloseSessionResponseSchema, kT as CloseSessionResult, bA as CloseSessionResultSchema, i9 as CommandsResource, kU as CompactSessionRequest, bB as CompactSessionRequestParamsSchema, bC as CompactSessionRequestSchema, kV as CompactSessionResponse, kW as CompactSessionResult, bD as CompactSessionResultSchema, bE as ComputeLimitExceededError, iO as Computer, iN as ComputerApiOptions, ji as ComputerConnectAttemptContext, bF as ComputerConnectAttemptTrigger, jj as ComputerConnectSliOptions, jk as ComputerConnectSliRunContext, bG as ComputerConnectStartType, iP as ComputerListResponse, bH as ComputerListResponseSchema, iQ as ComputerMetric, bI as ComputerMetricSchema, iR as ComputerMetricsResponse, bJ as ComputerMetricsResponseSchema, bK as ComputerSchema, bL as ConcurrentStreamError, h_ as ConnectToDaemonOptions, hY as ConnectedDroid, hZ as ConnectedDroidSession, bM as ConnectionClosedError, gS as ConnectionError, bN as ConnectionFailureReason, nt as ContentBlock, bO as ContentBlockSchema, bP as ContextBreakdownCategorySchema, kj as ContextBreakdownResult, bQ as ContextBreakdownResultSchema, kl as ContextStats, bR as ContextStatsAccuracy, bS as ContextStatsSchema, iS as CreateComputerOptions, ia as CreateCronOptions, h$ as CreateDaemonSessionOptions, hF as CreateMessage, lY as CreateMessageNotification, bT as CreateMessageNotificationSchema, mm as CreateToolConfirmationDetails, bU as CreateToolConfirmationDetailsSchema, ib as CronOperationsResource, ic as CronsResource, id as CustomModelsResource, bV as DEFAULT_LOCAL_DAEMON_WS_URL, bW as DEFAULT_REQUEST_TIMEOUT, i0 as DaemonAuth, bX as DaemonAuthenticationMode, bY as DaemonClient, jm as DaemonClientConfig, bZ as DaemonClientMetaError, jb as DaemonCoreDeps, b_ as DaemonDroidEvent, jL as DaemonRequest, b$ as DaemonRequestPermissionSchema, ie as DaemonResources, c0 as DaemonSessionController, i1 as DaemonSessionSummary, jc as DaemonSpan, c1 as DecompSessionType, iY as DeleteComputerOptions, mZ as DiscoveredIssue, c2 as DiscoveredIssueSchema, n7 as DismissalRecord, c3 as DismissalRecordSchema, c4 as DismissalType, nr as DocumentBlock, c5 as DocumentBlockSchema, nq as DocumentSource, c6 as DocumentSourceSchema, hq as DroidAssistantMessage, h4 as DroidAttributeValue, h5 as DroidAttributes, gT as DroidClientError, c7 as DroidClientMethod, hu as DroidErrorMessage, c8 as DroidErrorType, c9 as DroidEvent, he as DroidHookEvent, ca as DroidHookEventSchema, h3 as DroidHookExecutionResult, cb as DroidHookExecutionResultSchema, hf as DroidHookInput, hg as DroidHookOutput, cc as DroidHookOutputSchema, cd as DroidHookSpecificOutputSchema, h6 as DroidLogEvent, h7 as DroidLogger, hX as DroidMessage, ce as DroidMessageType, h8 as DroidMetricEvent, h9 as DroidMetricSink, hh as DroidPermissionMode, ha as DroidSerializedError, cf as DroidServerMethod, hs as DroidToolCallMessage, ht as DroidToolResultMessage, hb as DroidTraceContextCarrier, hc as DroidTraceContextProvider, hr as DroidUserMessage, cg as DroidWorkingState, l_ as DroidWorkingStateChangedNotification, ch as DroidWorkingStateChangedNotificationSchema, mk as EditToolConfirmationDetails, ci as EditToolConfirmationDetailsSchema, k1 as EmptyResult, cj as EmptyResultSchema, mw as ErrorDetail, ck as ErrorDetailSchema, hW as ErrorEvent, lZ as ErrorNotification, cl as ErrorNotificationSchema, cm as ExecToolInfoSchema, kX as ExecuteRewindRequest, cn as ExecuteRewindRequestParamsSchema, co as ExecuteRewindRequestSchema, kY as ExecuteRewindResponse, kZ as ExecuteRewindResult, cp as ExecuteRewindResultSchema, ml as ExecuteToolConfirmationDetails, cq as ExecuteToolConfirmationDetailsSchema, mo as ExitSpecModeConfirmationDetails, cr as ExitSpecModeConfirmationDetailsSchema, cs as FACTORY_CLIENT_HEADER, ct as FACTORY_CLIENT_VERSION, cu as FACTORY_PROTOCOL_VERSION, iM as FactoryApiOptions, jq as FactoryDaemonConfig, cv as FactoryDaemonTransport, jr as FactoryDroidEvents, nu as FactoryDroidMessage, cw as FactoryDroidMessageRole, cx as FactoryDroidMessageSchema, cy as FeatureStatus, cz as FeatureSuccessState, cA as FeatureSuccessStateSchema, ig as FeedbackResource, ih as FileTransfersResource, i2 as ForkSessionOptions, k_ as ForkSessionRequest, cB as ForkSessionRequestSchema, k$ as ForkSessionResponse, l0 as ForkSessionResult, cC as ForkSessionResultSchema, iV as GetComputerByNameOptions, iW as GetComputerMetricsOptions, iU as GetComputerOptions, l1 as GetContextStatsRequest, l2 as GetContextStatsRequestParams, cD as GetContextStatsRequestParamsSchema, cE as GetContextStatsRequestSchema, l3 as GetContextStatsResponse, bS as GetContextStatsResultSchema, j4 as GetMachineTemplateOptions, l4 as GetRewindInfoRequest, cF as GetRewindInfoRequestParamsSchema, cG as GetRewindInfoRequestSchema, l5 as GetRewindInfoResponse, cH as GetRewindInfoResultSchema, ii as GetSessionMessagesOptions, km as GitRepoInfo, cI as GitRepoInfoSchema, ij as GitResource, n6 as Handoff, nh as HandoffItemsDismissedEntry, cJ as HandoffItemsDismissedEntrySchema, cK as HandoffSchema, mJ as HookCommand, cL as HookCommandSchema, hT as HookExecution, mb as HookExecutionCompletedNotification, cM as HookExecutionCompletedNotificationSchema, ma as HookExecutionStartedNotification, cN as HookExecutionStartedNotificationSchema, mK as HookResult, cO as HookResultSchema, kn as HttpHeader, cP as HttpHeaderSchema, cQ as HttpMcpConfigSchema, jn as IDaemonClient, gQ as IPC_DAEMON_URL, jz as IToolProgressStore, nm as ImageBlock, cR as ImageBlockSchema, gR as InProcessMessageHandler, jE as InitializeResult, l6 as InitializeSessionRequest, cS as InitializeSessionRequestParamsSchema, cT as InitializeSessionRequestSchema, cU as InitializeSessionResponseSchema, l7 as InitializeSessionResult, cV as InitializeSessionResultSchema, m$ as InteractiveCheck, cW as InteractiveCheckSchema, jH as InterruptResult, l8 as InterruptSessionRequest, l9 as InterruptSessionRequestParams, cX as InterruptSessionRequestParamsSchema, cY as InterruptSessionRequestSchema, la as InterruptSessionResponse, cZ as InterruptSessionResponseSchema, lb as InterruptSessionResult, c_ as InterruptSessionResultSchema, gU as InvalidSessionCwdError, c$ as IssueSeverity, d0 as JSONRPC_VERSION, j_ as JsonArray, d1 as JsonArraySchema, jZ as JsonObject, d2 as JsonObjectSchema, jY as JsonPrimitive, k3 as JsonRpcEnvelope, d3 as JsonRpcEnvelopeSchema, k4 as JsonRpcError, d4 as JsonRpcErrorCode, d5 as JsonRpcErrorSchema, ke as JsonRpcMessage, d6 as JsonRpcMessageSchema, d7 as JsonRpcMessageType, kc as JsonRpcNotification, d8 as JsonRpcNotificationSchema, k9 as JsonRpcRequest, d9 as JsonRpcRequestError, da as JsonRpcRequestSchema, kd as JsonRpcResponse, kb as JsonRpcResponseFailure, db as JsonRpcResponseFailureSchema, dc as JsonRpcResponseSchema, ka as JsonRpcResponseSuccess, dd as JsonRpcResponseSuccessSchema, j$ as JsonValue, de as JsonValueSchema, lc as KillWorkerSessionRequest, ld as KillWorkerSessionRequestParams, df as KillWorkerSessionRequestParamsSchema, dg as KillWorkerSessionRequestSchema, le as KillWorkerSessionResponse, dh as KillWorkerSessionResponseSchema, lf as KillWorkerSessionResult, di as KillWorkerSessionResultSchema, dj as LEGACY_FACTORY_API_VERSION, dk as LOCAL_MACHINE_ID, iT as ListComputersOptions, i3 as ListDaemonSessionsOptions, j3 as ListMachineTemplatesOptions, lg as ListMcpRegistryRequest, lh as ListMcpRegistryRequestParams, dl as ListMcpRegistryRequestParamsSchema, dm as ListMcpRegistryRequestSchema, li as ListMcpRegistryResponse, lj as ListMcpRegistryResult, dn as ListMcpRegistryResultSchema, lk as ListMcpServersRequest, ll as ListMcpServersRequestParams, dp as ListMcpServersRequestParamsSchema, dq as ListMcpServersRequestSchema, lm as ListMcpServersResponse, dr as ListMcpServersResultSchema, ln as ListMcpToolsRequest, lo as ListMcpToolsRequestParams, ds as ListMcpToolsRequestParamsSchema, dt as ListMcpToolsRequestSchema, lp as ListMcpToolsResponse, lq as ListMcpToolsResult, du as ListMcpToolsResultSchema, j8 as ListRemoteSessionsOptions, lu as ListSkillsRequest, lv as ListSkillsRequestParams, dv as ListSkillsRequestParamsSchema, dw as ListSkillsRequestSchema, lw as ListSkillsResponse, dx as ListSkillsResultSchema, lr as ListToolsRequest, dy as ListToolsRequestParamsSchema, dz as ListToolsRequestSchema, ls as ListToolsResponse, lt as ListToolsResult, dA as ListToolsResultSchema, jF as LoadResult, lz as LoadSessionRequest, dB as LoadSessionRequestParamsSchema, dC as LoadSessionRequestSchema, dD as LoadSessionResponseSchema, lA as LoadSessionResult, dE as LoadSessionResultSchema, jd as LogMetadata, dF as MACHINE_TYPE_WEBSOCKET_OVERRIDES, dG as MANAGED_COMPUTER_MAX_RETRIES, dH as MCP_AUTH_TIMEOUT, jv as MachineConnectionConfig, ju as MachineInfo, j1 as MachineTemplate, j2 as MachineTemplateBuildStatus, dI as MachineTemplateBuildStatusSchema, j5 as MachineTemplateListResponse, dJ as MachineTemplateListResponseSchema, dK as MachineTemplateSchema, dL as MachineType, ik as MarketplacesResource, hS as McpAuthCompleted, m9 as McpAuthCompletedNotification, dM as McpAuthCompletedNotificationSchema, dN as McpAuthOutcome, hR as McpAuthRequired, m8 as McpAuthRequiredNotification, dO as McpAuthRequiredNotificationSchema, mQ as McpHttpServerConfigFields, dP as McpHttpServerConfigFieldsSchema, mU as McpRegistryServer, dQ as McpRegistryServerSchema, il as McpResource, dR as McpServerConfigSchema, dS as McpServerStatus, mS as McpServerStatusInfo, dT as McpServerStatusInfoSchema, dU as McpServerType, mW as McpSseServerConfigFields, dV as McpSseServerConfigFieldsSchema, dW as McpStatus, hK as McpStatusChanged, m2 as McpStatusChangedNotification, dX as McpStatusChangedNotificationSchema, mT as McpStatusSummary, dY as McpStatusSummarySchema, mR as McpStdioServerConfigFields, dZ as McpStdioServerConfigFieldsSchema, ms as McpToolConfirmationDetails, d_ as McpToolConfirmationDetailsSchema, d$ as McpToolInfoSchema, mX as McpToolInputSchema, e0 as McpToolInputSchemaSchema, jJ as MessageRouterEvents, e1 as MessageVisibility, e2 as Metric, je as MetricLabels, ni as MilestoneValidationTriggeredEntry, e3 as MilestoneValidationTriggeredEntrySchema, n8 as MissionAcceptedEntry, e4 as MissionAcceptedEntrySchema, mY as MissionFeature, e5 as MissionFeatureSchema, hM as MissionFeaturesChanged, mf as MissionFeaturesChangedNotification, e6 as MissionFeaturesChangedNotificationSchema, hO as MissionHeartbeat, mh as MissionHeartbeatNotification, e7 as MissionHeartbeatNotificationSchema, n9 as MissionPausedEntry, e8 as MissionPausedEntrySchema, hN as MissionProgressEntry, mg as MissionProgressEntryNotification, e9 as MissionProgressEntryNotificationSchema, na as MissionResumedEntry, ea as MissionResumedEntrySchema, nb as MissionRunStartedEntry, eb as MissionRunStartedEntrySchema, ki as MissionSnapshot, ec as MissionSnapshotSchema, jC as MissionSnapshotStore, ed as MissionState, hL as MissionStateChanged, me as MissionStateChangedNotification, ee as MissionStateChangedNotificationSchema, jA as MissionStoreInterface, hQ as MissionWorkerCompleted, mj as MissionWorkerCompletedNotification, ef as MissionWorkerCompletedNotificationSchema, hP as MissionWorkerStarted, mi as MissionWorkerStartedNotification, eg as MissionWorkerStartedNotificationSchema, im as MissionsResource, eh as ModelProvider, ei as MultiMissionStateManager, ej as MultiSessionStateManager, jP as NotificationDispatcherEvents, hi as NotificationHookInput, ip as OpenedSessionSummary, ek as OtelTracing, jM as OutgoingMessage, ko as OutputFormat, el as OutputFormatSchema, em as OutputFormatType, jS as PendingAskUserRequest, jQ as PendingPermission, jo as PendingRequest, jU as PendingUserAction, jR as PermissionRequestHandlerEvents, hG as PermissionResolved, l$ as PermissionResolvedNotification, en as PermissionResolvedNotificationSchema, io as PluginsResource, hj as PreCompactHookInput, gV as ProcessExitError, nj as ProgressLogEntry, eo as ProgressLogEntrySchema, ep as ProgressLogEntryType, mp as ProposeMissionConfirmationDetails, eq as ProposeMissionConfirmationDetailsSchema, gW as ProtocolError, iq as ProxyResource, er as QueuedUserMessageDisplayGroup, es as QueuedUserMessageKind, jO as QueuedUserMessageState, et as REWIND_TIMEOUT, no as RedactedThinkingBlock, eu as RedactedThinkingBlockSchema, i_ as RefreshComputerOptions, i$ as RefreshComputerResponse, ev as RefreshComputerResponseSchema, ew as RelayConnectionError, ir as RelayResource, j6 as RemoteSession, j7 as RemoteSessionListResponse, ex as RemoteSessionListResponseSchema, ey as RemoteSessionSchema, lB as RemoveMcpServerRequest, ez as RemoveMcpServerRequestParamsSchema, eA as RemoveMcpServerRequestSchema, lC as RemoveMcpServerResponse, eB as RemoveMcpServerResultSchema, lD as RenameSessionRequest, eC as RenameSessionRequestParamsSchema, eD as RenameSessionRequestSchema, lE as RenameSessionResponse, lF as RenameSessionResult, eE as RenameSessionResultSchema, jN as RequestManagerEvents, mL as RequestPermissionRequest, mM as RequestPermissionRequestParams, eF as RequestPermissionRequestParamsSchema, eG as RequestPermissionRequestSchema, mO as RequestPermissionResponse, eH as RequestPermissionResponseSchema, mN as RequestPermissionResult, eI as RequestPermissionResultSchema, mP as RequestPermissionSelection, iZ as RestartComputerOptions, i4 as ResumeDaemonSessionOptions, j0 as RetryInstallDepsOptions, jg as RetryOptions, jh as RetryWarnLogger, kp as RewindEvictedFile, eJ as RewindEvictedFileSchema, kq as RewindFileCreation, eK as RewindFileCreationSchema, kr as RewindFileSnapshot, eL as RewindFileSnapshotSchema, i5 as RewindSessionParams, i6 as RewindSessionResult, eM as SDK_TAG, eN as SDK_VERSION, eO as SESSION_INIT_TIMEOUT, eP as SLACK_DELEGATION_MAX_RETRIES, iu as SearchSessionSummary, it as SearchSessionsResult, is as SemanticDiffResource, eQ as ServerRequestHandlerType, js as Session, hk as SessionEndHookInput, gX as SessionError, jw as SessionInitializedOutcome, jt as SessionManagerConfig, iv as SessionMessage, eR as SessionMetadataSchema, gY as SessionNotFoundError, mB as SessionNotification, mA as SessionNotificationParams, eS as SessionNotificationParamsSchema, mz as SessionNotificationPayload, eT as SessionNotificationPayloadSchema, eU as SessionNotificationSchema, eV as SessionNotificationSchemaList, eW as SessionNotificationType, iw as SessionOperationsResource, jK as SessionPendingRequest, eX as SessionPlatform, eY as SessionReplacedError, eZ as SessionReplacementError, h1 as SessionSettingsFile, e_ as SessionSettingsFileSchema, e$ as SessionSettingsSchema, f0 as SessionSourceSchema, h2 as SessionStartEvent, f1 as SessionStartEventSchema, hl as SessionStartHookInput, h0 as SessionSummary, f2 as SessionTagSchema, hI as SessionTitleUpdated, m1 as SessionTitleUpdatedNotification, f3 as SessionTitleUpdatedNotificationSchema, md as SessionTokenUsageChangedNotification, f4 as SessionTokenUsageChangedNotificationSchema, jI as SessionWebSocketConnectionEvents, hJ as SessionWorkingDirectoryChanged, i7 as SessionsResource, lx as SetSkillDisabledRequest, f5 as SetSkillDisabledRequestParamsSchema, f6 as SetSkillDisabledRequestSchema, ly as SetSkillDisabledResponse, f7 as SetSkillDisabledResultSchema, ix as SettingsResource, hH as SettingsUpdated, m0 as SettingsUpdatedNotification, f8 as SettingsUpdatedNotificationSchema, mx as SettingsUpdatedPayload, f9 as SettingsUpdatedPayloadSchema, n4 as SkillDeviation, fa as SkillDeviationSchema, n5 as SkillFeedback, fb as SkillFeedbackSchema, ks as SkillInfo, fc as SkillInfoSchema, fd as SkillLocation, kt as SkillResource, fe as SkillResourceSchema, iy as SkillsResource, iz as SoftwareFactoryActivitiesResource, iA as SoftwareFactoryChangesResource, iB as SoftwareFactoryEventsResource, iC as SoftwareFactoryResource, iD as SoftwareFactorySignalsResource, iE as SoftwareFactoryWorkstreamsResource, ff as SpanAttribute, fg as SpanEvent, fh as SpanName, kh as SseMcpConfig, fi as SseMcpConfigSchema, iF as SshResource, mq as StartMissionRunConfirmationDetails, fj as StartMissionRunConfirmationDetailsSchema, kg as StdioMcpConfig, fk as StdioMcpConfigSchema, hm as StopHookInput, jW as StoredAskUserAction, jV as StoredPermissionAction, fl as StreamStateTracker, hU as StructuredOutput, my as StructuredOutputError, fm as StructuredOutputErrorSchema, hV as StructuredOutputFields, m5 as StructuredOutputNotification, fn as StructuredOutputNotificationSchema, hn as SubagentStopHookInput, lG as SubmitBugReportRequest, lH as SubmitBugReportRequestParams, fo as SubmitBugReportRequestParamsSchema, fp as SubmitBugReportRequestSchema, lI as SubmitBugReportResponse, lJ as SubmitBugReportResult, fq as SubmitBugReportResultSchema, lK as SubmitMcpAuthCodeRequest, lL as SubmitMcpAuthCodeRequestParams, fr as SubmitMcpAuthCodeRequestSchema, lM as SubmitMcpAuthCodeResponse, lN as SubmitMcpAuthCodeResult, fs as SubmitMcpAuthCodeResultSchema, k2 as SuccessResult, ft as SuccessResultSchema, jy as TerminalMetadata, jx as TerminalSerializedState, iG as TerminalsResource, n1 as TestCase, fu as TestCaseSchema, n2 as TestFile, fv as TestFileSchema, n3 as Tests, fw as TestsSchema, nk as TextBlock, fx as TextBlockSchema, nn as ThinkingBlock, fy as ThinkingBlockSchema, hy as ThinkingTextComplete, m7 as ThinkingTextCompleteNotification, fz as ThinkingTextCompleteNotificationSchema, hx as ThinkingTextDelta, m6 as ThinkingTextDeltaNotification, fA as ThinkingTextDeltaNotificationSchema, gZ as TimeoutError, lO as ToggleMcpServerRequest, fB as ToggleMcpServerRequestParamsSchema, fC as ToggleMcpServerRequestSchema, lP as ToggleMcpServerResponse, fD as ToggleMcpServerResultSchema, lQ as ToggleMcpToolRequest, lR as ToggleMcpToolRequestParams, fE as ToggleMcpToolRequestParamsSchema, fF as ToggleMcpToolRequestSchema, lS as ToggleMcpToolResponse, lT as ToggleMcpToolResult, fG as ToggleMcpToolResultSchema, kf as TokenUsage, fH as TokenUsageSchema, hE as TokenUsageUpdate, hz as ToolCallDelta, mc as ToolCallNotification, fI as ToolCallNotificationSchema, mt as ToolConfirmationDetails, fJ as ToolConfirmationDetailsSchema, mu as ToolConfirmationInfo, fK as ToolConfirmationInfoSchema, mV as ToolConfirmationListItem, fL as ToolConfirmationListItemSchema, fM as ToolConfirmationType, ho as ToolHookInput, hC as ToolProgress, jB as ToolProgressNotifier, mv as ToolProgressUpdate, lX as ToolProgressUpdateNotification, fN as ToolProgressUpdateNotificationSchema, fO as ToolProgressUpdateSchema, hB as ToolResult, ns as ToolResultBlock, fP as ToolResultBlockSchema, lW as ToolResultNotification, fQ as ToolResultNotificationSchema, fR as ToolSelectionOverridesSchema, hA as ToolUse, np as ToolUseBlock, fS as ToolUseBlockSchema, fT as ToolUseSchema, jf as TraceContext, k0 as TraceContextMeta, fU as TraceContextMetaSchema, fV as TunnelConnection, jl as TunnelConnectionOptions, iH as UnstableResource, iX as UpdateComputerOptions, iI as UpdateCronOptions, iJ as UpdateSessionSettingsOptions, lU as UpdateSessionSettingsRequest, fW as UpdateSessionSettingsRequestParamsSchema, fX as UpdateSessionSettingsRequestSchema, lV as UpdateSessionSettingsResponse, fY as UpdateSessionSettingsResponseSchema, fZ as UpdateSessionSettingsResultSchema, iK as UpdatesResource, jD as UseMissionStoreSnapshotParams, hp as UserPromptSubmitHookInput, n0 as Verification, m_ as VerificationCommand, f_ as VerificationCommandSchema, f$ as VerificationSchema, jp as WebSocketConnectionConfig, g0 as WebSocketConnectionError, jI as WebSocketConnectionEvents, g1 as WebSocketDaemonTransport, jX as WebSocketDaemonTransportConfig, ne as WorkerCompletedEntry, g2 as WorkerCompletedEntrySchema, nf as WorkerFailedEntry, g3 as WorkerFailedEntrySchema, ng as WorkerPausedEntry, g4 as WorkerPausedEntrySchema, nd as WorkerSelectedFeatureEntry, g5 as WorkerSelectedFeatureEntrySchema, nc as WorkerStartedEntry, g6 as WorkerStartedEntrySchema, ku as WorkerStateInfo, g7 as WorkerStateInfoSchema, hD as WorkingStateChanged, iL as WorkspaceResource, g8 as buildUserMessageContentBlocks, g9 as configureDaemonCoreDeps, ga as connectAndAuthenticate, gb as connectToDaemon, gc as connectWithRetry, gd as convertNotificationToStreamMessage, ge as createComputer, gf as createResponseSchema, gg as createWebSocketDaemonClient, gh as defaultDaemonCoreDeps, gi as deleteComputer, gj as filterMessagesForUI, gk as getComputer, gl as getComputerByName, gm as getComputerMetrics, gn as getMachineTemplate, go as getPermissionToolInputForDisplay, gp as getQueuedUserMessageDisplayGroup, gq as getQueuedUserMessageReviewPriority, gr as getSubagentCallingMetadata, gs as getToolResultBlocks, gt as getToolResultToolUseId, gu as hasDecoupledInteractionSettings, gv as hasSubagentSessionTag, gw as inspectJsonRpcEnvelope, gx as isDaemonQueuedMessageKind, gy as isPendingToolResultMarker, gz as isPersistedHookMessage, gA as isReviewableQueuedMessageKind, gB as listComputers, gC as listMachineTemplates, gD as listRemoteSessions, gE as machineTypeToMachineConnectionType, gF as orderMessagesByParentChain, gG as recordComputerConnectSli, gH as refreshComputer, gI as repairParentChainCorruption, gJ as restartComputer, gK as retryInstallDeps, gL as retryWithLogger, gM as sumTokenUsage, gN as summarizeSessionToolUsage, gO as toError, gP as updateComputer } from './index-D_SzTnFR.mjs';
+import EventEmitter from 'events';
+import { z } from 'zod';
+import { ChildProcess, StdioOptions } from 'child_process';
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import '@opentelemetry/api';
+import 'eventemitter3';
+
+declare class IpcDaemonClientTransport implements DaemonClientTransport {
+    private readonly connectionId;
+    private connected;
+    private readonly channel;
+    private unsubscribeMessage;
+    private unsubscribeDisconnect;
+    private readonly handlers;
+    private readonly handleChannelMessage;
+    private readonly handleChannelDisconnect;
+    constructor(channel?: DaemonIpcMessageChannel);
+    connect(_url: string): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    getConnectionId(): string | null;
+    isRelayConnection(): boolean;
+    getTransportKind(): DaemonClientTransportKind.Ipc;
+    send(data: string): void;
+    on<T extends keyof DaemonClientTransportEvents>(event: T, handler: DaemonClientTransportEvents[T]): void;
+    off<T extends keyof DaemonClientTransportEvents>(event: T, handler: DaemonClientTransportEvents[T]): void;
+    private cleanupSubscriptions;
+    private isChannelAvailable;
+    private sendWhenAvailable;
+    private normalizeError;
+}
+
+/**
+ * A DaemonClientTransport that forwards JSON-RPC frames directly to an
+ * in-process runtime instead of crossing an IPC/WS boundary.
+ *
+ * Why this exists: the TUI's "parent" mode previously plugged
+ * `InProcessDaemonClient` straight into `DaemonSessionController`, which
+ * meant every method had to re-implement DaemonClient's envelope/error
+ * handling. That's how the recent `/bug` and `/compact` regressions
+ * happened (`response.result` returned without `if (response.error)`).
+ *
+ * Routing the same calls through `DaemonClient(transport: this)` means
+ * envelope construction, schema validation, timeouts, and error
+ * propagation live in exactly one place; the runtime handles frames.
+ */
+declare class InProcessDaemonClientTransport implements DaemonClientTransport {
+    private readonly connectionId;
+    private readonly options;
+    private connected;
+    private readonly unsubscribeFns;
+    private readonly handlers;
+    constructor(options: InProcessDaemonClientTransportOptions);
+    connect(url: string): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    getConnectionId(): string | null;
+    isRelayConnection(): boolean;
+    getTransportKind(): DaemonClientTransportKind.InProcess;
+    send(data: string): void;
+    on<T extends keyof DaemonClientTransportEvents>(event: T, handler: DaemonClientTransportEvents[T]): void;
+    off<T extends keyof DaemonClientTransportEvents>(event: T, handler: DaemonClientTransportEvents[T]): void;
+    /**
+     * Escape hatch for the in-process-only `setPendingSessionReady`
+     * coordination hook. Routed via the transport so DaemonSessionController
+     * can share in-flight session initialization/loading with the in-process
+     * runtime after it moves behind `DaemonClient`.
+     */
+    setPendingSessionReady(sessionId: string, promise: Promise<unknown>): void;
+    private sendWhenAvailable;
+    private registerUnsubscribe;
+    private cleanupSubscriptions;
+    private emitMessage;
+    private emitError;
+    private handleClose;
+    private normalizeError;
+}
+
+declare enum DroidClientEvent {
+    SESSION_NOTIFICATION = "session_notification",
+    REQUEST_PERMISSION = "request_permission",
+    ASK_USER = "ask_user",
+    ERROR = "error"
+}
+/**
+ * CLI mode for spawning droid processes
+ */
+declare enum DroidProcessMode {
+    /** ACP child mode (`droid --acp`) */
+    Acp = "acp",
+    /** SDK mode (`droid exec --input-format stream-jsonrpc`) */
+    StreamJsonRpc = "stream-jsonrpc"
+}
+/**
+ * Direction of a JSON-RPC transport message when written to the
+ * droid-transport.log file.
+ */
+declare enum TransportDirection {
+    /** Inbound: from droid process to host (daemon / CLI / host app). */
+    In = "in",
+    /** Outbound: from host to droid process, written successfully. */
+    Out = "out",
+    /**
+     * Outbound attempt that failed to reach the child process (e.g. EPIPE,
+     * ECONNRESET). Logged so frame loss is visible without conflating it
+     * with successfully sent frames.
+     */
+    OutFailed = "out_failed"
+}
+
+/** Observability logger interface for the exec core. */
+interface Logger {
+    info(message: string, metadata?: LogMetadata): void;
+    warn(message: string, metadata?: LogMetadata): void;
+    exception(error: unknown, message: string, metadata?: LogMetadata): void;
+}
+/** Metrics emitter interface for the exec core. */
+interface Metrics {
+    addToCounter(metric: string, value: number, tags?: Record<string, string>): void;
+    /**
+     * Record a millisecond-valued duration. Distinct from {@link addToCounter}
+     * so downstream sinks can model it as a histogram with a `ms` unit rather
+     * than a unitless counter.
+     */
+    recordDuration(metric: string, valueMs: number, tags?: Record<string, string>): void;
+}
+/** Tracing context interface for the exec core. */
+interface Tracing {
+    getCurrentContext(): unknown;
+    injectContext(meta: Record<string, unknown>, context: unknown): void;
+}
+/** Result of resolving the droid executable path and prefix arguments. */
+interface ResolvedDroidCommand {
+    execPath: string;
+    prefixArgs: string[];
+}
+/** Resolves the droid executable command for spawn. */
+interface CommandResolver {
+    resolveDroidCommand(isDevelopment: boolean): ResolvedDroidCommand;
+}
+/** Resolves Factory home directory and directory name for path construction. */
+interface FactoryPathResolver {
+    getFactoryHome(): string;
+    getFactoryDirName(): string;
+}
+/** Resolves environment values used by the exec core. */
+interface EnvironmentResolver {
+    resolveTransportLogEnvValue(): string | undefined;
+    /**
+     * Sanitize the environment handed to a spawned droid child. The default
+     * implementation is identity; Factory wiring injects a strip that removes
+     * whole-process sandbox bridge material so it never crosses into a child.
+     */
+    sanitizeSpawnEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+}
+/** Bundle of injectable dependencies for the exec core. */
+interface ExecCoreDeps {
+    logger: Logger;
+    metrics: Metrics;
+    tracing: Tracing;
+    commandResolver: CommandResolver;
+    factoryPathResolver: FactoryPathResolver;
+    environmentResolver: EnvironmentResolver;
+}
+interface DroidProcessManagerOptions {
+    observability?: DroidObservability;
+}
+type DroidEventMap = {
+    [DroidClientEvent.SESSION_NOTIFICATION]: [SessionNotificationEvent];
+    [DroidClientEvent.REQUEST_PERMISSION]: [RequestPermissionEvent];
+    [DroidClientEvent.ASK_USER]: [AskUserEvent];
+    [DroidClientEvent.ERROR]: [Error];
+};
+type DroidEventType = keyof DroidEventMap;
+/**
+ * Configuration for spawning a droid process
+ */
+interface DroidProcessConfig {
+    /** Path to the droid executable (defaults to 'droid' or 'droid-dev') */
+    execPath?: string;
+    /** Whether to use development mode (droid-dev) */
+    isDevelopment?: boolean;
+    /** CLI mode for the spawned process */
+    mode: DroidProcessMode;
+    /** Working directory for the process */
+    cwd?: string;
+    /** Additional environment variables */
+    env?: Record<string, string>;
+    /** Trusted env merged after sanitizer strips inherited process env. */
+    trustedEnv?: Record<string, string>;
+    /** Extra CLI arguments to pass */
+    extraArgs?: string[];
+    /** Whether to allocate a Node IPC channel for this child process. */
+    enableIpc?: boolean;
+    /** Override stdio for trusted process topologies. */
+    stdio?: StdioOptions;
+}
+/**
+ * Represents a managed droid child process
+ */
+interface ManagedProcess {
+    /** The underlying child process */
+    readonly childProcess: ChildProcess;
+    /** Send a message to the process (newline-delimited) */
+    send(message: string): Promise<void>;
+    /** Register a handler for incoming messages */
+    onMessage(handler: (message: string) => void): void;
+    /** Register a handler for errors */
+    onError(handler: (error: Error) => void): void;
+    /** Close the process gracefully */
+    close(): Promise<void>;
+    /** Check if the process is still connected */
+    readonly isConnected: boolean;
+}
+/**
+ * Options controlling the Windows Job Object spawn retry wrapper.
+ */
+interface SpawnWithRetryOptions {
+    /** Max number of retries after the initial spawn. */
+    maxRetries?: number;
+    /** Backoff schedule in ms between attempts. */
+    backoffMs?: readonly number[];
+    /**
+     * How long to wait for early failure signals before committing to the
+     * spawn. On happy path this adds this much latency to spawn completion,
+     * so keep it short.
+     */
+    gracePeriodMs?: number;
+    /** Overrides `setTimeout` (primarily for tests). */
+    sleep?: (ms: number) => Promise<void>;
+    /**
+     * Overrides the platform check (primarily for tests). When `false`, retry
+     * machinery is skipped entirely and the spawn factory runs once.
+     */
+    enabled?: boolean;
+    /**
+     * Best-effort cleanup for children that exited early but we're NOT
+     * returning to the caller.
+     */
+    disposeEarlyExited?: (child: ChildProcess) => void | Promise<void>;
+    /** Used to tag log lines for easier correlation. */
+    logPrefix?: string;
+    /** Injected logger; defaults to no-op when not provided. */
+    logger?: Logger;
+}
+
+type McpSettingsLevel = SettingsLevel.User;
+type PermissionHandlerResult = RequestPermissionHandlerResult | ToolConfirmationOutcome | RequestPermissionResult;
+/**
+ * Derive the JSON-RPC error code for an outgoing failure response. An error can
+ * opt into a specific code by setting `metadata.code` on a {@link DroidClientError}
+ * (e.g. {@link JsonRpcErrorCode.CONFLICT} for a duplicate request); anything
+ * else falls back to INTERNAL_ERROR.
+ */
+declare class DroidClient extends EventEmitter<DroidEventMap> {
+    private transport;
+    private requestTimeout;
+    private pendingRequests;
+    private permissionHandlers;
+    private askUserHandlers;
+    private pendingPermissionRequests;
+    private pendingAskUserRequests;
+    private currentSessionId;
+    private peerProtocolVersion;
+    /**
+     * Sticky error from a transport failure. Once set, all subsequent
+     * `sendRequest()` calls throw this error immediately, preventing
+     * requests from hanging on a dead transport.
+     */
+    private transportError;
+    private readonly logger;
+    private readonly tracing;
+    private readonly onRequestSettled;
+    constructor(options: DroidClientOptions, deps?: ExecCoreDeps);
+    get sessionId(): string | null;
+    get isConnected(): boolean;
+    private requireMcpOAuthOptOutSupport;
+    private validateMcpServersProtocolSupport;
+    initializeSession(params: InitializeSessionRequestParams): Promise<InitializeSessionResponse>;
+    loadSession(params: LoadSessionRequestParams): Promise<LoadSessionResponse>;
+    addUserMessage(params: AddUserMessageParams, requestId?: string): Promise<AddUserMessageResponse>;
+    resolveQueuedUserMessage(params: ResolveQueuedUserMessageParams): Promise<ResolveQueuedUserMessageResponse>;
+    interruptSession(params?: InterruptSessionParams): Promise<InterruptSessionResponse>;
+    closeSession(params?: CloseSessionParams): Promise<CloseSessionResponse>;
+    killWorkerSession(params: KillWorkerSessionParams): Promise<KillWorkerSessionResponse>;
+    updateSessionSettings(params: UpdateSessionSettingsRequestParams, requestId?: string): Promise<UpdateSessionSettingsResponse>;
+    changeWorkingDirectory(params: ChangeWorkingDirectoryParams): Promise<ChangeWorkingDirectoryResponse>;
+    toggleMcpServer(params: {
+        serverName: string;
+        enabled: boolean;
+        settingsLevel: McpSettingsLevel;
+    }): Promise<z.infer<typeof ToggleMcpServerResponseSchema>>;
+    authenticateMcpServer(params: {
+        serverName: string;
+    }): Promise<z.infer<typeof AuthenticateMcpServerResponseSchema>>;
+    cancelMcpAuth(params: {
+        serverName: string;
+    }): Promise<z.infer<typeof CancelMcpAuthResponseSchema>>;
+    clearMcpAuth(params: {
+        serverName: string;
+    }): Promise<z.infer<typeof ClearMcpAuthResponseSchema>>;
+    addMcpServer(params: AddMcpServerRequest['params']): Promise<z.infer<typeof AddMcpServerResponseSchema>>;
+    removeMcpServer(params: {
+        serverName: string;
+        settingsLevel: McpSettingsLevel;
+    }): Promise<z.infer<typeof RemoveMcpServerResponseSchema>>;
+    listMcpRegistry(): Promise<z.infer<typeof ListMcpRegistryResponseSchema>>;
+    listMcpTools(): Promise<z.infer<typeof ListMcpToolsResponseSchema>>;
+    listTools(params?: ListToolsRequestParams): Promise<z.infer<typeof ListToolsResponseSchema>>;
+    listMcpServers(): Promise<z.infer<typeof ListMcpServersResponseSchema>>;
+    toggleMcpTool(serverName: string, toolName: string, enabled: boolean): Promise<z.infer<typeof ToggleMcpToolResponseSchema>>;
+    submitMcpAuthCode(params: z.infer<typeof SubmitMcpAuthCodeRequestParamsSchema>): Promise<z.infer<typeof SubmitMcpAuthCodeResponseSchema>>;
+    submitMcpAuthError(params: z.infer<typeof SubmitMcpAuthErrorRequestParamsSchema>): Promise<z.infer<typeof SubmitMcpAuthErrorResponseSchema>>;
+    listSkills(): Promise<z.infer<typeof ListSkillsResponseSchema>>;
+    setSkillDisabled(skillName: string, disabled: boolean, settingsLevel?: SetSkillDisabledRequest['params']['settingsLevel']): Promise<z.infer<typeof SetSkillDisabledResponseSchema>>;
+    listCommands(): Promise<z.infer<typeof ListCommandsResponseSchema>>;
+    getContextStats(): Promise<z.infer<typeof GetContextStatsResponseSchema>>;
+    getContextBreakdown(): Promise<z.infer<typeof GetContextBreakdownResponseSchema>>;
+    submitBugReport(userComment: string, clientLogs?: string, source?: SubmitBugReportRequest['params']['source']): Promise<z.infer<typeof SubmitBugReportResponseSchema>>;
+    getRewindInfo(params: {
+        messageId: string;
+    }, timeout?: number): Promise<z.infer<typeof GetRewindInfoResponseSchema>>;
+    executeRewind(params: {
+        messageId: string;
+        filesToRestore: Array<{
+            filePath: string;
+            contentHash: string;
+            size: number;
+        }>;
+        filesToDelete: Array<{
+            filePath: string;
+        }>;
+        forkTitle: string;
+    }): Promise<z.infer<typeof ExecuteRewindResponseSchema>>;
+    compactSession(params: {
+        customInstructions?: string;
+    }): Promise<z.infer<typeof CompactSessionResponseSchema>>;
+    forkSession(params?: z.infer<typeof ForkSessionRequestParamsSchema>): Promise<z.infer<typeof ForkSessionResponseSchema>>;
+    renameSession(params: RenameSessionRequestParams, requestId?: string): Promise<z.infer<typeof RenameSessionResponseSchema>>;
+    warmupCache(): Promise<z.infer<typeof WarmupCacheResponseSchema>>;
+    onNotification(callback: (notification: Record<string, unknown>) => void, filter?: {
+        type?: string;
+    }): () => void;
+    onError(callback: (error: Error) => void): () => void;
+    setPermissionHandler(handler: (event: RequestPermissionEvent) => Promise<PermissionHandlerResult> | PermissionHandlerResult): void;
+    clearPermissionHandler(): void;
+    setAskUserHandler(handler: (event: AskUserEvent) => Promise<AskUserResult> | AskUserResult): void;
+    clearAskUserHandler(): void;
+    close(): Promise<void>;
+    private rejectAllPending;
+    private settleRequest;
+    private notifyRequestSettled;
+    private sendRequest;
+    private handleMessage;
+    private handleResponse;
+    private handleEvent;
+    /**
+     * When an incoming CLI->client request fails to parse, send back a
+     * structurally valid JsonRpcBaseResponseFailure so the peer's pending
+     * request doesn't hang. No-ops for notifications (no id to reply on)
+     * or events we can't correlate.
+     */
+    private replyWithParseFailureIfRequest;
+    /**
+     * Invariant: parsing failures for incoming events (notifications or
+     * server-initiated requests) must NEVER surface as user-visible ERROR
+     * notifications. Version skew, unknown inner enum values, missing
+     * fields, or malformed shapes all degrade to a log-and-drop so the
+     * session continues quietly instead of flashing a synthetic error on
+     * every
+     */
+    private logDroppedEventParseError;
+    private handlePermissionRequest;
+    private handleAskUserRequest;
+    private static getErrorType;
+    private static createErrorNotification;
+    private static getNestedString;
+    private static isRecord;
+    /**
+     * Create a full SessionNotificationEvent for locally-generated notifications.
+     * Used when the SDK needs to emit error notifications that weren't received from the CLI.
+     */
+    private static createNotificationEvent;
+}
+
+/**
+ * Internal implementation of ManagedProcess
+ */
+declare class ManagedProcessImpl implements ManagedProcess {
+    private readonly logPrefix;
+    private readonly spawnContext;
+    private readonly transportLoggerDeps;
+    private _childProcess;
+    private messageHandler;
+    private errorHandler;
+    private readlineInterface;
+    private isClosing;
+    /** Latch so exit teardown/classification runs exactly once per process. */
+    private exitFinalized;
+    private exitDrainTimer;
+    /**
+     * Sticky error from a process error or unexpected exit event. Once set,
+     * all subsequent `send()` calls throw this error immediately instead of
+     * hanging on a dead transport.
+     */
+    private processError;
+    private queuedSendPromise;
+    private readonly logger;
+    constructor(childProcess: ChildProcess, logPrefix: string, spawnContext: {
+        cwd?: string;
+        execPath?: string;
+    } | undefined, deps: ExecCoreDeps, transportLoggerDeps?: ExecCoreDeps);
+    get childProcess(): ChildProcess;
+    private setupHandlers;
+    private finalizeExit;
+    send(message: string): Promise<void>;
+    onMessage(handler: (message: string) => void): void;
+    onError(handler: (error: Error) => void): void;
+    close(): Promise<void>;
+    get isConnected(): boolean;
+}
+
+/**
+ * ProcessTransport implements the StringFramedDroidClientTransport interface using a spawned
+ * droid child process. It uses DroidProcessManager internally for process management.
+ *
+ * This is a thin wrapper that maintains the existing API while delegating to
+ * the more general-purpose DroidProcessManager.
+ */
+declare class ProcessTransport implements StringFramedDroidClientTransport {
+    private managedProcess;
+    private processManager;
+    private options;
+    private messageHandler;
+    private errorHandler;
+    private metrics;
+    constructor(options?: ProcessTransportOptions, deps?: ExecCoreDeps);
+    connect(): Promise<void>;
+    send(message: string): Promise<void>;
+    onMessage(handler: (message: string) => void): void;
+    onError(handler: (error: Error) => void): void;
+    close(): Promise<void>;
+    get isConnected(): boolean;
+    getManagedProcess(): ManagedProcess | null;
+}
+
+/**
+ * DroidProcessManager handles spawning and managing droid child processes.
+ * This is a generalized process manager that can spawn processes in different modes:
+ * - 'acp': For ACP child mode (`droid exec --output-format acp`)
+ * - 'stream-jsonrpc': For SDK mode (`droid exec --input-format stream-jsonrpc`)
+ */
+declare class DroidProcessManager {
+    private readonly deps;
+    private readonly transportLoggerDeps;
+    private readonly logger;
+    private readonly commandResolver;
+    constructor(options?: DroidProcessManagerOptions, deps?: ExecCoreDeps);
+    /**
+     * Spawn a new droid process with the given configuration.
+     *
+     * Returns a synchronous ManagedProcess as soon as the OS reports the child
+     * as spawned. This does not retry Windows Job Object spawn failures — use
+     * {@link DroidProcessManager#spawnWithWindowsRetry} for that.
+     */
+    spawn(config: DroidProcessConfig): ManagedProcess;
+    /**
+     * Spawn a droid process with automatic retry for the Windows Job Object
+     * spawn error class (FAC-19070). On non-Windows platforms this behaves
+     * identically to {@link DroidProcessManager#spawn} but returns a promise.
+     *
+     * When a Windows child process exits within the startup grace period and
+     * the exit looks like the `AssignProcessToJobObject` failure pattern, the
+     * dead child is disposed and a fresh spawn is attempted, up to the
+     * configured retry cap.
+     */
+    spawnWithWindowsRetry(config: DroidProcessConfig, retryOptions?: SpawnWithRetryOptions): Promise<ManagedProcess>;
+    private prepareSpawn;
+    private invokeNodeSpawn;
+    private spawnChildProcess;
+}
+
+/**
+ * Check whether transport logging is enabled via env var. The result is
+ * cached on first access for performance (env vars don't change mid-run).
+ *
+ * @public
+ */
+declare function isTransportLoggingEnabled(deps?: ExecCoreDeps): boolean;
+/**
+ * Log a single JSON-RPC transport message. This is the hot path and is
+ * designed to be as cheap as possible when logging is disabled:
+ *   - Single boolean check when the env var is unset.
+ *   - No JSON serialisation (messages are already strings on the wire).
+ *   - Fire-and-forget writes via `WriteStream.write()`: Node buffers
+ *     internally and never blocks the caller.
+ *   - Any I/O error disables the logger for the remainder of the process
+ *     instead of propagating up into the transport.
+ */
+declare function logTransportMessage(direction: TransportDirection, message: string, childPid?: number, deps?: ExecCoreDeps): void;
+/**
+ * Test-only: reset the cached state so subsequent tests can re-read env vars.
+ * Waits for the underlying write stream to flush before resolving.
+ *
+ * @public
+ */
+declare function __resetTransportLoggerForTests(deps?: ExecCoreDeps): Promise<void>;
+
+declare function resolveExecCoreDeps(observability: DroidObservability | undefined, fallback?: ExecCoreDeps): ExecCoreDeps;
+
+/**
+ * Wraps a Node `child_process.spawn` factory with automatic retries on the
+ * Windows Job Object spawn failure class. On non-Windows platforms (or when
+ * `enabled: false`) this simply invokes `spawnFactory()` once.
+ *
+ * On Windows, after each spawn we watch for early exits within
+ * `gracePeriodMs`. If the child exits early AND the exit looks like a Job
+ * Object failure (stderr marker, or non-zero exit without an explicit
+ * permanent-failure 'error' event), we dispose the dead child and respawn
+ * up to `maxRetries`.
+ */
+declare function spawnWithWindowsJobObjectRetry(spawnFactory: () => ChildProcess, options?: SpawnWithRetryOptions): Promise<ChildProcess>;
+
+/**
+ * Default timeout values for DroidClient
+ */
+
+/**
+ * Windows kernel error string emitted to a child process's stderr when
+ * libuv's `uv_spawn` calls `AssignProcessToJobObject` on an
+ * already-terminated child handle. Used by the Windows spawn retry wrapper
+ * (FAC-19070) to identify the retryable failure class.
+ */
+declare const WINDOWS_JOB_OBJECT_ERROR_MARKER = "AssignProcessToJobObject";
+/**
+ * Metric key for child-process spawn latency emitted by the process
+ * transport. Kept byte-identical to the value historically sourced from the
+ * `@factory/logging` metric enum so downstream telemetry stays continuous.
+ */
+declare const CLI_JSONRPC_CHILD_SPAWN_LATENCY_METRIC = "cli_jsonrpc_child_spawn_latency";
+/** No-op logger used when no real logger is injected. Safe because it is observability-only. */
+declare const noopLogger: Logger;
+
+type ToolInputShape = Record<string, z.ZodTypeAny>;
+type DroidToolResult = string | CallToolResult;
+interface DroidTool {
+    name: string;
+    description?: string;
+    inputSchema?: ToolInputShape;
+    handler: (input: Record<string, unknown>) => DroidToolResult | Promise<DroidToolResult>;
+}
+interface SdkMcpServerOptions {
+    name: string;
+    version?: string;
+    tools: DroidTool[];
+}
+type DroidMcpServerConfig = McpServerConfig | SdkMcpServer;
+declare function tool<InputShape extends ToolInputShape>(name: string, description: string, inputSchema: InputShape, handler: (input: z.infer<z.ZodObject<InputShape>>) => DroidToolResult | Promise<DroidToolResult>): DroidTool;
+declare function tool(name: string, description: string, handler: DroidTool['handler']): DroidTool;
+declare class SdkMcpServer {
+    readonly name: string;
+    readonly version: string;
+    readonly tools: DroidTool[];
+    private _httpServer;
+    private _url;
+    private _token;
+    constructor(options: SdkMcpServerOptions);
+    get config(): HttpMcpConfig | null;
+    start(): Promise<HttpMcpConfig>;
+    close(): Promise<void>;
+    private createMcpServer;
+    private handleRequest;
+}
+declare function createSdkMcpServer(options: SdkMcpServerOptions): SdkMcpServer;
+
+interface TransportCreationOptions {
+    /** Defaults to `process.env.FACTORY_API_KEY`. */
+    apiKey?: string;
+    execPath?: string;
+    execArgs?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    observability?: DroidObservability;
+    transport?: StringFramedDroidClientTransport;
+}
+interface SessionInitOptions extends ToolSelectionOverrides {
+    /** Defaults to `process.cwd()`. */
+    cwd?: string;
+    machineId?: string;
+    modelId?: string;
+    autonomyLevel?: AutonomyLevel;
+    interactionMode?: DroidInteractionMode;
+    reasoningEffort?: ReasoningEffort;
+    specModeModelId?: string;
+    specModeReasoningEffort?: ReasoningEffort;
+    mcpServers?: DroidMcpServerConfig[];
+    sessionSource?: SessionSource;
+    tags?: SessionTag[];
+    autoRejectPermissionRequests?: boolean;
+    /** When true, Factory-provided builtin skills are unavailable. */
+    disableBuiltinSkills?: boolean;
+}
+
+type NotificationCallback = (notification: Record<string, unknown>) => void;
+interface NotificationFilter {
+    type?: string;
+}
+/** Aggregated result from a one-shot {@link run} call. */
+type DroidResult = DroidResultMessage;
+interface CreateSessionOptions extends SessionInitOptions, HandlerOptions, TransportCreationOptions {
+    abortSignal?: AbortSignal;
+}
+interface ResumeSessionOptions extends Pick<CreateSessionOptions, 'apiKey' | 'execPath' | 'execArgs' | 'env' | 'permissionHandler' | 'askUserHandler' | 'transport' | 'abortSignal' | 'observability' | 'disabledToolIds' | 'autoRejectPermissionRequests' | 'disableBuiltinSkills' | 'sessionSource'> {
+    mcpServers?: DroidMcpServerConfig[];
+}
+
+type ToolInfo = Omit<ExecToolInfo, 'id' | 'llmId' | 'currentlyAllowed'> & {
+    id: ExecToolInfo['llmId'];
+    allowed: ExecToolInfo['currentlyAllowed'];
+};
+type ListToolsOptions = ListToolsRequestParams;
+type DroidSessionUpdateSettingsOptions = UpdateSessionSettingsRequestParams;
+type ReplacementLoadParams = Omit<LoadSessionRequestParams, 'sessionId'>;
+interface SessionRuntime {
+    abortSignal?: AbortSignal;
+    loadParams: ReplacementLoadParams;
+}
+interface SessionMetadataSnapshot {
+    settings: SessionSettings;
+    cwd?: string;
+}
+/** Create instances via {@link createSession} or {@link resumeSession}. */
+declare class DroidSession {
+    private readonly _runtime;
+    private readonly _client;
+    private readonly _sessionId;
+    private _settings;
+    private _cwd;
+    private _settingsRevision;
+    private _status;
+    private _replacementSessionId;
+    private _cleanupAbortSignal;
+    private _cleanupCallbacks;
+    private readonly _activeBridges;
+    private readonly _notificationCleanups;
+    /** @internal */
+    constructor(client: DroidClient, sessionId: string, metadata: SessionMetadataSnapshot, _runtime: SessionRuntime, cleanupCallbacks?: Array<() => Promise<void> | void>);
+    get id(): string;
+    get settings(): Readonly<SessionSettings>;
+    get cwd(): string | undefined;
+    /** Yields message-level events until the final `result` message. */
+    stream(prompt: string, options?: MessageOptions & {
+        includePartialMessages?: false;
+    }): AsyncGenerator<DroidStreamMessage, void, undefined>;
+    /** Yields message-level events plus partial chunks until the final `result` message. */
+    stream(prompt: string, options: MessageOptions & {
+        includePartialMessages: true;
+    }): AsyncGenerator<DroidStreamEvent, void, undefined>;
+    interrupt(): Promise<void>;
+    close(): Promise<void>;
+    updateSettings(params: DroidSessionUpdateSettingsOptions): Promise<UpdateSessionSettingsResult>;
+    enterSpecMode(params?: Pick<UpdateSessionSettingsRequestParams, 'specModeModelId' | 'specModeReasoningEffort'>): Promise<UpdateSessionSettingsResult>;
+    addMcpServer(params: AddMcpServerRequestParams): Promise<AddMcpServerResult>;
+    removeMcpServer(params: RemoveMcpServerRequestParams): Promise<RemoveMcpServerResult>;
+    toggleMcpServer(params: ToggleMcpServerRequestParams): Promise<ToggleMcpServerResult>;
+    listMcpServers(): Promise<ListMcpServersResult>;
+    listMcpTools(): Promise<McpToolInfo[]>;
+    listTools(params?: ListToolsOptions): Promise<ToolInfo[]>;
+    authenticateMcpServer(params: AuthenticateMcpServerRequestParams): Promise<AuthenticateMcpServerResult>;
+    listSkills(): Promise<ListSkillsResult>;
+    setSkillDisabled(params: SetSkillDisabledRequestParams): Promise<SetSkillDisabledResult>;
+    getRewindInfo(params: Omit<GetRewindInfoRequestParams, 'sessionId'>): Promise<GetRewindInfoResult>;
+    rewind(params: Omit<ExecuteRewindRequestParams, 'sessionId'>): Promise<SessionRewindOutcome<DroidSession>>;
+    compact(params?: CompactSessionRequestParams): Promise<SessionCompactionOutcome<DroidSession>>;
+    fork(params?: ForkSessionRequestParams): Promise<DroidSession>;
+    getContextStats(): Promise<GetContextStatsResult>;
+    rename(params: RenameSessionRequestParams$1): Promise<void>;
+    onNotification(callback: NotificationCallback, filter?: NotificationFilter): () => void;
+    private _ensureNotClosed;
+    private _beginReplacement;
+    private _runReplacement;
+    private _loadReplacement;
+    private _bindAbortSignal;
+    private _bindMetadataNotifications;
+    private _releaseHandleSubscriptions;
+    private _disposeAfterFailedRollback;
+}
+declare function createSession(options?: CreateSessionOptions): Promise<DroidSession>;
+/**
+ * Resumes an existing Droid session.
+ *
+ * The resumed session always runs in the working directory that was persisted
+ * with the session at creation time. `resumeSession()` intentionally does not
+ * accept a `cwd` option: the persisted session cwd is authoritative. The
+ * underlying subprocess is launched in the host process's `process.cwd()`, but
+ * this does not affect the session's working directory as far as the Droid is
+ * concerned. To run in a different directory, create a new session or fork the
+ * existing one.
+ *
+ * @throws {SessionNotFoundError} If the session ID does not exist.
+ */
+declare function resumeSession(sessionId: string, options?: ResumeSessionOptions): Promise<DroidSession>;
+
+interface RunOptions extends CreateSessionOptions, Omit<MessageOptions, 'includePartialMessages'> {
+}
+declare function run(prompt: string, options?: RunOptions): Promise<DroidResult>;
+
+/**
+ * List droid sessions stored on disk.
+ *
+ * Sessions are read from `~/.factory/sessions/` (or the `sessionsDir`
+ * override) by scanning `.jsonl` files, mirroring the logic used by the
+ * `droid` CLI's `SessionService`. No JSON-RPC server calls are made.
+ *
+ * By default, returns sessions for `process.cwd()`. Pass a specific `cwd`
+ * to scope to a different project, or `fetchOutsideCWD: true` to return
+ * every session on disk regardless of working directory. Results are
+ * sorted by `modifiedTime` descending and can be capped with `limit`.
+ *
+ * @example
+ * ```ts
+ * // Sessions for the current project
+ * const sessions = await listSessions();
+ *
+ * // 10 most recent sessions across every project
+ * const recent = await listSessions({
+ *   fetchOutsideCWD: true,
+ *   limit: 10,
+ * });
+ * ```
+ */
+declare function listSessions(options?: ListSessionsOptions): Promise<SessionMetadata[]>;
+
+export { AddMcpServerRequestParams, AddMcpServerResponseSchema, AddMcpServerResult, AuthenticateMcpServerRequestParams, AuthenticateMcpServerResponseSchema, AuthenticateMcpServerResult, AutonomyLevel, CLI_JSONRPC_CHILD_SPAWN_LATENCY_METRIC, CancelMcpAuthResponseSchema, ClearMcpAuthResponseSchema, type CommandResolver, CompactSessionRequestParams, CompactSessionResponseSchema, type CreateSessionOptions, DaemonClientTransport, DaemonClientTransportEvents, DaemonIpcMessageChannel, DroidClient, DroidClientEvent, DroidClientOptions, type DroidEventMap, type DroidEventType, DroidInteractionMode, type DroidMcpServerConfig, DroidObservability, type DroidProcessConfig, DroidProcessManager, type DroidProcessManagerOptions, DroidProcessMode, type DroidResult, DroidResultMessage, DroidSession, type DroidSessionUpdateSettingsOptions, DroidStreamEvent, DroidStreamMessage, type DroidTool, type DroidToolResult, type EnvironmentResolver, type ExecCoreDeps, ExecToolInfo, ExecuteRewindRequestParams, ExecuteRewindResponseSchema, type FactoryPathResolver, ForkSessionRequestParams, ForkSessionRequestParamsSchema, ForkSessionResponseSchema, GetContextStatsResponseSchema, GetContextStatsResult, GetRewindInfoRequestParams, GetRewindInfoResponseSchema, GetRewindInfoResult, HttpMcpConfig, InProcessDaemonClientTransport, InProcessDaemonClientTransportOptions, InitializeSessionRequestParams, InitializeSessionResponse, IpcDaemonClientTransport, ListMcpRegistryResponseSchema, ListMcpServersResponseSchema, ListMcpServersResult, ListMcpToolsResponseSchema, ListSessionsOptions, ListSkillsResponseSchema, ListSkillsResult, type ListToolsOptions, ListToolsRequestParams, ListToolsResponseSchema, LoadSessionRequestParams, LoadSessionResponse, type Logger, type ManagedProcess, ManagedProcessImpl, McpServerConfig, McpToolInfo, MessageOptions, type Metrics, ProcessTransport, ProcessTransportOptions, ReasoningEffort, RemoveMcpServerRequestParams, RemoveMcpServerResponseSchema, RemoveMcpServerResult, RenameSessionRequestParams$1 as RenameSessionRequestParams, RenameSessionResponseSchema, RequestPermissionHandlerResult, type ResolvedDroidCommand, type ResumeSessionOptions, type RunOptions, SdkMcpServer, type SdkMcpServerOptions, SessionCompactionOutcome, SessionMetadata, SessionRewindOutcome, SessionSettings, SessionSource, SessionTag, SetSkillDisabledRequestParams, SetSkillDisabledResponseSchema, SetSkillDisabledResult, SettingsLevel, type SpawnWithRetryOptions, StringFramedDroidClientTransport, SubmitBugReportResponseSchema, SubmitMcpAuthCodeRequestParamsSchema, SubmitMcpAuthCodeResponseSchema, ToggleMcpServerRequestParams, ToggleMcpServerResponseSchema, ToggleMcpServerResult, ToggleMcpToolResponseSchema, ToolConfirmationOutcome, type ToolInfo, ToolSelectionOverrides, type Tracing, TransportDirection, UpdateSessionSettingsRequestParams, UpdateSessionSettingsResult, WINDOWS_JOB_OBJECT_ERROR_MARKER, __resetTransportLoggerForTests, createSdkMcpServer, createSession, isTransportLoggingEnabled, listSessions, logTransportMessage, noopLogger, resolveExecCoreDeps, resumeSession, run, spawnWithWindowsJobObjectRetry, tool };