@factory/droid-sdk 0.3.0 → 0.4.0

package/dist/index.js

@@ -255,6 +255,11 @@ var JsonRpcMessageType = /* @__PURE__ */ ((JsonRpcMessageType2) => {
   JsonRpcMessageType2["Notification"] = "notification";
   return JsonRpcMessageType2;
 })(JsonRpcMessageType || {});
+var ServerRequestHandlerType = /* @__PURE__ */ ((ServerRequestHandlerType2) => {
+  ServerRequestHandlerType2["Permission"] = "permission";
+  ServerRequestHandlerType2["AskUser"] = "askUser";
+  return ServerRequestHandlerType2;
+})(ServerRequestHandlerType || {});
 var SettingsLevel = /* @__PURE__ */ ((SettingsLevel2) => {
   SettingsLevel2["Org"] = "org";
   SettingsLevel2["Runtime"] = "runtime";
@@ -275,7 +280,7 @@ var SkillLocation = /* @__PURE__ */ ((SkillLocation2) => {
 // src/schemas/constants.ts
 var JSONRPC_VERSION = "2.0";
 var LEGACY_FACTORY_API_VERSION = "1.0.0";
-var FACTORY_PROTOCOL_VERSION = "1.3.0";
+var FACTORY_PROTOCOL_VERSION = "1.51.0";
 var FACTORY_CLIENT_HEADER = "X-Factory-Client";
 var FACTORY_CLIENT_VERSION = "X-Client-Version";
 var DEFAULT_REQUEST_TIMEOUT = 3e4;
@@ -1135,6 +1140,19 @@ var ForkSessionResultSchema = z5.object({
   newSessionId: z5.string()
 }).passthrough();
 var GetContextStatsResultSchema = ContextStatsSchema;
+var ContextBreakdownCategorySchema = z5.object({
+  name: z5.string(),
+  tokens: z5.number(),
+  colorKey: z5.string()
+}).passthrough();
+var ContextBreakdownResultSchema = z5.object({
+  modelId: z5.string(),
+  modelDisplayName: z5.string(),
+  contextBudget: z5.number(),
+  usedTokens: z5.number(),
+  freeTokens: z5.number(),
+  categories: z5.array(ContextBreakdownCategorySchema)
+}).passthrough();
 var RenameSessionResultSchema = SuccessResultSchema;
 var InitializeSessionResponseSchema = createResponseSchema(
   InitializeSessionResultSchema
@@ -1638,7 +1656,7 @@ var _CliRequestOrNotificationSchema = z8.union([
 var CliRequestOrNotificationSchema = _CliRequestOrNotificationSchema;
 
 // src/constants.ts
-var SDK_VERSION = "0.3.0";
+var SDK_VERSION = "0.4.0";
 var SDK_TAG = {
   name: "sdk",
   metadata: { language: "typescript", version: SDK_VERSION }
@@ -1972,9 +1990,14 @@ function dispatchNotification(notification, listeners) {
     }
   }
 }
+var DEFAULT_SERVER_REQUEST_METHOD_MAP = {
+  ["droid.request_permission" /* REQUEST_PERMISSION */]: "permission" /* Permission */,
+  ["droid.ask_user" /* ASK_USER */]: "askUser" /* AskUser */
+};
 var ProtocolEngine = class {
   _transport;
   _defaultTimeout;
+  _serverRequestMethodMap;
   _pendingRequests = /* @__PURE__ */ new Map();
   _notificationListeners = /* @__PURE__ */ new Set();
   _permissionHandler = null;
@@ -1984,6 +2007,7 @@ var ProtocolEngine = class {
   constructor(options) {
     this._transport = options.transport;
     this._defaultTimeout = options.defaultTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+    this._serverRequestMethodMap = options.serverRequestMethodMap ?? DEFAULT_SERVER_REQUEST_METHOD_MAP;
     this._transport.onMessage((message) => {
       this._handleMessage(message);
     });
@@ -2139,9 +2163,10 @@ var ProtocolEngine = class {
     dispatchNotification(notification, this._notificationListeners);
   }
   async _handleServerRequest(method, requestId, params) {
-    if (method === "droid.request_permission" /* REQUEST_PERMISSION */) {
+    const handlerType = this._serverRequestMethodMap[method];
+    if (handlerType === "permission" /* Permission */) {
       await this._handlePermissionRequest(requestId, params);
-    } else if (method === "droid.ask_user" /* ASK_USER */) {
+    } else if (handlerType === "askUser" /* AskUser */) {
       await this._handleAskUserRequest(requestId, params);
     }
   }
@@ -2999,6 +3024,69 @@ function wireAbortSignal(signal, onAbort) {
     return () => signal.removeEventListener("abort", listener);
   }
 }
+function getAbortError(signal) {
+  if (signal.reason instanceof Error) {
+    return signal.reason;
+  }
+  return new Error(
+    typeof signal.reason === "string" ? signal.reason : "Operation aborted"
+  );
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw getAbortError(signal);
+  }
+}
+async function* streamFromClient(client, sessionId, activeBridges, prompt, options) {
+  throwIfAborted(options?.abortSignal);
+  const startedAt = Date.now();
+  let resolveDone = () => {
+  };
+  const donePromise = new Promise((resolve2) => {
+    resolveDone = resolve2;
+  });
+  const bridge = new MessageBridge(resolveDone, {
+    includePartialMessages: options?.includePartialMessages,
+    sessionId,
+    startedAt,
+    outputFormat: options?.outputFormat
+  });
+  activeBridges.add(bridge);
+  const unsubscribe = client.onNotification(bridge.notificationHandler);
+  let resolveAbort = () => {
+  };
+  const abortPromise = new Promise((resolve2) => {
+    resolveAbort = resolve2;
+  });
+  const cleanupAbortSignal = wireAbortSignal(options?.abortSignal, () => {
+    bridge.signalDone();
+    resolveAbort();
+    void client.interruptSession().catch(() => {
+    });
+  });
+  try {
+    await Promise.race([
+      client.addUserMessage({
+        text: prompt,
+        images: options?.images,
+        files: options?.files,
+        outputFormat: options?.outputFormat
+      }),
+      donePromise,
+      abortPromise
+    ]);
+    throwIfAborted(options?.abortSignal);
+    for await (const msg of bridge.messages()) {
+      throwIfAborted(options?.abortSignal);
+      yield msg;
+    }
+    throwIfAborted(options?.abortSignal);
+  } finally {
+    cleanupAbortSignal();
+    unsubscribe();
+    activeBridges.delete(bridge);
+  }
+}
 function extractInnerNotification(notification) {
   const parsed = SessionNotificationSchema.safeParse(notification);
   return parsed.success ? parsed.data.params.notification : null;
@@ -3094,7 +3182,7 @@ async function createTransport(options) {
     execPath: options.execPath,
     execArgs: options.execArgs,
     cwd: options.cwd,
-    env: options.env
+    env: { ...options.env, FACTORY_API_KEY: options.apiKey }
   };
   const processTransport = new ProcessTransport(transportOptions);
   await processTransport.connect();
@@ -3152,6 +3240,9 @@ function buildInitParams(options) {
     ...options.disabledToolIds !== void 0 && {
       disabledToolIds: options.disabledToolIds
     },
+    ...options.sessionSource !== void 0 && {
+      sessionSource: options.sessionSource
+    },
     tags: [...options.tags ?? [], SDK_TAG]
   };
 }
@@ -3352,19 +3443,6 @@ async function startSdkMcpServers(servers) {
 }
 
 // src/session.ts
-function getAbortError(signal) {
-  if (signal.reason instanceof Error) {
-    return signal.reason;
-  }
-  return new Error(
-    typeof signal.reason === "string" ? signal.reason : "Operation aborted"
-  );
-}
-function throwIfAborted(signal) {
-  if (signal?.aborted) {
-    throw getAbortError(signal);
-  }
-}
 var DroidSession = class {
   _client;
   _sessionId;
@@ -3395,54 +3473,13 @@ var DroidSession = class {
   }
   async *stream(prompt, options) {
     this._ensureNotClosed();
-    throwIfAborted(options?.abortSignal);
-    const startedAt = Date.now();
-    let resolveDone = () => {
-    };
-    const donePromise = new Promise((resolve2) => {
-      resolveDone = resolve2;
-    });
-    const bridge = new MessageBridge(resolveDone, {
-      includePartialMessages: options?.includePartialMessages,
-      sessionId: this._sessionId,
-      startedAt,
-      outputFormat: options?.outputFormat
-    });
-    this._activeBridges.add(bridge);
-    const unsubscribe = this._client.onNotification(bridge.notificationHandler);
-    let resolveAbort = () => {
-    };
-    const abortPromise = new Promise((resolve2) => {
-      resolveAbort = resolve2;
-    });
-    const cleanupAbortSignal = wireAbortSignal(options?.abortSignal, () => {
-      bridge.signalDone();
-      resolveAbort();
-      void this._client.interruptSession().catch(() => {
-      });
-    });
-    try {
-      await Promise.race([
-        this._client.addUserMessage({
-          text: prompt,
-          images: options?.images,
-          files: options?.files,
-          outputFormat: options?.outputFormat
-        }),
-        donePromise,
-        abortPromise
-      ]);
-      throwIfAborted(options?.abortSignal);
-      for await (const msg of bridge.messages()) {
-        throwIfAborted(options?.abortSignal);
-        yield msg;
-      }
-      throwIfAborted(options?.abortSignal);
-    } finally {
-      cleanupAbortSignal();
-      unsubscribe();
-      this._activeBridges.delete(bridge);
-    }
+    yield* streamFromClient(
+      this._client,
+      this._sessionId,
+      this._activeBridges,
+      prompt,
+      options
+    );
   }
   async interrupt() {
     this._ensureNotClosed();
@@ -3545,7 +3582,7 @@ var DroidSession = class {
     }
   }
 };
-async function createSession(options = {}) {
+async function createSession(options) {
   const { client } = await createConfiguredClient(options);
   let cleanupInitAbortSignal = options.abortSignal?.aborted ? () => {
   } : wireAbortSignal(options.abortSignal, () => {
@@ -3575,7 +3612,7 @@ async function createSession(options = {}) {
     throw error;
   }
 }
-async function resumeSession(sessionId, options = {}) {
+async function resumeSession(sessionId, options) {
   const { client } = await createConfiguredClient(options);
   let sdkMcpServers;
   try {
@@ -3599,7 +3636,7 @@ async function resumeSession(sessionId, options = {}) {
 }
 
 // src/run.ts
-async function run(prompt, options = {}) {
+async function run(prompt, options) {
   const session = await createSession(options);
   try {
     for await (const msg of session.stream(prompt, {
@@ -3839,6 +3876,1431 @@ async function listSessions(options = {}) {
   }
   return sorted;
 }
+
+// src/api-types.ts
+import { z as z10 } from "zod";
+var EnvironmentVariableSchema = z10.object({
+  key: z10.string(),
+  value: z10.string()
+});
+var MachineTemplateBuildStatusSchema = z10.object({
+  status: z10.enum(["building", "success", "failed"]),
+  failureReason: z10.enum(["setup_script_error", "system_error"]).optional(),
+  buildStartedAt: z10.number().int().optional(),
+  builtAt: z10.number().int().optional(),
+  logs: z10.string().optional()
+});
+var MachineTemplateSchema = z10.object({
+  templateId: z10.string(),
+  repoUrl: z10.string(),
+  templateName: z10.string(),
+  defaultBranch: z10.string(),
+  createdBy: z10.string(),
+  createdAt: z10.number().int().optional(),
+  buildStatus: MachineTemplateBuildStatusSchema.optional(),
+  lastUpdatedAt: z10.number().int().nullable().optional(),
+  environmentVariables: z10.array(EnvironmentVariableSchema).optional(),
+  userEnvironmentVariablesByUser: z10.array(EnvironmentVariableSchema).optional(),
+  setupScript: z10.string().optional()
+});
+var MachineTemplateListResponseSchema = z10.object({
+  templates: z10.array(MachineTemplateSchema),
+  pagination: z10.object({
+    hasMore: z10.boolean(),
+    nextCursor: z10.string().nullable()
+  })
+});
+var ComputerSchema = z10.object({
+  id: z10.string(),
+  name: z10.string(),
+  hostname: z10.string().optional(),
+  providerType: z10.enum(["byom", "e2b"]),
+  status: z10.enum(["provisioning", "active", "error"]).optional(),
+  createdAt: z10.number().int(),
+  relayClientUrl: z10.string().optional(),
+  remoteUser: z10.string().optional()
+}).passthrough();
+var ComputerListResponseSchema = z10.object({
+  computers: z10.array(ComputerSchema)
+});
+var RefreshComputerResponseSchema = z10.object({
+  configured: z10.number().int()
+});
+var ComputerMetricSchema = z10.object({
+  timestamp: z10.string(),
+  cpuUsedPct: z10.number(),
+  cpuCount: z10.number(),
+  memUsed: z10.number(),
+  memTotal: z10.number(),
+  diskUsed: z10.number(),
+  diskTotal: z10.number()
+});
+var ComputerMetricsResponseSchema = z10.array(ComputerMetricSchema);
+var RemoteSessionSchema = z10.object({
+  sessionId: z10.string(),
+  title: z10.string().optional(),
+  status: z10.enum(["idle", "pending", "running"]),
+  messageCount: z10.number().int(),
+  createdAt: z10.number().int(),
+  updatedAt: z10.number().int(),
+  completedAt: z10.number().int().optional(),
+  computerId: z10.string().optional()
+});
+var RemoteSessionListResponseSchema = z10.object({
+  sessions: z10.array(RemoteSessionSchema),
+  pagination: z10.object({
+    hasMore: z10.boolean(),
+    nextCursor: z10.string().nullable()
+  })
+});
+
+// src/api.ts
+var DEFAULT_BASE_URL = "https://api.factory.ai";
+function extractErrorMessage(body, status) {
+  if (isRecord(body) && typeof body["error"] === "string") {
+    return body["error"];
+  }
+  return `Factory API error (status ${status})`;
+}
+async function factoryFetch(path3, apiKey, baseUrl, options) {
+  const url = `${baseUrl ?? DEFAULT_BASE_URL}${path3}`;
+  const method = options?.method ?? "GET";
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    Accept: "application/json"
+  };
+  if (options?.body) {
+    headers["Content-Type"] = "application/json";
+  }
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      ...options?.body ? { body: JSON.stringify(options.body) } : {}
+    });
+  } catch (error) {
+    throw new ConnectionError(
+      `Failed to reach Factory API: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (response.status === 204) {
+    return void 0;
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    throw new ProtocolError(
+      `Factory API returned non-JSON response (status ${response.status})`
+    );
+  }
+  if (!response.ok) {
+    const message = extractErrorMessage(body, response.status);
+    if (response.status === 401 || response.status === 403) {
+      throw new ProtocolError(`Invalid or expired API key: ${message}`, {
+        code: response.status
+      });
+    }
+    throw new ProtocolError(message, { code: response.status });
+  }
+  return body;
+}
+function parseResponse(body, schema) {
+  const parsed = schema.safeParse(body);
+  if (!parsed.success) {
+    throw new ProtocolError(
+      `Unexpected response format from Factory API: ${parsed.error.message}`
+    );
+  }
+  return parsed.data;
+}
+async function listMachineTemplates(options) {
+  const params = new URLSearchParams();
+  if (options.limit != null) {
+    params.set("limit", String(options.limit));
+  }
+  if (options.cursor != null) {
+    params.set("cursor", options.cursor);
+  }
+  const query = params.toString();
+  const path3 = `/api/v0/machines/templates${query ? `?${query}` : ""}`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, MachineTemplateListResponseSchema);
+}
+async function getMachineTemplate(options) {
+  const path3 = `/api/v0/machines/templates/${encodeURIComponent(options.templateId)}`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, MachineTemplateSchema);
+}
+async function listComputers(options) {
+  const path3 = "/api/v0/computers";
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, ComputerListResponseSchema);
+}
+async function getComputer(options) {
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, ComputerSchema);
+}
+async function createComputer(options) {
+  const path3 = "/api/v0/computers";
+  const reqBody = {
+    name: options.name,
+    remoteUser: options.remoteUser
+  };
+  if (options.provider != null) reqBody["provider"] = options.provider;
+  if (options.hostId != null) reqBody["hostId"] = options.hostId;
+  if (options.repos != null) reqBody["repos"] = options.repos;
+  if (options.autoInstallDeps != null)
+    reqBody["autoInstallDeps"] = options.autoInstallDeps;
+  if (options.serviceAccountId != null)
+    reqBody["serviceAccountId"] = options.serviceAccountId;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl, {
+    method: "POST",
+    body: reqBody
+  });
+  return parseResponse(body, ComputerSchema);
+}
+async function getComputerByName(options) {
+  const path3 = `/api/v0/computers/name/${encodeURIComponent(options.name)}`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, ComputerSchema);
+}
+async function updateComputer(options) {
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}`;
+  const reqBody = {};
+  if (options.name != null) reqBody["name"] = options.name;
+  if (options.remoteUser != null) reqBody["remoteUser"] = options.remoteUser;
+  if (options.hostId != null) reqBody["hostId"] = options.hostId;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl, {
+    method: "PATCH",
+    body: reqBody
+  });
+  return parseResponse(body, ComputerSchema);
+}
+async function deleteComputer(options) {
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}`;
+  await factoryFetch(path3, options.apiKey, options.baseUrl, {
+    method: "DELETE"
+  });
+}
+async function restartComputer(options) {
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}/restart`;
+  await factoryFetch(path3, options.apiKey, options.baseUrl, {
+    method: "POST"
+  });
+}
+async function refreshComputer(options) {
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}/refresh`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl, {
+    method: "POST"
+  });
+  return parseResponse(body, RefreshComputerResponseSchema);
+}
+async function getComputerMetrics(options) {
+  const params = new URLSearchParams();
+  if (options.start != null) {
+    params.set("start", options.start);
+  }
+  const query = params.toString();
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}/metrics${query ? `?${query}` : ""}`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, ComputerMetricsResponseSchema);
+}
+async function retryInstallDeps(options) {
+  const path3 = `/api/v0/computers/${encodeURIComponent(options.computerId)}/install-deps`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl, {
+    method: "POST"
+  });
+  return parseResponse(body, ComputerSchema);
+}
+async function listRemoteSessions(options) {
+  const params = new URLSearchParams();
+  if (options.computerId != null) {
+    params.set("computerId", options.computerId);
+  }
+  if (options.limit != null) {
+    params.set("limit", String(options.limit));
+  }
+  if (options.cursor != null) {
+    params.set("cursor", options.cursor);
+  }
+  const query = params.toString();
+  const path3 = `/api/v0/sessions${query ? `?${query}` : ""}`;
+  const body = await factoryFetch(path3, options.apiKey, options.baseUrl);
+  return parseResponse(body, RemoteSessionListResponseSchema);
+}
+
+// src/daemon/client.ts
+var DAEMON_SERVER_REQUEST_METHODS = {
+  "daemon.request_permission": "permission" /* Permission */,
+  "daemon.ask_user": "askUser" /* AskUser */
+};
+var DaemonClient = class {
+  _engine;
+  _apiKey;
+  _sessionId = null;
+  _closed = false;
+  _notificationListeners = [];
+  _permissionHandler = null;
+  _askUserHandler = null;
+  constructor(options) {
+    this._apiKey = options.apiKey;
+    this._engine = new ProtocolEngine({
+      transport: options.transport,
+      serverRequestMethodMap: DAEMON_SERVER_REQUEST_METHODS
+    });
+    this._engine.onNotification((notification) => {
+      const normalized = notification["method"] === "daemon.session_notification" ? { ...notification, method: "droid.session_notification" } : notification;
+      dispatchNotification(normalized, [...this._notificationListeners]);
+    });
+    this._engine.setPermissionHandler(
+      (params) => this._dispatchPermissionRequest(params)
+    );
+    this._engine.setAskUserHandler(
+      (params) => this._dispatchAskUserRequest(params)
+    );
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  get isConnected() {
+    return !this._closed && this._engine.isHealthy;
+  }
+  async initializeSession(params) {
+    this._ensureNotClosed();
+    const result = await this._rpc(
+      "daemon.initialize_session" /* INITIALIZE_SESSION */,
+      { ...params, token: this._apiKey },
+      InitializeSessionResultSchema,
+      SESSION_INIT_TIMEOUT
+    );
+    this._sessionId = result.sessionId;
+    return result;
+  }
+  async loadSession(params) {
+    this._ensureNotClosed();
+    const result = await this._rpc(
+      "daemon.load_session" /* LOAD_SESSION */,
+      { ...params, token: this._apiKey },
+      LoadSessionResultSchema,
+      SESSION_INIT_TIMEOUT
+    );
+    this._sessionId = params.sessionId;
+    return result;
+  }
+  async addUserMessage(params) {
+    return this._sessionRpc(
+      "daemon.add_user_message" /* ADD_USER_MESSAGE */,
+      params,
+      AddUserMessageResultSchema
+    );
+  }
+  async interruptSession() {
+    return this._sessionRpc(
+      "daemon.interrupt_session" /* INTERRUPT_SESSION */,
+      {},
+      InterruptSessionResultSchema
+    );
+  }
+  async closeSession(params = {}) {
+    return this._sessionRpc(
+      "daemon.close_session" /* CLOSE_SESSION */,
+      params,
+      CloseSessionResultSchema
+    );
+  }
+  async updateSessionSettings(params) {
+    return this._sessionRpc(
+      "daemon.update_session_settings" /* UPDATE_SESSION_SETTINGS */,
+      params,
+      UpdateSessionSettingsResultSchema
+    );
+  }
+  async compactSession(params = {}) {
+    return this._sessionRpc(
+      "daemon.compact_session" /* COMPACT_SESSION */,
+      params,
+      CompactSessionResultSchema,
+      COMPACTION_TIMEOUT
+    );
+  }
+  async forkSession() {
+    return this._sessionRpc(
+      "daemon.fork_session" /* FORK_SESSION */,
+      {},
+      ForkSessionResultSchema
+    );
+  }
+  async getContextBreakdown() {
+    return this._sessionRpc(
+      "daemon.get_context_breakdown" /* GET_CONTEXT_STATS */,
+      {},
+      ContextBreakdownResultSchema
+    );
+  }
+  async renameSession(params) {
+    return this._sessionRpc(
+      "daemon.rename_session" /* RENAME_SESSION */,
+      params,
+      RenameSessionResultSchema
+    );
+  }
+  async getRewindInfo(params) {
+    return this._sessionRpc(
+      "daemon.get_rewind_info" /* GET_REWIND_INFO */,
+      params,
+      GetRewindInfoResultSchema,
+      REWIND_TIMEOUT
+    );
+  }
+  async executeRewind(params) {
+    return this._sessionRpc(
+      "daemon.execute_rewind" /* EXECUTE_REWIND */,
+      params,
+      ExecuteRewindResultSchema,
+      REWIND_TIMEOUT
+    );
+  }
+  async addMcpServer(params) {
+    return this._sessionRpc(
+      "daemon.add_mcp_server" /* ADD_MCP_SERVER */,
+      params,
+      AddMcpServerResultSchema
+    );
+  }
+  async removeMcpServer(params) {
+    return this._sessionRpc(
+      "daemon.remove_mcp_server" /* REMOVE_MCP_SERVER */,
+      params,
+      RemoveMcpServerResultSchema
+    );
+  }
+  async toggleMcpServer(params) {
+    return this._sessionRpc(
+      "daemon.toggle_mcp_server" /* TOGGLE_MCP_SERVER */,
+      params,
+      ToggleMcpServerResultSchema
+    );
+  }
+  async listMcpServers() {
+    return this._sessionRpc(
+      "daemon.list_mcp_servers" /* LIST_MCP_SERVERS */,
+      {},
+      ListMcpServersResultSchema
+    );
+  }
+  async listMcpTools() {
+    return this._sessionRpc(
+      "daemon.list_mcp_tools" /* LIST_MCP_TOOLS */,
+      {},
+      ListMcpToolsResultSchema
+    );
+  }
+  async authenticateMcpServer(params) {
+    return this._sessionRpc(
+      "daemon.authenticate_mcp_server" /* AUTHENTICATE_MCP_SERVER */,
+      params,
+      AuthenticateMcpServerResultSchema
+    );
+  }
+  async listSkills() {
+    return this._sessionRpc(
+      "daemon.list_skills" /* LIST_SKILLS */,
+      {},
+      ListSkillsResultSchema
+    );
+  }
+  onNotification(callback, filter) {
+    const entry = { callback, filter };
+    this._notificationListeners.push(entry);
+    let unsubscribed = false;
+    return () => {
+      if (!unsubscribed) {
+        unsubscribed = true;
+        const idx = this._notificationListeners.indexOf(entry);
+        if (idx !== -1) {
+          this._notificationListeners.splice(idx, 1);
+        }
+      }
+    };
+  }
+  setPermissionHandler(handler) {
+    this._permissionHandler = handler;
+  }
+  setAskUserHandler(handler) {
+    this._askUserHandler = handler;
+  }
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    this._notificationListeners.length = 0;
+    this._permissionHandler = null;
+    this._askUserHandler = null;
+    await this._engine.close();
+  }
+  async _rpc(method, params, schema, timeout) {
+    const raw = await this._engine.sendRequest(method, params, timeout);
+    return schema.parse(raw);
+  }
+  async _sessionRpc(method, params, schema, timeout) {
+    this._ensureNotClosed();
+    this._ensureSession();
+    return this._rpc(
+      method,
+      { sessionId: this._sessionId, ...params },
+      schema,
+      timeout
+    );
+  }
+  _dispatchPermissionRequest(params) {
+    const handler = this._permissionHandler;
+    if (handler == null) {
+      return "cancel" /* Cancel */;
+    }
+    return handler(params);
+  }
+  _dispatchAskUserRequest(params) {
+    const handler = this._askUserHandler;
+    if (handler == null) {
+      return { cancelled: true, answers: [] };
+    }
+    return handler(params);
+  }
+  _ensureNotClosed() {
+    if (this._closed) {
+      throw new ConnectionError(
+        "Daemon client has been closed. Create a new DaemonClient instance."
+      );
+    }
+  }
+  _ensureSession() {
+    if (this._sessionId == null) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+  }
+};
+
+// src/daemon/local.ts
+import { spawn as spawn2 } from "child_process";
+import * as fs2 from "fs";
+import * as net from "net";
+import * as os2 from "os";
+import * as path2 from "path";
+var SOCKET_TIMEOUT_MS = 2e3;
+var STARTUP_POLL_INTERVAL_MS = 250;
+var STARTUP_TIMEOUT_MS = 3e4;
+var MAX_STARTUP_ATTEMPTS = 3;
+var FACTORY_DIR = ".factory";
+var DEFAULT_PORT = 37643;
+var DAEMON_PORT_FILE = "daemon.port";
+var DEFAULT_HOST = "127.0.0.1";
+var spawnedDaemonProcess = null;
+var daemonTarget = null;
+var daemonEnsureInflight = null;
+function getFactoryHome() {
+  return process.env.FACTORY_HOME_OVERRIDE || os2.homedir();
+}
+function getFactoryDirName() {
+  return FACTORY_DIR;
+}
+function getFactoryDir() {
+  return path2.join(getFactoryHome(), getFactoryDirName());
+}
+function getSdkDir() {
+  return path2.join(getFactoryDir(), "sdk");
+}
+function getDefaultDaemonPort() {
+  return DEFAULT_PORT;
+}
+function resolveExecPath() {
+  const override = process.env.FACTORY_DROID_BINARY?.trim();
+  if (override && override.length > 0) {
+    if (override.includes("/") || override.includes("\\")) {
+      try {
+        fs2.accessSync(override, fs2.constants.X_OK);
+        return override;
+      } catch {
+      }
+    } else {
+      return override;
+    }
+  }
+  return "droid";
+}
+async function allocatePort() {
+  return new Promise((resolve2, reject) => {
+    const server = net.createServer();
+    server.once("error", reject);
+    server.listen(0, DEFAULT_HOST, () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close();
+        reject(new Error("Failed to determine dynamic port"));
+        return;
+      }
+      const port = address.port;
+      server.close((err) => {
+        if (err) reject(err);
+        else resolve2(port);
+      });
+    });
+  });
+}
+async function isDaemonReachable(port) {
+  return new Promise((resolve2) => {
+    const socket = net.createConnection({ host: DEFAULT_HOST, port });
+    const cleanup = () => {
+      socket.removeAllListeners();
+      socket.destroy();
+    };
+    const fail = () => {
+      cleanup();
+      resolve2(false);
+    };
+    socket.setTimeout(SOCKET_TIMEOUT_MS, fail);
+    socket.once("error", fail);
+    socket.once("connect", () => {
+      cleanup();
+      resolve2(true);
+    });
+  });
+}
+async function waitForDaemonReady(child, port, timeoutMs = STARTUP_TIMEOUT_MS) {
+  return new Promise((resolve2) => {
+    let settled = false;
+    let exited = false;
+    const deadline = Date.now() + timeoutMs;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      child.removeListener("exit", onExit);
+      child.removeListener("error", onExit);
+      resolve2(result);
+    };
+    const onExit = () => {
+      exited = true;
+      settle("exited");
+    };
+    child.once("exit", onExit);
+    child.once("error", onExit);
+    const poll = async () => {
+      while (!exited && !settled) {
+        if (await isDaemonReachable(port)) {
+          settle("ready");
+          return;
+        }
+        if (Date.now() >= deadline) {
+          settle("timeout");
+          return;
+        }
+        await new Promise((r) => setTimeout(r, STARTUP_POLL_INTERVAL_MS));
+      }
+    };
+    void poll();
+  });
+}
+function readPortFile() {
+  try {
+    const portPath = path2.join(getSdkDir(), DAEMON_PORT_FILE);
+    const content = fs2.readFileSync(portPath, "utf-8").trim();
+    const port = parseInt(content, 10);
+    if (Number.isFinite(port) && port > 0 && port < 65536) {
+      return port;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writePortFile(port) {
+  try {
+    const sdkDir = getSdkDir();
+    fs2.mkdirSync(sdkDir, { recursive: true });
+    fs2.writeFileSync(path2.join(sdkDir, DAEMON_PORT_FILE), String(port), {
+      mode: 384
+    });
+  } catch {
+  }
+}
+function cacheTarget(port) {
+  daemonTarget = { host: DEFAULT_HOST, port };
+  return { port };
+}
+function clearSpawnedDaemonProcess(child) {
+  if (spawnedDaemonProcess === child) {
+    spawnedDaemonProcess = null;
+  }
+}
+async function spawnDaemon(execPath, port) {
+  const args = ["daemon", "--host", DEFAULT_HOST, "--port", String(port)];
+  let stderrFd;
+  try {
+    const logsDir = path2.join(getSdkDir(), "logs");
+    fs2.mkdirSync(logsDir, { recursive: true });
+    stderrFd = fs2.openSync(path2.join(logsDir, "daemon-stderr.log"), "a");
+  } catch {
+  }
+  const child = spawn2(execPath, args, {
+    detached: true,
+    stdio: ["ignore", "ignore", stderrFd ?? "ignore"],
+    cwd: os2.homedir(),
+    env: { ...process.env }
+  });
+  if (stderrFd !== void 0) {
+    try {
+      fs2.closeSync(stderrFd);
+    } catch {
+    }
+  }
+  spawnedDaemonProcess = child;
+  child.unref();
+  child.once("exit", () => {
+    clearSpawnedDaemonProcess(child);
+  });
+  child.on("error", () => {
+    clearSpawnedDaemonProcess(child);
+  });
+  const result = await waitForDaemonReady(child, port);
+  if (result !== "ready") {
+    clearSpawnedDaemonProcess(child);
+    if (result === "timeout") {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+async function _ensureLocalDaemon() {
+  const execPath = resolveExecPath();
+  const wellKnownPort = getDefaultDaemonPort();
+  if (await isDaemonReachable(wellKnownPort)) {
+    return cacheTarget(wellKnownPort);
+  }
+  const portFilePort = readPortFile();
+  if (portFilePort !== null && portFilePort !== wellKnownPort) {
+    if (await isDaemonReachable(portFilePort)) {
+      return cacheTarget(portFilePort);
+    }
+  }
+  const firstResult = await spawnDaemon(execPath, wellKnownPort);
+  if (firstResult === "ready") {
+    writePortFile(wellKnownPort);
+    return cacheTarget(wellKnownPort);
+  }
+  for (let attempt = 2; attempt <= MAX_STARTUP_ATTEMPTS; attempt++) {
+    const port = await allocatePort();
+    const result = await spawnDaemon(execPath, port);
+    if (result === "ready") {
+      writePortFile(port);
+      return cacheTarget(port);
+    }
+  }
+  throw new ConnectionError(
+    `Failed to start local droid daemon after ${MAX_STARTUP_ATTEMPTS} attempts. Ensure the \`droid\` CLI is installed and \`droid auth login\` has been run.`
+  );
+}
+async function ensureLocalDaemon() {
+  if (daemonTarget) {
+    if (await isDaemonReachable(daemonTarget.port)) {
+      return { port: daemonTarget.port };
+    }
+    daemonTarget = null;
+  }
+  if (!daemonEnsureInflight) {
+    daemonEnsureInflight = _ensureLocalDaemon().finally(() => {
+      daemonEnsureInflight = null;
+    });
+  }
+  return daemonEnsureInflight;
+}
+
+// src/daemon/session.ts
+var DaemonSession = class {
+  _client;
+  _sessionId;
+  _closed = false;
+  _activeBridges = /* @__PURE__ */ new Set();
+  _cleanupCallbacks = [];
+  /** @internal */
+  constructor(client, sessionId) {
+    this._client = client;
+    this._sessionId = sessionId;
+  }
+  /** @internal */
+  addCleanup(cleanup) {
+    this._cleanupCallbacks.push(cleanup);
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  async *stream(prompt, options) {
+    this._ensureNotClosed();
+    yield* streamFromClient(
+      this._client,
+      this._sessionId,
+      this._activeBridges,
+      prompt,
+      options
+    );
+  }
+  async send(prompt, options) {
+    this._ensureNotClosed();
+    await this._client.addUserMessage({
+      text: prompt,
+      images: options?.images,
+      files: options?.files,
+      outputFormat: options?.outputFormat
+    });
+  }
+  async interrupt() {
+    this._ensureNotClosed();
+    await this._client.interruptSession();
+  }
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    for (const bridge of this._activeBridges) {
+      bridge.signalDone();
+    }
+    try {
+      await this._client.closeSession({ reason: "other" }).catch(() => {
+      });
+    } finally {
+      await this._client.close();
+      for (const cleanup of this._cleanupCallbacks) {
+        try {
+          await cleanup();
+        } catch {
+        }
+      }
+      this._cleanupCallbacks.length = 0;
+    }
+  }
+  async updateSettings(params) {
+    this._ensureNotClosed();
+    return this._client.updateSessionSettings(params);
+  }
+  async enterSpecMode(params = {}) {
+    this._ensureNotClosed();
+    return this._client.updateSessionSettings({
+      interactionMode: "spec" /* Spec */,
+      ...params
+    });
+  }
+  async compactSession(params) {
+    this._ensureNotClosed();
+    return this._client.compactSession(params ?? {});
+  }
+  async forkSession() {
+    this._ensureNotClosed();
+    return this._client.forkSession();
+  }
+  async getContextBreakdown() {
+    this._ensureNotClosed();
+    return this._client.getContextBreakdown();
+  }
+  async renameSession(params) {
+    this._ensureNotClosed();
+    return this._client.renameSession(params);
+  }
+  async getRewindInfo(params) {
+    this._ensureNotClosed();
+    return this._client.getRewindInfo(params);
+  }
+  async executeRewind(params) {
+    this._ensureNotClosed();
+    return this._client.executeRewind(params);
+  }
+  async addMcpServer(params) {
+    this._ensureNotClosed();
+    return this._client.addMcpServer(params);
+  }
+  async removeMcpServer(params) {
+    this._ensureNotClosed();
+    return this._client.removeMcpServer(params);
+  }
+  async toggleMcpServer(params) {
+    this._ensureNotClosed();
+    return this._client.toggleMcpServer(params);
+  }
+  async listMcpServers() {
+    this._ensureNotClosed();
+    return this._client.listMcpServers();
+  }
+  async listMcpTools() {
+    this._ensureNotClosed();
+    return this._client.listMcpTools();
+  }
+  async authenticateMcpServer(params) {
+    this._ensureNotClosed();
+    return this._client.authenticateMcpServer(params);
+  }
+  async listSkills() {
+    this._ensureNotClosed();
+    return this._client.listSkills();
+  }
+  onNotification(callback, filter) {
+    return this._client.onNotification(callback, filter);
+  }
+  _ensureNotClosed() {
+    if (this._closed) {
+      throw new ConnectionError(
+        "Daemon session has been closed. Create a new session to continue."
+      );
+    }
+  }
+};
+
+// src/daemon/transport.ts
+import WebSocket from "ws";
+
+// src/daemon/types.ts
+var MachineType = /* @__PURE__ */ ((MachineType2) => {
+  MachineType2["Local"] = "local";
+  MachineType2["Computer"] = "computer";
+  return MachineType2;
+})(MachineType || {});
+var DEFAULT_DAEMON_PORT = 37643;
+var DEFAULT_RELAY_BASE_URL = "wss://relay.factory.ai";
+var DEFAULT_WS_CONFIG = {
+  maxConnectRetries: 5,
+  initialRetryDelayMs: 500,
+  maxRetryDelayMs: 5e3,
+  connectionTimeoutMs: 5e3
+};
+var COMPUTER_WS_CONFIG = {
+  connectionTimeoutMs: 45e3,
+  maxConnectRetries: 10,
+  initialRetryDelayMs: 2e3,
+  maxRetryDelayMs: 1e4
+};
+
+// src/daemon/transport.ts
+var WebSocketTransport = class {
+  maxConnectRetries;
+  initialRetryDelayMs;
+  maxRetryDelayMs;
+  connectionTimeoutMs;
+  ws = null;
+  messageHandler = null;
+  errorHandler = null;
+  _isConnected = false;
+  isClosing = false;
+  constructor(options = {}) {
+    this.maxConnectRetries = options.maxConnectRetries ?? DEFAULT_WS_CONFIG.maxConnectRetries;
+    this.initialRetryDelayMs = options.initialRetryDelayMs ?? DEFAULT_WS_CONFIG.initialRetryDelayMs;
+    this.maxRetryDelayMs = options.maxRetryDelayMs ?? DEFAULT_WS_CONFIG.maxRetryDelayMs;
+    this.connectionTimeoutMs = options.connectionTimeoutMs ?? DEFAULT_WS_CONFIG.connectionTimeoutMs;
+  }
+  get isConnected() {
+    return this._isConnected;
+  }
+  async connect(url) {
+    if (!url) {
+      throw new ConnectionError("WebSocket URL is required");
+    }
+    if (this._isConnected) {
+      throw new ConnectionError("Transport already connected");
+    }
+    this.isClosing = false;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxConnectRetries; attempt++) {
+      try {
+        await this._doConnect(url);
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < this.maxConnectRetries) {
+          const delay = Math.min(
+            this.initialRetryDelayMs * 2 ** attempt,
+            this.maxRetryDelayMs
+          );
+          await new Promise((resolve2) => setTimeout(resolve2, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
+  send(message) {
+    if (!this._isConnected || !this.ws) {
+      throw new ConnectionError("WebSocket transport not connected");
+    }
+    try {
+      this.ws.send(JSON.stringify(message));
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      throw new ConnectionError(`Failed to send WebSocket message: ${msg}`);
+    }
+  }
+  onMessage(callback) {
+    this.messageHandler = callback;
+  }
+  onError(callback) {
+    this.errorHandler = callback;
+  }
+  async close() {
+    if (this.isClosing) {
+      return;
+    }
+    this.isClosing = true;
+    this._isConnected = false;
+    const ws = this.ws;
+    this.ws = null;
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      await new Promise((resolve2) => {
+        ws.once("close", () => resolve2());
+        ws.close(1e3, "Client disconnect");
+        setTimeout(() => resolve2(), 5e3);
+      });
+    }
+    this.isClosing = false;
+  }
+  async _doConnect(url) {
+    return new Promise((resolve2, reject) => {
+      let settled = false;
+      let timeoutId = null;
+      const cleanup = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+      };
+      const ws = new WebSocket(url);
+      const handleOpen = () => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        this.ws = ws;
+        this._isConnected = true;
+        this._setupOngoingHandlers(ws);
+        resolve2();
+      };
+      const handleError = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        try {
+          ws.close();
+        } catch {
+        }
+        reject(
+          new ConnectionError(`WebSocket connection failed: ${error.message}`)
+        );
+      };
+      const handleClose = (code, reason) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(
+          new ConnectionError(
+            `WebSocket closed before opening (code: ${code}, reason: ${reason.toString()})`
+          )
+        );
+      };
+      ws.once("open", handleOpen);
+      ws.once("error", handleError);
+      ws.once("close", handleClose);
+      timeoutId = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        try {
+          ws.close();
+        } catch {
+        }
+        reject(
+          new ConnectionError(
+            `WebSocket connection timeout after ${this.connectionTimeoutMs}ms: ${url}`
+          )
+        );
+      }, this.connectionTimeoutMs);
+    });
+  }
+  _setupOngoingHandlers(ws) {
+    ws.on("message", (data) => {
+      if (!this.messageHandler) return;
+      const text = typeof data === "string" ? data : data.toString();
+      try {
+        const parsed = JSON.parse(text);
+        if (isRecord(parsed)) {
+          this.messageHandler(parsed);
+        }
+      } catch {
+      }
+    });
+    ws.on("error", (error) => {
+      if (!this.isClosing && this.errorHandler) {
+        this.errorHandler(
+          new ConnectionError(`WebSocket error: ${error.message}`)
+        );
+      }
+    });
+    ws.on("close", (code, reason) => {
+      this._isConnected = false;
+      this.ws = null;
+      if (!this.isClosing && this.errorHandler) {
+        this.errorHandler(
+          new ConnectionError(
+            `WebSocket closed (code: ${code}, reason: ${reason.toString()})`
+          )
+        );
+      }
+    });
+  }
+};
+
+// src/daemon/connection.ts
+var DAEMON_AUTHENTICATE_METHOD = "daemon.authenticate";
+var DAEMON_AUTHENTICATE_TIMEOUT = 3e4;
+var SDK_CALLER = "droid-sdk";
+function resolveWebSocketUrl(options) {
+  if (options.url) {
+    return options.url;
+  }
+  const machine = options.machine;
+  if (!machine || machine.type === "local" /* Local */) {
+    const port = options._localPort ?? options.daemonPort ?? DEFAULT_DAEMON_PORT;
+    return `ws://127.0.0.1:${port}`;
+  }
+  if (machine.type === "computer" /* Computer */) {
+    const relayBase = options.relayBaseUrl ?? DEFAULT_RELAY_BASE_URL;
+    return `${relayBase}/v0/computer/${machine.computerId}/client`;
+  }
+  const _exhaustive = machine;
+  throw new ConnectionError(`Unsupported machine type: ${String(_exhaustive)}`);
+}
+function getWebSocketConfig(machine) {
+  if (machine?.type === "computer" /* Computer */) {
+    return { ...DEFAULT_WS_CONFIG, ...COMPUTER_WS_CONFIG };
+  }
+  if (!machine || machine.type === "local" /* Local */) {
+    return { ...DEFAULT_WS_CONFIG, connectionTimeoutMs: 1e4 };
+  }
+  return { ...DEFAULT_WS_CONFIG };
+}
+var SharedTransportMultiplexer = class {
+  constructor(_inner) {
+    this._inner = _inner;
+    this._inner.onMessage((message) => {
+      this._routeMessage(message);
+    });
+    this._inner.onError((error) => {
+      for (const view of this._views) {
+        if (view.errorCallback) {
+          try {
+            view.errorCallback(error);
+          } catch {
+          }
+        }
+      }
+    });
+  }
+  _views = /* @__PURE__ */ new Set();
+  createView() {
+    const inner = this._inner;
+    const viewState = {
+      messageCallback: null,
+      errorCallback: null,
+      pendingRequestIds: /* @__PURE__ */ new Set(),
+      sessionId: null
+    };
+    this._views.add(viewState);
+    const view = {
+      send: (message) => {
+        if (message["type"] === "request" && typeof message["id"] === "string") {
+          viewState.pendingRequestIds.add(message["id"]);
+        }
+        inner.send(message);
+      },
+      onMessage: (callback) => {
+        viewState.messageCallback = callback;
+      },
+      onError: (callback) => {
+        viewState.errorCallback = callback;
+      },
+      close: async () => {
+        viewState.messageCallback = null;
+        viewState.errorCallback = null;
+        viewState.pendingRequestIds.clear();
+        this._views.delete(viewState);
+      },
+      get isConnected() {
+        return inner.isConnected;
+      }
+    };
+    return view;
+  }
+  _routeMessage(message) {
+    const messageType = message["type"];
+    const messageId = message["id"];
+    if (messageType === "response" && typeof messageId === "string") {
+      for (const view of this._views) {
+        if (view.pendingRequestIds.has(messageId)) {
+          view.pendingRequestIds.delete(messageId);
+          const result = message["result"];
+          if (isRecord(result) && typeof result["sessionId"] === "string") {
+            view.sessionId = result["sessionId"];
+          }
+          if (view.messageCallback) {
+            try {
+              view.messageCallback(message);
+            } catch {
+            }
+          }
+          return;
+        }
+      }
+      return;
+    }
+    if (messageType === "notification") {
+      const params = message["params"];
+      const sessionId = isRecord(params) && typeof params["sessionId"] === "string" ? params["sessionId"] : null;
+      if (sessionId) {
+        for (const view of this._views) {
+          if (view.sessionId === sessionId && view.messageCallback) {
+            try {
+              view.messageCallback(message);
+            } catch {
+            }
+            return;
+          }
+        }
+      }
+      for (const view of this._views) {
+        if (view.messageCallback) {
+          try {
+            view.messageCallback(message);
+          } catch {
+          }
+        }
+      }
+      return;
+    }
+    if (messageType === "request") {
+      const params = message["params"];
+      const sessionId = isRecord(params) && typeof params["sessionId"] === "string" ? params["sessionId"] : null;
+      if (sessionId) {
+        for (const view of this._views) {
+          if (view.sessionId === sessionId && view.messageCallback) {
+            try {
+              view.messageCallback(message);
+            } catch {
+            }
+            return;
+          }
+        }
+      }
+      for (const view of this._views) {
+        if (view.messageCallback) {
+          try {
+            view.messageCallback(message);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+};
+async function authenticate(transport, options) {
+  const requestId = crypto.randomUUID();
+  const envelope = {
+    jsonrpc: JSONRPC_VERSION,
+    factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+    factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+    type: "request" /* Request */,
+    id: requestId,
+    method: DAEMON_AUTHENTICATE_METHOD,
+    params: {
+      apiKey: options.apiKey,
+      caller: SDK_CALLER
+    }
+  };
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      transport.onMessage(() => {
+      });
+      reject(
+        new ConnectionError(
+          `Daemon authentication timed out after ${DAEMON_AUTHENTICATE_TIMEOUT}ms`
+        )
+      );
+    }, DAEMON_AUTHENTICATE_TIMEOUT);
+    transport.onMessage((message) => {
+      if (message["id"] !== requestId) {
+        return;
+      }
+      clearTimeout(timer);
+      transport.onMessage(() => {
+      });
+      if (message["error"]) {
+        const error = message["error"];
+        const errorMessage = error && typeof error === "object" && "message" in error ? String(error.message) : "unknown error";
+        reject(
+          new ConnectionError(`Daemon authentication failed: ${errorMessage}`)
+        );
+        return;
+      }
+      resolve2();
+    });
+    transport.send(envelope);
+  });
+}
+var DaemonConnection = class {
+  _transport;
+  _multiplexer;
+  _apiKey;
+  _closed = false;
+  /** @internal */
+  constructor(transport, apiKey) {
+    this._transport = transport;
+    this._multiplexer = new SharedTransportMultiplexer(transport);
+    this._apiKey = apiKey;
+  }
+  async createSession(options = {}) {
+    this._ensureNotClosed();
+    const view = this._multiplexer.createView();
+    const client = new DaemonClient({
+      transport: view,
+      apiKey: this._apiKey
+    });
+    if (options.permissionHandler) {
+      client.setPermissionHandler(options.permissionHandler);
+    }
+    if (options.askUserHandler) {
+      client.setAskUserHandler(options.askUserHandler);
+    }
+    let sdkMcpServers;
+    try {
+      sdkMcpServers = await startSdkMcpServers(options.mcpServers);
+      const initParams = buildInitParams({
+        ...options,
+        mcpServers: sdkMcpServers.mcpServers
+      });
+      const initResult = await client.initializeSession(initParams);
+      const session = new DaemonSession(client, initResult.sessionId);
+      if (sdkMcpServers) {
+        session.addCleanup(sdkMcpServers.cleanup);
+      }
+      return session;
+    } catch (error) {
+      await sdkMcpServers?.cleanup();
+      await client.close();
+      throw error;
+    }
+  }
+  async resumeSession(sessionId, options = {}) {
+    this._ensureNotClosed();
+    const view = this._multiplexer.createView();
+    const client = new DaemonClient({
+      transport: view,
+      apiKey: this._apiKey
+    });
+    if (options.permissionHandler) {
+      client.setPermissionHandler(options.permissionHandler);
+    }
+    if (options.askUserHandler) {
+      client.setAskUserHandler(options.askUserHandler);
+    }
+    let sdkMcpServers;
+    try {
+      sdkMcpServers = await startSdkMcpServers(options.mcpServers);
+      await client.loadSession({
+        sessionId,
+        mcpServers: sdkMcpServers.mcpServers
+      });
+      const session = new DaemonSession(client, sessionId);
+      if (sdkMcpServers) {
+        session.addCleanup(sdkMcpServers.cleanup);
+      }
+      return session;
+    } catch (error) {
+      await sdkMcpServers?.cleanup();
+      await client.close();
+      throw error;
+    }
+  }
+  async interruptSession(sessionId) {
+    this._ensureNotClosed();
+    const view = this._multiplexer.createView();
+    const client = new DaemonClient({
+      transport: view,
+      apiKey: this._apiKey
+    });
+    try {
+      await client.loadSession({ sessionId });
+      await client.interruptSession();
+    } finally {
+      await client.close();
+    }
+  }
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    await this._transport.close();
+  }
+  _ensureNotClosed() {
+    if (this._closed) {
+      throw new ConnectionError(
+        "Daemon connection has been closed. Call connectDaemon() to create a new connection."
+      );
+    }
+  }
+};
+async function connectDaemon(options) {
+  const isLocal = !options.url && (!options.machine || options.machine.type === "local" /* Local */);
+  let resolvedOptions = options;
+  if (isLocal) {
+    const { port } = await ensureLocalDaemon();
+    resolvedOptions = { ...options, _localPort: port };
+  }
+  const url = resolveWebSocketUrl(resolvedOptions);
+  const wsConfig = getWebSocketConfig(resolvedOptions.machine);
+  const transport = new WebSocketTransport(wsConfig);
+  const apiKey = resolvedOptions.apiKey;
+  const maxRetries = resolvedOptions.maxRetries ?? 0;
+  try {
+    if (maxRetries > 0) {
+      let lastError;
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+          await transport.connect(url);
+          await authenticate(transport, resolvedOptions);
+          return new DaemonConnection(transport, apiKey);
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          try {
+            await transport.close();
+          } catch {
+          }
+          if (attempt < maxRetries) {
+            await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+          }
+        }
+      }
+      throw lastError;
+    }
+    await transport.connect(url);
+    await authenticate(transport, resolvedOptions);
+    return new DaemonConnection(transport, apiKey);
+  } catch (error) {
+    try {
+      await transport.close();
+    } catch {
+    }
+    throw error;
+  }
+}
 export {
   AddMcpServerRequestParamsSchema,
   AddMcpServerRequestSchema,
@@ -3889,13 +5351,22 @@ export {
   CompactSessionRequestSchema,
   CompactSessionResponseSchema,
   CompactSessionResultSchema,
+  ComputerListResponseSchema,
+  ComputerMetricSchema,
+  ComputerMetricsResponseSchema,
+  ComputerSchema,
   ConnectionError,
   ContentBlockSchema,
+  ContextBreakdownCategorySchema,
+  ContextBreakdownResultSchema,
   ContextStatsAccuracy,
   ContextStatsSchema,
   CreateMessageNotificationSchema,
   CreateToolConfirmationDetailsSchema,
   DEFAULT_REQUEST_TIMEOUT,
+  DaemonClient,
+  DaemonConnection,
+  DaemonSession,
   DecompSessionType,
   DiscoveredIssueSchema,
   DismissalRecordSchema,
@@ -4010,6 +5481,10 @@ export {
   LoadSessionResponseSchema,
   LoadSessionResultSchema,
   MCP_AUTH_TIMEOUT,
+  MachineTemplateBuildStatusSchema,
+  MachineTemplateListResponseSchema,
+  MachineTemplateSchema,
+  MachineType,
   McpAuthCompletedNotificationSchema,
   McpAuthOutcome,
   McpAuthRequiredNotificationSchema,
@@ -4055,6 +5530,9 @@ export {
   REWIND_TIMEOUT,
   ReasoningEffort,
   RedactedThinkingBlockSchema,
+  RefreshComputerResponseSchema,
+  RemoteSessionListResponseSchema,
+  RemoteSessionSchema,
   RemoveMcpServerRequestParamsSchema,
   RemoveMcpServerRequestSchema,
   RemoveMcpServerResponseSchema,
@@ -4074,6 +5552,7 @@ export {
   SDK_VERSION,
   SESSION_INIT_TIMEOUT,
   SdkMcpServer,
+  ServerRequestHandlerType,
   SessionError,
   SessionMetadataSchema,
   SessionNotFoundError,
@@ -4149,20 +5628,37 @@ export {
   UpdateSessionSettingsResultSchema,
   VerificationCommandSchema,
   VerificationSchema,
+  WebSocketTransport,
   WorkerCompletedEntrySchema,
   WorkerFailedEntrySchema,
   WorkerPausedEntrySchema,
   WorkerSelectedFeatureEntrySchema,
   WorkerStartedEntrySchema,
   WorkerStateInfoSchema,
+  connectDaemon,
   convertNotificationToStreamMessage,
+  createComputer,
   createResponseSchema,
   createSdkMcpServer,
   createSession,
+  deleteComputer,
   dispatchNotification,
+  ensureLocalDaemon,
+  getComputer,
+  getComputerByName,
+  getComputerMetrics,
+  getMachineTemplate,
+  listComputers,
+  listMachineTemplates,
+  listRemoteSessions,
   listSessions,
+  refreshComputer,
+  resolveWebSocketUrl,
+  restartComputer,
   resumeSession,
+  retryInstallDeps,
   run,
-  tool
+  tool,
+  updateComputer
 };
 //# sourceMappingURL=index.js.map