@factory/droid-sdk 0.9.1 → 0.10.0

package/dist/node.mjs

@@ -68,6 +68,7 @@ import {
   ConnectionError,
   ConnectionFailureReason,
   ContentBlockSchema,
+  ContextApiError,
   ContextBreakdownCategorySchema,
   ContextStatsAccuracy,
   ContextStatsSchema,
@@ -104,6 +105,7 @@ import {
   ErrorDetailSchema,
   ErrorNotificationSchema,
   ExecToolInfoSchema,
+  ExecToolInfoWithSchemasSchema,
   ExecuteRewindRequestParamsSchema,
   ExecuteRewindRequestSchema,
   ExecuteRewindResponseSchema,
@@ -183,6 +185,7 @@ import {
   LEGACY_FACTORY_API_VERSION,
   LEGACY_FACTORY_API_VERSION2,
   LOCAL_MACHINE_ID,
+  LfLineDecoder,
   ListCommandsResponseSchema,
   ListMcpRegistryRequestParamsSchema,
   ListMcpRegistryRequestSchema,
@@ -206,7 +209,9 @@ import {
   ListToolsRequestParamsSchema,
   ListToolsRequestSchema,
   ListToolsResponseSchema,
+  ListToolsResponseWithSchemasSchema,
   ListToolsResultSchema,
+  ListToolsResultWithSchemasSchema,
   LoadSessionRequestParamsSchema,
   LoadSessionRequestSchema,
   LoadSessionResponseSchema,
@@ -261,6 +266,12 @@ import {
   OutputFormatSchema,
   OutputFormatType,
   PermissionResolvedNotificationSchema,
+  PickOptionsRequestParamsSchema,
+  PickOptionsRequestSchema,
+  PickOptionsResponseSchema,
+  PickOptionsResultSchema,
+  PickOptionsRowSchema,
+  PickOptionsUnavailableError,
   ProcessExitError,
   ProgressLogEntrySchema,
   ProgressLogEntryType,
@@ -272,6 +283,7 @@ import {
   ReasoningEffort,
   RedactedThinkingBlockSchema,
   RefreshComputerResponseSchema,
+  RefreshConnectorToolCatalogResponseSchema,
   RelayConnectionError,
   RemoteSessionListResponseSchema,
   RemoteSessionSchema,
@@ -298,6 +310,12 @@ import {
   SESSION_INIT_TIMEOUT,
   SLACK_DELEGATION_MAX_RETRIES,
   ServerRequestHandlerType,
+  SessionArtifactAction,
+  SessionArtifactKind,
+  SessionArtifactProvider,
+  SessionArtifactSchema,
+  SessionArtifactSource,
+  SessionArtifactsSchema,
   SessionError,
   SessionMetadataSchema,
   SessionNotFoundError,
@@ -371,11 +389,15 @@ import {
   ToolConfirmationListItemSchema,
   ToolConfirmationOutcome,
   ToolConfirmationType,
+  ToolJsonSchemaSchema,
   ToolProgressUpdateNotificationSchema,
   ToolProgressUpdateSchema,
   ToolResultNotificationSchema,
   ToolResultSchema,
+  ToolResultSchemaDescriptorSchema,
+  ToolSchemasSchema,
   ToolSelectionOverridesSchema,
+  ToolSourceSchema,
   ToolUseSchema,
   ToolUseSchema2,
   TraceContextMetaSchema,
@@ -395,6 +417,7 @@ import {
   WorkerSelectedFeatureEntrySchema,
   WorkerStartedEntrySchema,
   WorkerStateInfoSchema,
+  appendContextSession,
   buildUserMessageContentBlocks,
   configureDaemonCoreDeps,
   connectAndAuthenticate,
@@ -402,15 +425,26 @@ import {
   connectWithRetry,
   convertNotificationToStreamMessage,
   createComputer,
+  createContextDocument,
+  createContextFile,
+  createContextSpace,
   createResponseSchema,
   createWebSocketDaemonClient,
   defaultDaemonCoreDeps,
   deleteComputer,
+  deleteContextDocument,
+  deleteContextFile,
+  emitDroidLog,
+  escapeJsonLineSeparators,
   extractInnerNotification,
   filterMessagesForUI,
   getComputer,
   getComputerByName,
   getComputerMetrics,
+  getContextDocument,
+  getContextDocumentByPath,
+  getContextSession,
+  getContextSpace,
   getMachineTemplate,
   getPermissionToolInputForDisplay,
   getQueuedUserMessageDisplayGroup,
@@ -420,20 +454,27 @@ import {
   getToolResultToolUseId,
   hasDecoupledInteractionSettings,
   hasSubagentSessionTag,
+  injectDroidTraceContext,
   inspectJsonRpcEnvelope,
   isDaemonQueuedMessageKind,
   isPendingToolResultMarker,
   isPersistedHookMessage,
+  isProtocolVersionAtLeast,
   isReviewableQueuedMessageKind,
   listComputers,
+  listContextDocuments,
+  listContextSessions,
+  listContextSpaces,
   listMachineTemplates,
   listRemoteSessions,
   machineTypeToMachineConnectionType,
   mergeSessionSettings,
-  orderMessagesByParentChain,
+  readContextFilePart,
+  readContextSessionRecords,
   recordComputerConnectSli,
+  recordDroidMetric,
   refreshComputer,
-  repairParentChainCorruption,
+  registerContextSession,
   restartComputer,
   retryInstallDeps,
   retryWithLogger,
@@ -443,9 +484,11 @@ import {
   toError,
   unwrapResponseResult,
   updateComputer,
+  updateContextDocument,
+  uploadContextFilePart,
   wireAbortSignal,
   withSdkTag
-} from "./chunk-TWSTJMV7.mjs";
+} from "./chunk-TWAVPIPS.mjs";
 
 // src/exec-core/client.ts
 import EventEmitter from "events";
@@ -517,6 +560,9 @@ var defaultExecCoreDeps = {
     },
     sanitizeSpawnEnv(env) {
       return env;
+    },
+    buildRuntimeSettingsAuthorityEnv() {
+      return {};
     }
   }
 };
@@ -526,6 +572,7 @@ var DroidClientEvent = /* @__PURE__ */ ((DroidClientEvent2) => {
   DroidClientEvent2["SESSION_NOTIFICATION"] = "session_notification";
   DroidClientEvent2["REQUEST_PERMISSION"] = "request_permission";
   DroidClientEvent2["ASK_USER"] = "ask_user";
+  DroidClientEvent2["PICK_OPTIONS"] = "pick_options";
   DroidClientEvent2["ERROR"] = "error";
   return DroidClientEvent2;
 })(DroidClientEvent || {});
@@ -541,90 +588,6 @@ var TransportDirection = /* @__PURE__ */ ((TransportDirection2) => {
   return TransportDirection2;
 })(TransportDirection || {});
 
-// ../droid-sdk-core/src/observability.ts
-function sanitizeAttributes(attributes) {
-  if (attributes === void 0) {
-    return void 0;
-  }
-  const sanitized = {};
-  for (const [key, value] of Object.entries(attributes)) {
-    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      sanitized[key] = value;
-    }
-  }
-  return Object.keys(sanitized).length > 0 ? sanitized : void 0;
-}
-function serializeError(error) {
-  if (error instanceof Error) {
-    const code = "code" in error && typeof error.code === "string" ? error.code : void 0;
-    return {
-      name: error.name || void 0,
-      message: error.message,
-      ...code !== void 0 && { code }
-    };
-  }
-  return { message: String(error) };
-}
-function handleSinkFailure(error, options) {
-  try {
-    options?.onError?.(error);
-  } catch {
-  }
-}
-function emitDroidLog(observability, event, options) {
-  const sink = observability?.logger;
-  if (!sink) {
-    return false;
-  }
-  try {
-    sink.log({
-      level: event.level,
-      name: event.name,
-      message: event.message,
-      attributes: sanitizeAttributes(event.attributes),
-      ...event.error !== void 0 && {
-        error: serializeError(event.error)
-      }
-    });
-    return true;
-  } catch (error) {
-    handleSinkFailure(error, options);
-    return false;
-  }
-}
-function recordDroidMetric(observability, event, options) {
-  const sink = observability?.metrics;
-  if (!sink) {
-    return false;
-  }
-  try {
-    sink.record({
-      name: event.name,
-      kind: event.kind,
-      value: event.value,
-      unit: event.unit,
-      attributes: sanitizeAttributes(event.attributes)
-    });
-    return true;
-  } catch (error) {
-    handleSinkFailure(error, options);
-    return false;
-  }
-}
-function injectDroidTraceContext(observability, carrier, options) {
-  const sink = observability?.tracing;
-  if (!sink) {
-    return false;
-  }
-  try {
-    sink.inject(carrier);
-    return true;
-  } catch (error) {
-    handleSinkFailure(error, options);
-    return false;
-  }
-}
-
 // src/exec-core/deps.ts
 function logWarn(logger, message, metadata) {
   logger.warn(message, metadata);
@@ -788,6 +751,7 @@ var JsonRpcEnvelopePeekSchema = JsonRpcEnvelopeSchema.partial().extend({
   method: z.string().optional(),
   id: z.string().nullable().optional()
 }).passthrough();
+var MCP_OAUTH_OPT_OUT_PROTOCOL_VERSION = "1.78.0";
 function inspectJsonRpcEnvelope2(message) {
   const result = JsonRpcEnvelopePeekSchema.safeParse(message);
   if (!result.success) {
@@ -811,8 +775,10 @@ var DroidClient = class _DroidClient extends EventEmitter {
   pendingRequests = /* @__PURE__ */ new Map();
   permissionHandlers = /* @__PURE__ */ new Map();
   askUserHandlers = /* @__PURE__ */ new Map();
+  pickOptionsHandlers = /* @__PURE__ */ new Map();
   pendingPermissionRequests = /* @__PURE__ */ new Map();
   pendingAskUserRequests = /* @__PURE__ */ new Map();
+  pendingPickOptionsRequests = /* @__PURE__ */ new Map();
   currentSessionId = null;
   peerProtocolVersion;
   /**
@@ -828,8 +794,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
   getRequestAttribution;
   constructor(options, deps = defaultExecCoreDeps) {
     super();
-    this.transport = options.transport;
     const resolved = resolveExecCoreDeps(options.observability, deps);
+    this.transport = options.transport;
     this.logger = resolved.logger;
     this.tracing = resolved.tracing;
     this.requestTimeout = options.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT2;
@@ -849,13 +815,28 @@ var DroidClient = class _DroidClient extends EventEmitter {
     });
     this.transport.onError((error) => {
       const err = error instanceof Error ? error : new Error(String(error));
+      const pendingSessionIds = /* @__PURE__ */ new Set();
+      let hasPendingIdlessSessionStart = false;
+      for (const pendingRequest of this.pendingRequests.values()) {
+        if (pendingRequest.method === "droid.initialize_session" /* INITIALIZE_SESSION */ && pendingRequest.sessionId === void 0) {
+          hasPendingIdlessSessionStart = true;
+        } else if (pendingRequest.sessionId !== void 0) {
+          pendingSessionIds.add(pendingRequest.sessionId);
+        }
+      }
+      const pendingSessionId = pendingSessionIds.size === 1 ? pendingSessionIds.values().next().value : void 0;
+      const sessionId = hasPendingIdlessSessionStart || pendingSessionIds.size > 1 ? void 0 : pendingSessionId ?? this.currentSessionId ?? void 0;
       const expectedCleanExit = err instanceof ProcessExitError && err.exitCode === 0 && this.completedTurnObserved;
       if (expectedCleanExit) {
         this.logger.info("[DroidClient] Process exited after completed turn", {
-          exitCode: err.exitCode
+          sessionId,
+          exitCode: err.exitCode,
+          signal: err.signal
         });
       } else {
-        this.logger.exception(err, "Transport error");
+        this.logger.exception(err, "Transport error", {
+          sessionId
+        });
       }
       this.transportError = err;
       this.rejectAllPending(err);
@@ -877,14 +858,18 @@ var DroidClient = class _DroidClient extends EventEmitter {
     return this.transport.isConnected;
   }
   requireMcpOAuthOptOutSupport() {
-    if (this.peerProtocolVersion === FACTORY_PROTOCOL_VERSION) {
+    if (isProtocolVersionAtLeast(
+      this.peerProtocolVersion,
+      MCP_OAUTH_OPT_OUT_PROTOCOL_VERSION
+    )) {
       return;
     }
     throw new ProtocolError(
-      "MCP OAuth opt-out requires a confirmed matching Droid protocol version. The connected Droid reported an incompatible protocol version and cannot disable OAuth for MCP servers.",
+      `MCP OAuth opt-out requires Droid protocol version ${MCP_OAUTH_OPT_OUT_PROTOCOL_VERSION} or newer. The connected Droid reported an older or unknown protocol version and cannot disable OAuth for MCP servers.`,
       {
         value: {
           localFactoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+          minimumFactoryProtocolVersion: MCP_OAUTH_OPT_OUT_PROTOCOL_VERSION,
           peerFactoryProtocolVersion: this.peerProtocolVersion
         }
       }
@@ -907,7 +892,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
     };
     const rawResponse = await this.sendRequest(
       request,
-      this.sessionInitTimeout
+      this.sessionInitTimeout,
+      params.sessionId
     );
     const response = InitializeSessionResponseSchema.parse(rawResponse);
     this.peerProtocolVersion = response.factoryProtocolVersion;
@@ -936,7 +922,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
     };
     const rawResponse = await this.sendRequest(
       request,
-      this.sessionInitTimeout
+      this.sessionInitTimeout,
+      params.sessionId
     );
     const response = LoadSessionResponseSchema.parse(rawResponse);
     this.peerProtocolVersion = response.factoryProtocolVersion;
@@ -1358,6 +1345,24 @@ var DroidClient = class _DroidClient extends EventEmitter {
     const response = ListMcpRegistryResponseSchema.parse(rawResponse);
     return response;
   }
+  async refreshConnectorToolCatalog(params = {}) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.refresh_connector_tool_catalog" /* REFRESH_CONNECTOR_TOOL_CATALOG */,
+      params
+    };
+    const response = await this.sendRequest(request, this.requestTimeout);
+    return RefreshConnectorToolCatalogResponseSchema.parse(response);
+  }
   async listMcpTools() {
     if (!this.currentSessionId) {
       throw new SessionError(
@@ -1378,6 +1383,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
     return response;
   }
   async listTools(params = {}) {
+    const schemasRequested = params.includeSchemas === true;
     const request = {
       factoryApiVersion: LEGACY_FACTORY_API_VERSION,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
@@ -1389,7 +1395,28 @@ var DroidClient = class _DroidClient extends EventEmitter {
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
     const response = ListToolsResponseSchema.parse(rawResponse);
-    return response;
+    if (!schemasRequested || !("result" in response)) {
+      return response;
+    }
+    const strictResult = ListToolsResultWithSchemasSchema.safeParse(
+      response.result
+    );
+    if (strictResult.success) {
+      return response;
+    }
+    const result = ListToolsResultSchema.parse(response.result);
+    const missingSchemaIds = [];
+    for (const tool2 of result.tools) {
+      if (tool2.schemas === void 0) {
+        missingSchemaIds.push(tool2.llmId);
+      }
+    }
+    if (missingSchemaIds.length > 0) {
+      throw new ProtocolError(
+        `The installed Droid version did not return requested schemas for tool IDs: ${missingSchemaIds.join(", ")}. Update Droid and try again.`
+      );
+    }
+    throw strictResult.error;
   }
   async listMcpServers() {
     if (!this.currentSessionId) {
@@ -1467,7 +1494,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
     const response = SubmitMcpAuthErrorResponseSchema.parse(rawResponse);
     return response;
   }
-  async listSkills() {
+  async listSkills(params = {}) {
     if (!this.currentSessionId) {
       throw new SessionError(
         "No active session. Call initializeSession or loadSession first."
@@ -1480,7 +1507,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       jsonrpc: JSONRPC_VERSION2,
       id: uuidv4(),
       method: "droid.list_skills" /* LIST_SKILLS */,
-      params: {}
+      params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
     const response = ListSkillsResponseSchema.parse(rawResponse);
@@ -1642,7 +1669,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       id: uuidv4(),
       method: "droid.compact_session" /* COMPACT_SESSION */,
       params: {
-        customInstructions: params.customInstructions
+        customInstructions: params.customInstructions,
+        mode: params.mode
       }
     };
     const rawResponse = await this.sendRequest(request, COMPACTION_TIMEOUT2);
@@ -1738,13 +1766,34 @@ var DroidClient = class _DroidClient extends EventEmitter {
   clearAskUserHandler() {
     this.askUserHandlers.delete("default");
   }
-  async close() {
+  setPickOptionsHandler(handler) {
+    this.pickOptionsHandlers.set(
+      "default",
+      async (event) => await handler(event)
+    );
+  }
+  clearPickOptionsHandler() {
+    this.pickOptionsHandlers.delete("default");
+  }
+  async close(options) {
     const closeError = new ConnectionError(
       "Droid client closed: pending requests cancelled"
     );
+    if (options?.closeTransportFirst) {
+      try {
+        await this.transport.close();
+      } finally {
+        this.rejectAllPending(closeError);
+        this.permissionHandlers.clear();
+        this.askUserHandlers.clear();
+        this.removeAllListeners();
+      }
+      return;
+    }
     this.rejectAllPending(closeError);
     this.permissionHandlers.clear();
     this.askUserHandlers.clear();
+    this.pickOptionsHandlers.clear();
     this.removeAllListeners();
     await this.transport.close();
   }
@@ -1765,6 +1814,10 @@ var DroidClient = class _DroidClient extends EventEmitter {
       reject(error);
     });
     this.pendingAskUserRequests.clear();
+    this.pendingPickOptionsRequests.forEach(({ reject }) => {
+      reject(error);
+    });
+    this.pendingPickOptionsRequests.clear();
   }
   settleRequest(requestId) {
     this.pendingRequests.delete(requestId);
@@ -1776,7 +1829,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
     } catch {
     }
   }
-  async sendRequest(request, timeout) {
+  async sendRequest(request, timeout, sessionId) {
     if (this.transportError) {
       throw this.transportError;
     }
@@ -1802,16 +1855,19 @@ var DroidClient = class _DroidClient extends EventEmitter {
           method: request.method,
           resolve: resolve2,
           reject,
-          timeoutId
+          timeoutId,
+          sessionId
         });
       }
     );
+    void responsePromise.catch(() => {
+    });
     try {
       this.logger.info("[DroidClient] [daemon -> droid] sending request", {
         requestId: request.id,
         method: request.method
       });
-      await this.transport.send(JSON.stringify(requestWithMeta));
+      await this.transport.send(requestWithMeta);
     } catch (error) {
       const pending = this.pendingRequests.get(request.id);
       if (pending) {
@@ -1831,20 +1887,13 @@ var DroidClient = class _DroidClient extends EventEmitter {
   }
   async handleMessage(message) {
     try {
-      const parsed = JSON.parse(message);
-      if ("result" in parsed || "error" in parsed) {
-        this.handleResponse(parsed);
-      } else if ("method" in parsed) {
-        await this.handleEvent(parsed);
+      if (message.type === "response") {
+        this.handleResponse(message);
       } else {
-        throw new ProtocolError("Invalid message format", {
-          message
-        });
+        await this.handleEvent(message);
       }
     } catch {
-      this.logger.warn("[DroidClient] Failed to handle message", {
-        messageByteLength: new TextEncoder().encode(message).byteLength
-      });
+      this.logger.warn("[DroidClient] Failed to handle message");
     }
   }
   handleResponse(response) {
@@ -1912,6 +1961,9 @@ var DroidClient = class _DroidClient extends EventEmitter {
             case "droid.list_tools" /* LIST_TOOLS */:
               validatedResponse = ListToolsResponseSchema.parse(response);
               break;
+            case "droid.refresh_connector_tool_catalog" /* REFRESH_CONNECTOR_TOOL_CATALOG */:
+              validatedResponse = RefreshConnectorToolCatalogResponseSchema.parse(response);
+              break;
             case "droid.toggle_mcp_tool" /* TOGGLE_MCP_TOOL */:
               validatedResponse = ToggleMcpToolResponseSchema.parse(response);
               break;
@@ -2052,6 +2104,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
         await this.handlePermissionRequest(validatedEvent);
       } else if (validatedEvent.method === "droid.ask_user" /* ASK_USER */) {
         await this.handleAskUserRequest(validatedEvent);
+      } else if (validatedEvent.method === "droid.pick_options" /* PICK_OPTIONS */) {
+        await this.handlePickOptionsRequest(validatedEvent);
       }
     } catch (error) {
       this.logDroppedEventParseError(error, event);
@@ -2086,7 +2140,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       }
     };
     try {
-      await this.transport.send(JSON.stringify(errorResponse));
+      await this.transport.send(errorResponse);
     } catch (sendError) {
       this.logger.exception(
         sendError,
@@ -2149,6 +2203,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
     let selectedOption = "cancel" /* Cancel */;
     let comment;
     let editedSpecContent;
+    let clientStartsHandoffSession;
+    let specHandoffId;
     const handler = this.permissionHandlers.get("default");
     if (handler) {
       try {
@@ -2179,6 +2235,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
           selectedOption = parsedHandlerResult.data.selectedOption;
           comment = parsedHandlerResult.data.comment;
           editedSpecContent = parsedHandlerResult.data.editedSpecContent;
+          clientStartsHandoffSession = parsedHandlerResult.data.clientStartsHandoffSession;
+          specHandoffId = parsedHandlerResult.data.specHandoffId;
         } else {
           throw new DroidClientError(
             "Permission handler returned invalid result",
@@ -2222,7 +2280,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
           }
         };
         try {
-          await this.transport.send(JSON.stringify(cancelResponse));
+          await this.transport.send(cancelResponse);
         } catch (sendError) {
           this.logger.exception(
             sendError,
@@ -2248,14 +2306,18 @@ var DroidClient = class _DroidClient extends EventEmitter {
       result: {
         selectedOption,
         ...comment !== void 0 && { comment },
-        ...editedSpecContent !== void 0 && { editedSpecContent }
+        ...editedSpecContent !== void 0 && { editedSpecContent },
+        ...clientStartsHandoffSession !== void 0 && {
+          clientStartsHandoffSession
+        },
+        ...specHandoffId !== void 0 && { specHandoffId }
       }
     };
     this.logger.info("[DroidClient] Sending permission response back to CLI", {
       requestId: event.id,
       result: String(selectedOption)
     });
-    await this.transport.send(JSON.stringify(response));
+    await this.transport.send(response);
   }
   async handleAskUserRequest(event) {
     this.logger.info("[DroidClient] Handling ask-user request", {
@@ -2319,7 +2381,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
           }
         };
         try {
-          await this.transport.send(JSON.stringify(cancelResponse));
+          await this.transport.send(cancelResponse);
         } catch (sendError) {
           this.logger.exception(
             sendError,
@@ -2341,7 +2403,105 @@ var DroidClient = class _DroidClient extends EventEmitter {
       requestId: event.id,
       cancelled: result.cancelled ?? false
     });
-    await this.transport.send(JSON.stringify(response));
+    await this.transport.send(response);
+  }
+  /**
+   * Same shape as the ask-user round trip: the handler (a UI) resolves with
+   * the user's selection, and any failure or missing handler answers the CLI
+   * with a cancellation so its tool call never hangs. A handler that rejects
+   * with {@link PickOptionsUnavailableError} is relayed as that JSON-RPC
+   * error instead, which the CLI does not read as the user's cancel.
+   */
+  async handlePickOptionsRequest(event) {
+    this.logger.info("[DroidClient] Handling pick-options request", {
+      requestId: event.id,
+      toolCallId: event.params.toolCallId,
+      count: event.params.rows.length
+    });
+    this.emit("pick_options" /* PICK_OPTIONS */, event);
+    let result = { cancelled: true, selectedIds: [] };
+    const handler = this.pickOptionsHandlers.get("default");
+    if (handler) {
+      try {
+        const handlerPromise = new Promise(
+          (resolve2, reject) => {
+            this.pendingPickOptionsRequests.set(event.id, { reject });
+            handler(event).then(resolve2).catch(reject).finally(() => {
+              this.pendingPickOptionsRequests.delete(event.id);
+            });
+          }
+        );
+        const parsedResult = PickOptionsResultSchema.safeParse(
+          await handlerPromise
+        );
+        if (!parsedResult.success) {
+          throw new DroidClientError(
+            "PickOptions handler returned invalid result",
+            { cause: parsedResult.error }
+          );
+        }
+        result = parsedResult.data;
+      } catch (error) {
+        this.pendingPickOptionsRequests.delete(event.id);
+        if (error instanceof PickOptionsUnavailableError) {
+          this.logger.info("[DroidClient] Pick-options request unavailable", {
+            requestId: event.id,
+            code: error.rpcError.code
+          });
+          const failure = {
+            jsonrpc: JSONRPC_VERSION2,
+            factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+            factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+            type: "response",
+            id: event.id,
+            error: error.rpcError
+          };
+          try {
+            await this.transport.send(failure);
+          } catch (sendError) {
+            this.logger.exception(
+              sendError,
+              "Failed to send pick-options failure"
+            );
+          }
+          return;
+        }
+        this.logger.exception(error, "Failed to handle pick-options request");
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.emit(
+          "session_notification" /* SESSION_NOTIFICATION */,
+          _DroidClient.createNotificationEvent(
+            _DroidClient.createErrorNotification(err)
+          )
+        );
+        const cancelResponse = {
+          jsonrpc: JSONRPC_VERSION2,
+          factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+          factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+          type: "response",
+          id: event.id,
+          result: { cancelled: true, selectedIds: [] }
+        };
+        try {
+          await this.transport.send(cancelResponse);
+        } catch (sendError) {
+          this.logger.exception(
+            sendError,
+            "Failed to send pick-options cancellation"
+          );
+        }
+        return;
+      }
+    }
+    const response = {
+      type: "response",
+      jsonrpc: JSONRPC_VERSION2,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      id: event.id,
+      result
+    };
+    await this.transport.send(response);
   }
   static getErrorType(error) {
     switch (error.constructor) {
@@ -2403,10 +2563,52 @@ var DroidClient = class _DroidClient extends EventEmitter {
   }
 };
 
+// src/exec-core/message-transport.ts
+var JsonRpcCodecTransport = class {
+  transport;
+  logger;
+  constructor(transport, logger) {
+    this.transport = transport;
+    this.logger = logger;
+  }
+  send(message) {
+    return this.transport.send(JSON.stringify(message));
+  }
+  onMessage(handler) {
+    this.transport.onMessage((frame) => {
+      const message = decodeDroidMessage(frame, this.logger);
+      if (message) handler(message);
+    });
+  }
+  onError(handler) {
+    this.transport.onError(handler);
+  }
+  close() {
+    return this.transport.close();
+  }
+  get isConnected() {
+    return this.transport.isConnected;
+  }
+};
+function withJsonRpcCodec(transport, deps = defaultExecCoreDeps) {
+  const { logger } = resolveExecCoreDeps(void 0, deps);
+  return new JsonRpcCodecTransport(transport, logger);
+}
+function decodeDroidMessage(frame, logger) {
+  try {
+    return JsonRpcMessageSchema.parse(JSON.parse(frame));
+  } catch (error) {
+    logWarn(logger, "[DroidClient] Failed to handle message", {
+      errorName: error instanceof Error ? error.name : typeof error,
+      messageByteLength: new TextEncoder().encode(frame).byteLength
+    });
+    return void 0;
+  }
+}
+
 // src/exec-core/managed-process.ts
 import { spawnSync } from "child_process";
 import fs2 from "fs";
-import * as readline from "readline";
 
 // src/exec-core/runtime-utils.ts
 import { homedir } from "os";
@@ -2637,7 +2839,13 @@ var ManagedProcessImpl = class {
   _childProcess;
   messageHandler = null;
   errorHandler = null;
-  readlineInterface = null;
+  stdoutDecoder = new LfLineDecoder();
+  stdoutDataHandler = (chunk) => {
+    const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    for (const line of this.stdoutDecoder.push(text)) {
+      this.handleStdoutLine(line);
+    }
+  };
   isClosing = false;
   /** Latch so exit teardown/classification runs exactly once per process. */
   exitFinalized = false;
@@ -2660,31 +2868,12 @@ var ManagedProcessImpl = class {
     if (!this.childProcess.stdout) {
       throw new ConnectionError("Failed to get process stdout");
     }
-    this.readlineInterface = readline.createInterface({
-      input: this.childProcess.stdout,
-      crlfDelay: Infinity
-    });
-    this.readlineInterface.on("line", (line) => {
-      const trimmedLine = line.trim();
-      if (this.messageHandler && trimmedLine) {
-        if (trimmedLine.startsWith("{") || trimmedLine.startsWith("[")) {
-          logTransportMessage(
-            "in" /* In */,
-            trimmedLine,
-            this._childProcess?.pid,
-            this.transportLoggerDeps
-          );
-          this.messageHandler(trimmedLine);
-        } else {
-          const truncated = trimmedLine.length > MAX_NON_JSON_LOG_LENGTH ? trimmedLine.substring(0, MAX_NON_JSON_LOG_LENGTH) : trimmedLine;
-          this.logger.warn("[droid process] non-JSON output", {
-            state: this.logPrefix,
-            output: truncated
-          });
-        }
-      }
-    });
+    this.childProcess.stdout.setEncoding("utf8");
+    this.childProcess.stdout.on("data", this.stdoutDataHandler);
     this.childProcess.on("error", (error) => {
+      if (this.processError || this.isClosing || this.exitFinalized) {
+        return;
+      }
       this.processError = new ConnectionError(
         describeSpawnError(error, this.spawnContext),
         {
@@ -2693,9 +2882,16 @@ var ManagedProcessImpl = class {
           execPath: this.spawnContext?.execPath
         }
       );
-      if (!this.isClosing && this.errorHandler) {
-        this.errorHandler(this.processError);
+      this.errorHandler?.(this.processError);
+    });
+    this.childProcess.stdin?.on("error", (error) => {
+      if (this.processError || this.isClosing || this.exitFinalized) {
+        return;
       }
+      this.processError = new ConnectionError("Process stdin failed", {
+        error
+      });
+      this.errorHandler?.(this.processError);
     });
     this.childProcess.on("exit", (code, signal) => {
       this.exitDrainTimer = setTimeout(() => {
@@ -2704,6 +2900,9 @@ var ManagedProcessImpl = class {
       this.exitDrainTimer.unref?.();
     });
     this.childProcess.on("close", (code, signal) => {
+      for (const line of this.stdoutDecoder.finish()) {
+        this.handleStdoutLine(line);
+      }
       this.finalizeExit(code, signal);
     });
     if (this.childProcess.stderr) {
@@ -2715,6 +2914,27 @@ var ManagedProcessImpl = class {
       });
     }
   }
+  handleStdoutLine(line) {
+    const trimmedLine = line.trim();
+    if (!this.messageHandler || !trimmedLine) {
+      return;
+    }
+    if (trimmedLine.startsWith("{") || trimmedLine.startsWith("[")) {
+      logTransportMessage(
+        "in" /* In */,
+        trimmedLine,
+        this._childProcess?.pid,
+        this.transportLoggerDeps
+      );
+      this.messageHandler(trimmedLine);
+      return;
+    }
+    const truncated = trimmedLine.length > MAX_NON_JSON_LOG_LENGTH ? trimmedLine.substring(0, MAX_NON_JSON_LOG_LENGTH) : trimmedLine;
+    this.logger.warn("[droid process] non-JSON output", {
+      state: this.logPrefix,
+      output: truncated
+    });
+  }
   finalizeExit(code, signal) {
     if (this.exitFinalized) {
       return;
@@ -2724,12 +2944,10 @@ var ManagedProcessImpl = class {
       clearTimeout(this.exitDrainTimer);
       this.exitDrainTimer = null;
     }
+    this._childProcess?.stdout?.off("data", this.stdoutDataHandler);
     this._childProcess = null;
-    if (this.readlineInterface) {
-      this.readlineInterface.close();
-      this.readlineInterface = null;
-    }
-    if (!this.isClosing) {
+    this.stdoutDecoder.reset();
+    if (!this.isClosing && !this.processError) {
       this.processError = new ProcessExitError(
         describeExitError(code, signal),
         {
@@ -2768,7 +2986,7 @@ var ManagedProcessImpl = class {
             return;
           }
           const childPid = this._childProcess?.pid;
-          stdin.write(`${message}
+          stdin.write(`${escapeJsonLineSeparators(message)}
 `, (error) => {
             if (error) {
               logTransportMessage(
@@ -2858,11 +3076,9 @@ var ManagedProcessImpl = class {
           }
         });
       }
+      processToClose.stdout?.off("data", this.stdoutDataHandler);
     }
-    if (this.readlineInterface) {
-      this.readlineInterface.close();
-      this.readlineInterface = null;
-    }
+    this.stdoutDecoder.reset();
     this.exitFinalized = true;
     if (this.exitDrainTimer) {
       clearTimeout(this.exitDrainTimer);
@@ -3011,6 +3227,14 @@ async function spawnWithWindowsJobObjectRetry(spawnFactory, options = {}) {
 }
 
 // src/exec-core/process-manager.ts
+var NATIVE_PROCESS_LIFECYCLE_MESSAGE = "[droid process] native lifecycle";
+var MAX_SPAWN_ERROR_CODE_LENGTH = 64;
+function getSpawnErrorCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error) || typeof error.code !== "string" && typeof error.code !== "number") {
+    return void 0;
+  }
+  return String(error.code).slice(0, MAX_SPAWN_ERROR_CODE_LENGTH);
+}
 function buildArgs(config) {
   const args = [];
   if (config.mode === "acp" /* Acp */) {
@@ -3029,6 +3253,13 @@ function buildArgs(config) {
   }
   return args;
 }
+function ensureIpcStdio(stdio) {
+  if (Array.isArray(stdio)) {
+    return stdio.includes("ipc") ? stdio : [...stdio, "ipc"];
+  }
+  const standardChannel = stdio ?? "pipe";
+  return [standardChannel, standardChannel, standardChannel, "ipc"];
+}
 var DroidProcessManager = class {
   deps;
   transportLoggerDeps;
@@ -3109,6 +3340,7 @@ var DroidProcessManager = class {
       }
     );
     if (!childProcess.stdout || !childProcess.stdin) {
+      childProcess.kill();
       throw new ConnectionError("Failed to get process stdio");
     }
     return new ManagedProcessImpl(
@@ -3155,20 +3387,87 @@ var DroidProcessManager = class {
     };
   }
   invokeNodeSpawn(planned) {
+    const stdio = planned.enableIpc ? ensureIpcStdio(planned.stdio) : planned.stdio ?? ["pipe", "pipe", "pipe"];
     const options = {
       cwd: planned.expandedCwd,
       env: planned.env,
-      stdio: planned.stdio ?? (planned.enableIpc ? ["pipe", "pipe", "pipe", "ipc"] : ["pipe", "pipe", "pipe"])
+      stdio
     };
     if (planned.enableIpc) {
       options.serialization = "json";
     }
-    return spawn(planned.execPath, planned.args, options);
+    const spawnedAt = Date.now();
+    let childProcess;
+    try {
+      childProcess = spawn(planned.execPath, planned.args, options);
+    } catch (error) {
+      const failedAt = Date.now();
+      this.logNativeProcessLifecycle({
+        state: "spawn_error",
+        pid: null,
+        createdAt: spawnedAt,
+        eventDate: new Date(failedAt).toISOString(),
+        durationMs: failedAt - spawnedAt,
+        errnoCode: getSpawnErrorCode(error)
+      });
+      throw error;
+    }
+    const pid = childProcess.pid;
+    if (pid === void 0) {
+      childProcess.once("error", (error) => {
+        const failedAt = Date.now();
+        this.logNativeProcessLifecycle({
+          state: "spawn_error",
+          pid: null,
+          createdAt: spawnedAt,
+          eventDate: new Date(failedAt).toISOString(),
+          durationMs: failedAt - spawnedAt,
+          errnoCode: getSpawnErrorCode(error)
+        });
+      });
+    } else {
+      childProcess.once("exit", (exitCode, signal) => {
+        const exitedAt = Date.now();
+        this.logNativeProcessLifecycle({
+          state: "exited",
+          pid,
+          createdAt: spawnedAt,
+          eventDate: new Date(exitedAt).toISOString(),
+          durationMs: exitedAt - spawnedAt,
+          exitCode,
+          signal
+        });
+      });
+      this.logNativeProcessLifecycle({
+        state: "spawned",
+        pid,
+        createdAt: spawnedAt,
+        eventDate: new Date(spawnedAt).toISOString()
+      });
+    }
+    return childProcess;
+  }
+  /**
+   * Emits the content-free native process record consumed by lifecycle
+   * measurement harnesses. `createdAt` is the wall-clock lower bound captured
+   * immediately before spawn; `eventDate` is the wall-clock observation time.
+   */
+  logNativeProcessLifecycle(record) {
+    try {
+      this.logger.info(NATIVE_PROCESS_LIFECYCLE_MESSAGE, record);
+    } catch (loggingError) {
+      void loggingError;
+      logWarn(
+        defaultExecCoreDeps.logger,
+        "[droid process] native lifecycle logger failed"
+      );
+    }
   }
   spawnChildProcess(config) {
     const planned = this.prepareSpawn(config);
     const childProcess = this.invokeNodeSpawn(planned);
     if (!childProcess.stdout || !childProcess.stdin) {
+      childProcess.kill();
       throw new ConnectionError("Failed to get process stdio");
     }
     return {
@@ -3187,12 +3486,20 @@ var ProcessTransport = class {
   options;
   // Store handlers that may be registered before connect() is called
   messageHandler = null;
+  logger;
+  handleMessage = (frame) => {
+    const message = decodeDroidMessage(frame, this.logger);
+    if (message) this.messageHandler?.(message);
+  };
   errorHandler = null;
   metrics;
+  environmentResolver;
   constructor(options = {}, deps = defaultExecCoreDeps) {
     this.options = options;
     const resolved = resolveExecCoreDeps(options.observability, deps);
+    this.logger = resolved.logger;
     this.metrics = resolved.metrics;
+    this.environmentResolver = resolved.environmentResolver;
     this.processManager = new DroidProcessManager(
       {
         observability: options.observability
@@ -3210,13 +3517,21 @@ var ProcessTransport = class {
       mode: "stream-jsonrpc" /* StreamJsonRpc */,
       cwd: this.options.cwd,
       env: this.options.env,
+      trustedEnv: {
+        ...this.options.runtimeSettingsAuthority ? this.environmentResolver.buildRuntimeSettingsAuthorityEnv(
+          this.options.runtimeSettingsAuthority
+        ) : {},
+        ...this.options.trustedEnv
+      },
       extraArgs: this.options.droidExecExtraArgs,
-      enableIpc: this.options.enableIpc
+      enableIpc: this.options.enableIpc,
+      stdio: this.options.stdio
     };
     const spawnStart = performance.now();
     let spawnOutcome = "error";
+    let managedProcess;
     try {
-      this.managedProcess = process.platform === "win32" ? await this.processManager.spawnWithWindowsRetry(config) : this.processManager.spawn(config);
+      managedProcess = process.platform === "win32" ? await this.processManager.spawnWithWindowsRetry(config) : this.processManager.spawn(config);
       spawnOutcome = "success";
     } finally {
       this.metrics.recordDuration(
@@ -3225,8 +3540,15 @@ var ProcessTransport = class {
         { outcome: spawnOutcome, source: "process_transport" }
       );
     }
+    try {
+      this.options.onSpawned?.(managedProcess.childProcess);
+    } catch (error) {
+      await managedProcess.close();
+      throw error;
+    }
+    this.managedProcess = managedProcess;
     if (this.messageHandler) {
-      this.managedProcess.onMessage(this.messageHandler);
+      this.managedProcess.onMessage(this.handleMessage);
     }
     if (this.errorHandler) {
       this.managedProcess.onError(this.errorHandler);
@@ -3236,12 +3558,12 @@ var ProcessTransport = class {
     if (!this.managedProcess) {
       throw new ConnectionError("Transport not connected");
     }
-    return this.managedProcess.send(message);
+    return await this.managedProcess.send(JSON.stringify(message));
   }
   onMessage(handler) {
     this.messageHandler = handler;
     if (this.managedProcess) {
-      this.managedProcess.onMessage(handler);
+      this.managedProcess.onMessage(this.handleMessage);
     }
   }
   onError(handler) {
@@ -3372,15 +3694,21 @@ import http from "http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { z as z2 } from "zod";
-function tool(name, description, inputSchemaOrHandler, handler) {
+function tool(name, description, inputSchemaOrHandler, handlerOrOptions, maybeOptions) {
+  const options = typeof handlerOrOptions === "function" ? maybeOptions : handlerOrOptions;
+  const annotationFields = options?.annotations && {
+    annotations: options.annotations
+  };
   if (typeof inputSchemaOrHandler === "function") {
     const actualHandler = inputSchemaOrHandler;
     return {
       name,
       description,
-      handler: (input) => actualHandler(input)
+      handler: (input) => actualHandler(input),
+      ...annotationFields
     };
   }
+  const handler = typeof handlerOrOptions === "function" ? handlerOrOptions : void 0;
   if (!handler) {
     throw new Error(`Missing handler for SDK MCP tool "${name}"`);
   }
@@ -3389,7 +3717,8 @@ function tool(name, description, inputSchemaOrHandler, handler) {
     name,
     description,
     inputSchema: inputSchemaOrHandler,
-    handler: (input) => handler(inputObjectSchema.parse(input))
+    handler: (input) => handler(inputObjectSchema.parse(input)),
+    ...annotationFields
   };
 }
 function isSdkMcpServer(server) {
@@ -3515,7 +3844,8 @@ var SdkMcpServer = class {
           description: sdkTool.description,
           ...sdkTool.inputSchema && {
             inputSchema: sdkTool.inputSchema
-          }
+          },
+          ...sdkTool.annotations && { annotations: sdkTool.annotations }
         },
         async (input) => toCallToolResult(await sdkTool.handler(input))
       );
@@ -3717,6 +4047,11 @@ var DroidSession = class _DroidSession {
     this._ensureNotClosed();
     return unwrapResponseResult(await this._client.listMcpTools()).tools;
   }
+  /** Refresh connector discovery. MCP configuration has its own lifecycle. */
+  async refreshConnectorToolCatalog() {
+    this._ensureNotClosed();
+    unwrapResponseResult(await this._client.refreshConnectorToolCatalog());
+  }
   async listTools(params = {}) {
     this._ensureNotClosed();
     return unwrapResponseResult(await this._client.listTools(params)).tools.map(
@@ -3733,9 +4068,9 @@ var DroidSession = class _DroidSession {
       await this._client.authenticateMcpServer(params)
     );
   }
-  async listSkills() {
+  async listSkills(params) {
     this._ensureNotClosed();
-    return unwrapResponseResult(await this._client.listSkills());
+    return unwrapResponseResult(await this._client.listSkills(params));
   }
   async setSkillDisabled(params) {
     this._ensureNotClosed();
@@ -3760,7 +4095,14 @@ var DroidSession = class _DroidSession {
   }
   async compact(params) {
     const { session, result } = await this._runReplacement(
-      () => this._client.compactSession(params ?? {}).then(unwrapResponseResult)
+      () => this._client.compactSession(params ?? {}).then(unwrapResponseResult),
+      { retainSourceWhenSameId: true }
+    );
+    return { session, removedCount: result.removedCount };
+  }
+  async handoff(params) {
+    const { session, result } = await this._runReplacement(
+      () => this._client.compactSession({ ...params, mode: "handoff" }).then(unwrapResponseResult)
     );
     return { session, removedCount: result.removedCount };
   }
@@ -3808,7 +4150,7 @@ var DroidSession = class _DroidSession {
     }
     this._status = "replacing";
   }
-  async _runReplacement(operation) {
+  async _runReplacement(operation, options) {
     this._beginReplacement();
     let result;
     try {
@@ -3829,6 +4171,10 @@ var DroidSession = class _DroidSession {
         )
       });
     }
+    if (options?.retainSourceWhenSameId && result.newSessionId === this._sessionId) {
+      this._status = "active";
+      return { session: this, result };
+    }
     return {
       session: await this._loadReplacement(result.newSessionId),
       result
@@ -4360,6 +4706,7 @@ export {
   ConnectionError,
   ConnectionFailureReason,
   ContentBlockSchema,
+  ContextApiError,
   ContextBreakdownCategorySchema,
   GetContextBreakdownResultSchema as ContextBreakdownResultSchema,
   ContextStatsAccuracy,
@@ -4403,6 +4750,7 @@ export {
   ErrorDetailSchema,
   ErrorNotificationSchema,
   ExecToolInfoSchema,
+  ExecToolInfoWithSchemasSchema,
   ExecuteRewindRequestParamsSchema,
   ExecuteRewindRequestSchema,
   ExecuteRewindResponseSchema,
@@ -4496,7 +4844,9 @@ export {
   ListToolsRequestParamsSchema,
   ListToolsRequestSchema,
   ListToolsResponseSchema,
+  ListToolsResponseWithSchemasSchema,
   ListToolsResultSchema,
+  ListToolsResultWithSchemasSchema,
   LoadSessionRequestParamsSchema,
   LoadSessionRequestSchema,
   LoadSessionResponseSchema,
@@ -4551,6 +4901,12 @@ export {
   OutputFormatSchema,
   OutputFormatType,
   PermissionResolvedNotificationSchema,
+  PickOptionsRequestParamsSchema,
+  PickOptionsRequestSchema,
+  PickOptionsResponseSchema,
+  PickOptionsResultSchema,
+  PickOptionsRowSchema,
+  PickOptionsUnavailableError,
   ProcessExitError,
   ProcessTransport,
   ProgressLogEntrySchema,
@@ -4587,6 +4943,12 @@ export {
   SLACK_DELEGATION_MAX_RETRIES,
   SdkMcpServer,
   ServerRequestHandlerType,
+  SessionArtifactAction,
+  SessionArtifactKind,
+  SessionArtifactProvider,
+  SessionArtifactSchema,
+  SessionArtifactSource,
+  SessionArtifactsSchema,
   SessionError,
   SessionMetadataSchema,
   SessionNotFoundError,
@@ -4658,11 +5020,15 @@ export {
   ToolConfirmationListItemSchema,
   ToolConfirmationOutcome,
   ToolConfirmationType,
+  ToolJsonSchemaSchema,
   ToolProgressUpdateNotificationSchema,
   ToolProgressUpdateSchema,
   ToolResultSchema as ToolResultBlockSchema,
   ToolResultNotificationSchema,
+  ToolResultSchemaDescriptorSchema,
+  ToolSchemasSchema,
   ToolSelectionOverridesSchema,
+  ToolSourceSchema,
   ToolUseSchema as ToolUseBlockSchema,
   ToolUseSchema2 as ToolUseSchema,
   TraceContextMetaSchema,
@@ -4684,6 +5050,7 @@ export {
   WorkerStartedEntrySchema,
   WorkerStateInfoSchema,
   __resetTransportLoggerForTests,
+  appendContextSession,
   buildUserMessageContentBlocks,
   configureDaemonCoreDeps,
   connectAndAuthenticate,
@@ -4691,16 +5058,25 @@ export {
   connectWithRetry,
   convertNotificationToStreamMessage,
   createComputer,
+  createContextDocument,
+  createContextFile,
+  createContextSpace,
   createResponseSchema,
   createSdkMcpServer,
   createSession,
   createWebSocketDaemonClient,
   defaultDaemonCoreDeps,
   deleteComputer,
+  deleteContextDocument,
+  deleteContextFile,
   filterMessagesForUI,
   getComputer,
   getComputerByName,
   getComputerMetrics,
+  getContextDocument,
+  getContextDocumentByPath,
+  getContextSession,
+  getContextSpace,
   getMachineTemplate,
   getPermissionToolInputForDisplay,
   getQueuedUserMessageDisplayGroup,
@@ -4717,6 +5093,9 @@ export {
   isReviewableQueuedMessageKind,
   isTransportLoggingEnabled,
   listComputers,
+  listContextDocuments,
+  listContextSessions,
+  listContextSpaces,
   listMachineTemplates,
   listModels,
   listRemoteSessions,
@@ -4724,10 +5103,11 @@ export {
   logTransportMessage,
   machineTypeToMachineConnectionType,
   noopLogger,
-  orderMessagesByParentChain,
+  readContextFilePart,
+  readContextSessionRecords,
   recordComputerConnectSli,
   refreshComputer,
-  repairParentChainCorruption,
+  registerContextSession,
   resolveExecCoreDeps,
   restartComputer,
   resumeSession,
@@ -4739,6 +5119,9 @@ export {
   summarizeSessionToolUsage,
   toError,
   tool,
-  updateComputer
+  updateComputer,
+  updateContextDocument,
+  uploadContextFilePart,
+  withJsonRpcCodec
 };
 //# sourceMappingURL=node.mjs.map