nolo-cli 0.1.30 → 0.1.31

package/server/handlers/chatUpstreamRetry.ts

@@ -1,9 +1,24 @@
 type RetryLogger = {
   warn?: (...args: any[]) => void;
+  error?: (...args: any[]) => void;
 };
 
 import type { OpenAIServiceTier } from "../../integrations/openai/flexTier";
 import { isFireworksKimiModel } from "../../ai/llm/kimi";
+import {
+  createProviderCallCompletedEvent,
+} from "../../ai/token/providerCall";
+import {
+  writeProviderCallEvent,
+  type ProviderCallStore,
+} from "../../ai/token/providerCallWriter";
+import { dispatchProviderRequest } from "../../ai/token/providerGateway";
+import type { ProviderCredentialIdentity } from "../../ai/token/providerCredential";
+import { writeBillingAnomaly } from "../../ai/token/billingAnomalyWriter";
+import {
+  writeRevokedProviderCredentialUsedAnomalyIfNeeded,
+} from "../../ai/token/providerCredentialAnomaly";
+import { ulid } from "ulid";
 
 const FIREWORKS_GENTLE_RETRY_DELAY_MS = 1200;
 const FIREWORKS_GENTLE_RETRY_STATUSES = new Set([429, 503]);
@@ -14,8 +29,168 @@ type UpstreamRequest = {
   provider?: string;
   model?: string;
   serviceTier?: OpenAIServiceTier;
+  credential?: ProviderCredentialIdentity;
 };
 
+type ProviderCallContext = {
+  userId: string;
+  dialogId?: string;
+  agentId?: string;
+  endpoint?: string;
+  credential?: ProviderCredentialIdentity;
+};
+
+const isoNow = () => new Date().toISOString();
+type ProviderCallWriter = typeof writeProviderCallEvent;
+type BillingAnomalyWriter = typeof writeBillingAnomaly;
+type ProviderDispatchIntentWriter =
+  NonNullable<Parameters<typeof dispatchProviderRequest>[0]["writers"]>["providerDispatchIntentWriter"];
+
+async function writeProviderCallEvidence({
+  store,
+  event,
+  providerCallWriter,
+}: {
+  store: ProviderCallStore;
+  event: Parameters<typeof writeProviderCallEvent>[0]["event"];
+  providerCallWriter?: ProviderCallWriter;
+}) {
+  const writer = providerCallWriter ?? writeProviderCallEvent;
+  if (typeof writer === "function") {
+    return writer({ store, event });
+  }
+  const key = `provider-call-${event.providerCallId}-event-${event.eventId}`;
+  await store.put(key, event);
+  return { key };
+}
+
+async function writeTerminalProviderCallEventSafely({
+  store,
+  event,
+  log,
+  providerCallWriter = writeProviderCallEvent,
+  billingAnomalyWriter = writeBillingAnomaly,
+}: {
+  store: ProviderCallStore;
+  event: Parameters<typeof writeProviderCallEvent>[0]["event"];
+  log?: RetryLogger;
+  providerCallWriter?: ProviderCallWriter;
+  billingAnomalyWriter?: BillingAnomalyWriter;
+}) {
+  try {
+    await writeProviderCallEvidence({ store, event, providerCallWriter });
+  } catch (error) {
+    log?.error?.("provider-call terminal event write failed", {
+      err: error,
+      providerCallId: event.providerCallId,
+      status: event.status,
+    });
+    return;
+  }
+  await writeRevokedProviderCredentialUsedAnomalyIfNeeded({
+    store,
+    event,
+    onError: (error) =>
+      log?.error?.("provider-call revoked credential anomaly write failed", {
+        err: error,
+        providerCallId: event.providerCallId,
+      }),
+    billingAnomalyWriter,
+  });
+}
+
+async function fetchWithProviderCallEvidence({
+  url,
+  init,
+  provider,
+  model,
+  serviceTier,
+  fetchImpl,
+  providerCallStore,
+  providerCallContext,
+  log,
+  providerCallWriter,
+  providerDispatchIntentWriter,
+  billingAnomalyWriter,
+  credential,
+}: {
+  url: string;
+  init: RequestInit;
+  provider?: string;
+  model?: string;
+  serviceTier?: OpenAIServiceTier;
+  fetchImpl: typeof fetch;
+  providerCallStore?: ProviderCallStore;
+  providerCallContext?: ProviderCallContext;
+  log?: RetryLogger;
+  providerCallWriter?: ProviderCallWriter;
+  providerDispatchIntentWriter?: ProviderDispatchIntentWriter;
+  billingAnomalyWriter?: BillingAnomalyWriter;
+  credential?: ProviderCredentialIdentity;
+}): Promise<{ response: Response; providerCallId?: string }> {
+  if (!providerCallStore || !providerCallContext) {
+    return { response: await fetchImpl(url, init) };
+  }
+
+  const providerCallId = `call_${ulid()}`;
+  const startedAt = isoNow();
+
+  const { response } = await dispatchProviderRequest({
+    store: providerCallStore,
+    fetchImpl,
+    now: () => new Date(startedAt),
+    ids: {
+      providerCallId: () => providerCallId,
+      pendingEventId: () => `evt_${ulid()}`,
+      dispatchIntentId: () => `intent_${ulid()}`,
+      failedEventId: () => `evt_${ulid()}`,
+    },
+    writers: {
+      providerCallWriter,
+      providerDispatchIntentWriter,
+      billingAnomalyWriter,
+    },
+    call: {
+      userId: providerCallContext.userId,
+      dialogId: providerCallContext.dialogId,
+      agentId: providerCallContext.agentId,
+      provider: provider || "unknown",
+      model: model || "unknown",
+      endpoint: providerCallContext.endpoint,
+      serviceTier,
+      credential: credential ?? providerCallContext.credential,
+      url,
+      init,
+    },
+  });
+  await writeTerminalProviderCallEventSafely({
+    store: providerCallStore,
+    log,
+    providerCallWriter,
+    billingAnomalyWriter,
+    event: createProviderCallCompletedEvent({
+      providerCallId,
+      eventId: `evt_${ulid()}`,
+      userId: providerCallContext.userId,
+      dialogId: providerCallContext.dialogId,
+      agentId: providerCallContext.agentId,
+      provider: provider || "unknown",
+      model: model || "unknown",
+      endpoint: providerCallContext.endpoint,
+      serviceTier,
+      credential: credential ?? providerCallContext.credential,
+      startedAt,
+      completedAt: isoNow(),
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0,
+      billingStatus: "unpriced",
+    }),
+  });
+  return { response, providerCallId };
+}
+
 function createAbortError(reason?: unknown): Error {
   const error = new Error(typeof reason === "string" ? reason : "Aborted");
   error.name = "AbortError";
@@ -57,6 +232,12 @@ export async function fetchUpstreamWithGentleRetry({
   fallbackOnStatuses,
   retryDelayMs = FIREWORKS_GENTLE_RETRY_DELAY_MS,
   fetchImpl = fetch,
+  providerCallStore,
+  providerCallContext,
+  providerCallWriter,
+  providerDispatchIntentWriter,
+  billingAnomalyWriter,
+  credential,
 }: {
   url: string;
   init: RequestInit;
@@ -68,17 +249,40 @@ export async function fetchUpstreamWithGentleRetry({
   fallbackOnStatuses?: Iterable<number>;
   retryDelayMs?: number;
   fetchImpl?: typeof fetch;
+  providerCallStore?: ProviderCallStore;
+  providerCallContext?: ProviderCallContext;
+  providerCallWriter?: ProviderCallWriter;
+  providerDispatchIntentWriter?: ProviderDispatchIntentWriter;
+  billingAnomalyWriter?: BillingAnomalyWriter;
+  credential?: ProviderCredentialIdentity;
 }): Promise<{
   response: Response;
   provider?: string;
   model?: string;
   serviceTier?: OpenAIServiceTier;
+  providerCallIds?: string[];
 }> {
   const maxAttempts = provider === "fireworks" ? 2 : 1;
   let response: Response | undefined;
+  const providerCallIds: string[] = [];
 
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    response = await fetchImpl(url, init);
+    const evidence = await fetchWithProviderCallEvidence({
+      url,
+      init,
+      provider,
+      model,
+      fetchImpl,
+      providerCallStore,
+      providerCallContext,
+      log,
+      providerCallWriter,
+      providerDispatchIntentWriter,
+      billingAnomalyWriter,
+      credential,
+    });
+    response = evidence.response;
+    if (evidence.providerCallId) providerCallIds.push(evidence.providerCallId);
     const shouldRetry =
       provider === "fireworks" &&
       attempt < maxAttempts &&
@@ -122,6 +326,7 @@ export async function fetchUpstreamWithGentleRetry({
       response,
       provider,
       model,
+      ...(providerCallIds.length > 0 ? { providerCallIds: [...providerCallIds] } : {}),
     };
   }
 
@@ -138,13 +343,30 @@ export async function fetchUpstreamWithGentleRetry({
       fallbackModel: nextFallback.model,
     });
 
-    const fallbackResponse = await fetchImpl(nextFallback.url, nextFallback.init);
+    const fallbackEvidence = await fetchWithProviderCallEvidence({
+      url: nextFallback.url,
+      init: nextFallback.init,
+      provider: nextFallback.provider,
+      model: nextFallback.model,
+      serviceTier: nextFallback.serviceTier,
+      fetchImpl,
+      providerCallStore,
+      providerCallContext,
+      log,
+      providerCallWriter,
+      providerDispatchIntentWriter,
+      billingAnomalyWriter,
+      credential: nextFallback.credential,
+    });
+    const fallbackResponse = fallbackEvidence.response;
+    if (fallbackEvidence.providerCallId) providerCallIds.push(fallbackEvidence.providerCallId);
     if (!fallbackStatuses.has(fallbackResponse.status)) {
       return {
         response: fallbackResponse,
         provider: nextFallback.provider,
         model: nextFallback.model,
         serviceTier: nextFallback.serviceTier,
+        ...(providerCallIds.length > 0 ? { providerCallIds: [...providerCallIds] } : {}),
       };
     }
 
@@ -158,5 +380,6 @@ export async function fetchUpstreamWithGentleRetry({
     response,
     provider: currentProvider,
     model: currentModel,
+    ...(providerCallIds.length > 0 ? { providerCallIds: [...providerCallIds] } : {}),
   };
 }

package/server/handlers/connector/connectorConnectionRegistry.ts

@@ -43,6 +43,7 @@ export type ConnectorAgentRunProgress = {
 export type ConnectorAgentRunOptions = {
   requestTimeoutMs?: number;
   onProgress?: (progress: ConnectorAgentRunProgress) => void | Promise<void>;
+  connectorSurface?: string;
 };
 
 type ConnectorSocket = {
@@ -60,8 +61,10 @@ type PendingRequest = {
 };
 
 type RegisteredConnection = {
+  sessionId: string;
   machineId: string;
   ownerUserId: string;
+  connectorSurface?: string;
   receive(message: string): void;
   close(): void;
 };
@@ -70,8 +73,14 @@ function connectionKey(ownerUserId: string, machineId: string) {
   return `${ownerUserId}:${machineId}`;
 }
 
+function normalizeConnectorSurface(surface: unknown) {
+  return typeof surface === "string" && surface.trim()
+    ? surface.trim().toLowerCase()
+    : undefined;
+}
+
 export function createConnectorConnectionRegistry(options: { requestTimeoutMs?: number } = {}) {
-  const connections = new Map<string, RegisteredConnection & { socket: ConnectorSocket }>();
+  const connections = new Map<string, Array<RegisteredConnection & { socket: ConnectorSocket }>>();
   const pending = new Map<string, PendingRequest>();
   const requestTimeoutMs = options.requestTimeoutMs ?? 120_000;
 
@@ -84,22 +93,58 @@ export function createConnectorConnectionRegistry(options: { requestTimeoutMs?:
     }
   };
 
-  const unregister = (ownerUserId: string, machineId: string) => {
+  const unregister = (ownerUserId: string, machineId: string, sessionId?: string) => {
     const key = connectionKey(ownerUserId, machineId);
+    if (!sessionId) {
+      connections.delete(key);
+      rejectPendingForConnection(key, machineId);
+      return;
+    }
+    const remaining = (connections.get(key) ?? []).filter((connection) =>
+      connection.sessionId !== sessionId
+    );
+    if (remaining.length > 0) {
+      connections.set(key, remaining);
+      return;
+    }
     connections.delete(key);
     rejectPendingForConnection(key, machineId);
   };
 
+  const findConnection = (
+    ownerUserId: string,
+    machineId: string,
+    connectorSurface?: string,
+  ) => {
+    const list = connections.get(connectionKey(ownerUserId, machineId)) ?? [];
+    if (list.length === 0) return null;
+    const surface = normalizeConnectorSurface(connectorSurface);
+    if (surface) {
+      const exact = list.find((connection) => connection.connectorSurface === surface);
+      if (exact) return exact;
+      if (surface === "desktop") {
+        const legacyDesktop = list.find((connection) => !connection.connectorSurface);
+        if (legacyDesktop) return legacyDesktop;
+      }
+      return null;
+    }
+    return list.at(-1) ?? null;
+  };
+
   return {
     register(args: {
       machineId: string;
       ownerUserId: string;
+      connectorSurface?: string;
       send: (message: string) => unknown;
     }): RegisteredConnection {
       const key = connectionKey(args.ownerUserId, args.machineId);
+      const sessionId = randomUUID();
       const connection: RegisteredConnection & { socket: ConnectorSocket } = {
+        sessionId,
         machineId: args.machineId,
         ownerUserId: args.ownerUserId,
+        connectorSurface: normalizeConnectorSurface(args.connectorSurface),
         socket: { send: args.send },
         receive(message) {
           let parsed: any;
@@ -135,15 +180,18 @@ export function createConnectorConnectionRegistry(options: { requestTimeoutMs?:
           });
         },
         close() {
-          unregister(args.ownerUserId, args.machineId);
+          unregister(args.ownerUserId, args.machineId, sessionId);
         },
       };
-      connections.set(key, connection);
+      connections.set(key, [
+        ...(connections.get(key) ?? []),
+        connection,
+      ]);
       return connection;
     },
 
-    hasConnection(ownerUserId: string, machineId: string) {
-      return connections.has(connectionKey(ownerUserId, machineId));
+    hasConnection(ownerUserId: string, machineId: string, connectorSurface?: string) {
+      return Boolean(findConnection(ownerUserId, machineId, connectorSurface));
     },
 
     unregister,
@@ -154,7 +202,7 @@ export function createConnectorConnectionRegistry(options: { requestTimeoutMs?:
       payload: ConnectorAgentRunPayload,
       options: ConnectorAgentRunOptions = {}
     ): Promise<ConnectorAgentRunResult> {
-      const connection = connections.get(connectionKey(ownerUserId, machineId));
+      const connection = findConnection(ownerUserId, machineId, options.connectorSurface);
       if (!connection) {
         return Promise.reject(new Error(`Connector offline for machine: ${machineId}`));
       }

package/server/handlers/connector/connectorWebSocket.ts

@@ -12,7 +12,8 @@ type ConnectorRegistry = ReturnType<typeof createConnectorConnectionRegistry>;
 type ConnectorWsData = {
   connector?: {
     ownerUserId: string;
-    machineId: string;
+    machineId: string;
+    connectorSurface?: string;
     preview?: {
       slotSlug: string;
       capability: "realtime";
@@ -44,7 +45,8 @@ export async function handleConnectorUpgradeRequest(
   } = {}
 ) {
   const url = new URL(req.url);
-  const machineId = url.searchParams.get("machineId")?.trim();
+  const machineId = url.searchParams.get("machineId")?.trim();
+  const connectorSurface = url.searchParams.get("connectorSurface")?.trim().toLowerCase();
   if (!machineId) {
     return new Response("machineId is required", { status: 400 });
   }
@@ -70,10 +72,11 @@ export async function handleConnectorUpgradeRequest(
   const upgraded = server.upgrade(req, {
     data: {
       connector: {
-        ownerUserId: auth.userId,
-        machineId,
-        preview: deps.preview ?? null,
-      },
+        ownerUserId: auth.userId,
+        machineId,
+        ...(connectorSurface ? { connectorSurface } : {}),
+        preview: deps.preview ?? null,
+      },
     },
   });
   return upgraded ? undefined : new Response("WebSocket upgrade failed", { status: 400 });
@@ -87,10 +90,11 @@ export function handleConnectorOpen(
   if (!connector) return false;
   const registry = deps.registry ?? connectorConnectionRegistry;
   connector.connection = registry.register({
-    ownerUserId: connector.ownerUserId,
-    machineId: connector.machineId,
-    send: (message) => ws.send(message),
-  });
+    ownerUserId: connector.ownerUserId,
+    machineId: connector.machineId,
+    connectorSurface: connector.connectorSurface,
+    send: (message) => ws.send(message),
+  });
   return true;
 }
 

package/server/handlers/desktopAgentRuntimeAdapter.ts

@@ -22,9 +22,9 @@ import {
   shouldUsePlatformChatProvider,
 } from "../../agent-runtime";
 import {
-  describeDesktopAgentRuntimeHostFacts,
+  describeDesktopAgentRuntimeHostCapabilities,
   type DesktopAgentRuntimeEnv,
-} from "./desktopAgentRuntimeHostFacts";
+} from "./desktopAgentRuntimeHostCapabilities";
 import { normalizeBuiltinPlatformAgentModelConfig } from "./agentRun/builtinAgents";
 
 export type DesktopAgentRuntimeActions = {
@@ -278,11 +278,11 @@ export function createDesktopAgentRuntimeAdapter(args: {
   actions: DesktopAgentRuntimeActions;
   capabilities?: string[];
 }): AgentRuntimeHostAdapter {
-  const facts = describeDesktopAgentRuntimeHostFacts(args.env);
+  const capabilities = describeDesktopAgentRuntimeHostCapabilities(args.env);
 
   return {
     host: "desktop",
-    capabilities: [...new Set([...facts.capabilities, ...(args.capabilities ?? [])])],
+    capabilities: [...new Set([...capabilities, ...(args.capabilities ?? [])])],
     loadAgentConfig: (agentRef) => loadDesktopAgentRuntimeAgentConfig({
       actions: args.actions,
       agentRef,

package/server/handlers/desktopAgentRuntimeHostCapabilities.ts

@@ -0,0 +1,25 @@
+import {
+  canUsePlatformChatProvider,
+  hasDirectOpenAiCompatibleProvider,
+} from "../../agent-runtime";
+
+export type DesktopAgentRuntimeEnv = Record<string, string | undefined>;
+
+function hasDesktopLocalPersistence(env: DesktopAgentRuntimeEnv) {
+  return Boolean(env.NOLO_SERVER_DB_PATH?.trim());
+}
+
+function hasDesktopProviderEndpoint(env: DesktopAgentRuntimeEnv) {
+  return hasDirectOpenAiCompatibleProvider(env) || canUsePlatformChatProvider(env);
+}
+
+export function describeDesktopAgentRuntimeHostCapabilities(
+  env: DesktopAgentRuntimeEnv
+) {
+  const hasLocalPersistence = hasDesktopLocalPersistence(env);
+  return [
+    ...(hasLocalPersistence ? ["leveldb-agent-config"] : []),
+    ...(hasDesktopProviderEndpoint(env) ? ["local-provider"] : []),
+    ...(hasLocalPersistence ? ["leveldb-persistence"] : []),
+  ];
+}

package/server/handlers/desktopAgentRuntimeReadiness.ts

@@ -0,0 +1,62 @@
+import {
+  resolveAgentRuntimeDecision,
+  type AgentRuntimeDecision,
+} from "../../agent-runtime";
+import type {
+  DesktopProviderRuntimeSnapshot,
+} from "./desktopLlamaRuntimeHandler";
+import type { DesktopAgentRuntimeEnv } from "./desktopAgentRuntimeHostCapabilities";
+
+export type DesktopAgentRuntimeReadinessStatus = {
+  ok: true;
+  host: "desktop";
+  providerRuntimeState: DesktopProviderRuntimeSnapshot["state"];
+  localCapabilities: string[];
+  decision: AgentRuntimeDecision;
+  missingLocalCapabilities: string[];
+};
+
+function hasDesktopLocalPersistence(env: DesktopAgentRuntimeEnv) {
+  return Boolean(env.NOLO_SERVER_DB_PATH?.trim());
+}
+
+function isDesktopProviderRuntimeReady(snapshot: DesktopProviderRuntimeSnapshot) {
+  return snapshot.state === "running";
+}
+
+export function buildDesktopAgentRuntimeReadiness(args: {
+  env: DesktopAgentRuntimeEnv;
+  providerRuntimeSnapshot: DesktopProviderRuntimeSnapshot;
+}): DesktopAgentRuntimeReadinessStatus {
+  const hasLocalPersistence = hasDesktopLocalPersistence(args.env);
+  const hasLocalAgentConfig = hasLocalPersistence;
+  const hasLocalProvider = isDesktopProviderRuntimeReady(args.providerRuntimeSnapshot);
+  const localCapabilities = [
+    ...(hasLocalAgentConfig ? ["agent-config"] : []),
+    ...(hasLocalProvider ? ["provider"] : []),
+    ...(hasLocalPersistence ? ["persistence"] : []),
+  ];
+  const decision = resolveAgentRuntimeDecision({
+    host: "desktop",
+    syncRequested: false,
+    hasLocalAgentConfig,
+    hasLocalProvider,
+    hasLocalPersistence,
+    missingLocalCapabilities: [
+      ...(hasLocalAgentConfig ? [] : ["agent-config"]),
+      ...(hasLocalProvider ? [] : ["provider"]),
+      ...(hasLocalPersistence ? [] : ["persistence"]),
+    ],
+    requiresServer: false,
+    serverFallbackAvailable: true,
+  });
+
+  return {
+    ok: true,
+    host: "desktop",
+    providerRuntimeState: args.providerRuntimeSnapshot.state,
+    localCapabilities,
+    decision,
+    missingLocalCapabilities: decision.missingLocalCapabilities,
+  };
+}

package/server/handlers/desktopAgentRuntimeStatusHandler.ts

@@ -1,43 +1,39 @@
 import {
-  resolveAgentRuntimeDecision,
-  type AgentRuntimeDecision,
-} from "../../agent-runtime";
+  buildDesktopAgentRuntimeReadiness,
+  type DesktopAgentRuntimeReadinessStatus,
+} from "./desktopAgentRuntimeReadiness";
 import {
-  buildDesktopAgentRuntimeDecisionInput,
-  describeDesktopAgentRuntimeHostFacts,
-  type DesktopAgentRuntimeEnv,
-} from "./desktopAgentRuntimeHostFacts";
+  readDesktopProviderRuntimeSnapshot,
+  type DesktopProviderRuntimeSnapshot,
+} from "./desktopLlamaRuntimeHandler";
+import type { DesktopAgentRuntimeEnv } from "./desktopAgentRuntimeHostCapabilities";
 
-export type DesktopAgentRuntimeStatus = {
-  ok: true;
-  host: "desktop";
-  capabilities: string[];
-  decision: AgentRuntimeDecision;
-  missingLocalCapabilities: string[];
-};
+export type { DesktopAgentRuntimeReadinessStatus } from "./desktopAgentRuntimeReadiness";
 
 const JSON_HEADERS = {
   "Content-Type": "application/json; charset=utf-8",
 };
 
-export function buildDesktopAgentRuntimeStatus(args: {
+export async function buildDesktopAgentRuntimeReadinessStatus(args: {
   env?: DesktopAgentRuntimeEnv;
-} = {}): DesktopAgentRuntimeStatus {
+  readDesktopProviderRuntimeSnapshot?: () => Promise<DesktopProviderRuntimeSnapshot>;
+} = {}): Promise<DesktopAgentRuntimeReadinessStatus> {
   const env = args.env ?? process.env;
-  const facts = describeDesktopAgentRuntimeHostFacts(env);
-  const decision = resolveAgentRuntimeDecision(buildDesktopAgentRuntimeDecisionInput(env));
-  return {
-    ok: true,
-    host: "desktop",
-    capabilities: facts.capabilities,
-    decision,
-    missingLocalCapabilities: decision.missingLocalCapabilities,
-  };
+  const providerRuntimeSnapshot = await (
+    args.readDesktopProviderRuntimeSnapshot ?? readDesktopProviderRuntimeSnapshot
+  )();
+  return buildDesktopAgentRuntimeReadiness({
+    env,
+    providerRuntimeSnapshot,
+  });
 }
 
 export async function handleDesktopAgentRuntimeStatusGet(
   _req: Request,
-  deps: { env?: DesktopAgentRuntimeEnv } = {}
+  deps: {
+    env?: DesktopAgentRuntimeEnv;
+    readDesktopProviderRuntimeSnapshot?: () => Promise<DesktopProviderRuntimeSnapshot>;
+  } = {}
 ) {
   const env = deps.env ?? process.env;
   if (env.NOLO_DESKTOP !== "1") {
@@ -47,8 +43,20 @@ export async function handleDesktopAgentRuntimeStatusGet(
     });
   }
 
-  return new Response(JSON.stringify(buildDesktopAgentRuntimeStatus({ env })), {
-    status: 200,
-    headers: JSON_HEADERS,
-  });
+  try {
+    return new Response(JSON.stringify(await buildDesktopAgentRuntimeReadinessStatus({
+      env,
+      readDesktopProviderRuntimeSnapshot: deps.readDesktopProviderRuntimeSnapshot,
+    })), {
+      status: 200,
+      headers: JSON_HEADERS,
+    });
+  } catch (error) {
+    return new Response(JSON.stringify({
+      error: error instanceof Error ? error.message : "Failed to read desktop agent runtime readiness",
+    }), {
+      status: 500,
+      headers: JSON_HEADERS,
+    });
+  }
 }