@openhands/agent-canvas 1.0.0-rc.2 → 1.0.0-rc.3

package/scripts/dev-safe.mjs

@@ -21,6 +21,10 @@ import {
   isProcessRunning,
   signalProcessTree,
 } from "./dev-process-utils.mjs";
+// buildRuntimeServicesInfo moved to its own dependency-free module so the
+// Docker entrypoint can run it as a CLI. Re-exported below for back-compat
+// (dev-with-automation.mjs and tests still import it from here).
+import { buildRuntimeServicesInfo } from "./runtime-services-info.mjs";
 
 // ── Centralized config (single source of truth for versions, ports, etc.) ───
 const __dev_safe_dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -31,6 +35,32 @@ const SHARED_DEFAULTS = JSON.parse(
   ),
 );
 
+/**
+ * Extract the pinned commit SHA for @openhands/extensions from package.json.
+ * Returns the 40-char hex SHA when the dependency is a git+https URL with a
+ * commit hash fragment (e.g. "git+https://…#62594156…"), null otherwise.
+ * @returns {string | null}
+ */
+function getExtensionsRef() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(
+        path.join(__dev_safe_dirname, "..", "package.json"),
+        "utf-8",
+      ),
+    );
+    const url =
+      (pkg.dependencies ?? pkg.devDependencies ?? {})["@openhands/extensions"] ??
+      "";
+    return url.match(/#([0-9a-f]{40})$/i)?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** Pinned extensions commit SHA derived from package.json, or null if not pinned. */
+export const DEFAULT_EXTENSIONS_REF = getExtensionsRef();
+
 const DEFAULT_BACKEND_PORT = SHARED_DEFAULTS.ports.agentServer;
 const DEFAULT_VITE_PORT = 3001;
 const DEFAULT_WAIT_TIMEOUT_MS = 30_000;
@@ -389,7 +419,7 @@ export function validateFrontendDependencies(
  *   edits are picked up without a manual reinstall. The agent-server itself
  *   is rebuilt from local source on each invocation (--reinstall).
  * - OH_AGENT_SERVER_GIT_REF: Git commit SHA or branch name
- * - OH_AGENT_SERVER_VERSION: Specific PyPI version (e.g., "1.24.0")
+ * - OH_AGENT_SERVER_VERSION: Specific PyPI version (e.g., "1.25.0")
  *
  * If none are set, defaults to the released version specified by
  * DEFAULT_AGENT_SERVER_VERSION. Set OH_AGENT_SERVER_GIT_REF to use a
@@ -426,14 +456,23 @@ export function buildAgentServerCommand(env = process.env) {
     );
     source = `local (${localPath})`;
   } else if (gitRef) {
-    // Use git ref with subdirectory syntax for uv workspace monorepo
+    // Use git ref with subdirectory syntax for uv workspace monorepo.
     // The software-agent-sdk repo has packages in subdirectories:
-    // openhands-agent-server/, openhands-tools/, openhands-workspace/
+    // openhands-agent-server/, openhands-sdk/, openhands-tools/, openhands-workspace/
+    // All four must come from the same ref so inter-package APIs stay in sync.
+    //
+    // --reinstall is required because the git branch may carry the same version
+    // string as the current PyPI release (e.g. both "1.25.0"). Without it, uv
+    // silently reuses the cached PyPI wheels and the git ref is never actually
+    // used, even though it was explicitly requested.
     const baseGitUrl = `git+${AGENT_SERVER_GIT_REPO}@${gitRef}`;
     uvxArgs.push(
+      "--reinstall",
       "--from",
       `${baseGitUrl}#subdirectory=openhands-agent-server`,
       "--with",
+      `${baseGitUrl}#subdirectory=openhands-sdk`,
+      "--with",
       `${baseGitUrl}#subdirectory=openhands-tools`,
       "--with",
       `${baseGitUrl}#subdirectory=openhands-workspace`,
@@ -697,124 +736,20 @@ export function buildAgentServerEnv(config) {
     // Make the host tools/ directory importable so the agent-server can
     // resolve modules listed in tool_module_qualnames (e.g. canvas_ui_tool).
     OH_EXTRA_PYTHON_PATH: config.canvasToolsDir,
+    // Tell the agent-server which extensions commit to use for the public
+    // skills catalog. Derived from the @openhands/extensions pin in
+    // package.json; the SDK skips network polling when it already has this
+    // SHA cached. Only injected when the caller has not already set it.
+    ...(DEFAULT_EXTENSIONS_REF && !process.env.EXTENSIONS_REF
+      ? { EXTENSIONS_REF: DEFAULT_EXTENSIONS_REF }
+      : {}),
   };
 }
 
-/**
- * Build a structured description of the dev-stack services that are
- * reachable from inside the agent's sandbox. The frontend forwards this
- * (verbatim, as a JSON string in `VITE_RUNTIME_SERVICES_INFO`) and renders
- * it into the system prompt via `AgentContext.system_message_suffix`, so
- * the agent sees a `<RUNTIME_SERVICES>` block listing what's available
- * without having to probe.
- *
- * URLs are written from the *agent's* point of view. The agent-server
- * runs on the host, so the host alias is "localhost".
- *
- * @param {object} options
- * @param {string} [options.mode] - Human-readable dev mode label (e.g. "dev:safe").
- * @param {string} [options.agentHostAlias="localhost"] - Hostname the agent
- *   uses to reach services running on the host machine.
- * @param {number} [options.agentServerPort] - Port the agent-server listens on.
- *   Required at runtime; the function throws if missing because the resulting
- *   URL would otherwise bake `undefined` into the agent's system prompt.
- *   Typed as optional only so TypeScript callers can negative-test the guard.
- * @param {number} [options.ingressPort] - Ingress port (omit if no ingress).
- * @param {number} [options.frontendPort] - Frontend port (Vite dev server
- *   or static-file server). Omit if no frontend is exposed.
- * @param {number} [options.vitePort] - Deprecated alias for `frontendPort`,
- *   accepted for backward compat with older launchers. Remove after one release.
- * @param {"vite"|"static"} [options.frontendKind="vite"] - Whether the
- *   frontend port hosts Vite or a static build. Only affects the
- *   description shown to the agent.
- * @param {object} [options.automation] - Automation backend info. Skipped
- *   entirely if `.port` is missing, so passing `{}` is safe.
- * @param {number} [options.automation.port] - Automation backend port.
- * @param {string} [options.automation.apiPrefix="/api/automation"] - Path
- *   prefix all automation routes are mounted under.
- * @param {string} [options.automation.authEnvVar="OPENHANDS_AUTOMATION_API_KEY"]
- *   - Env var holding the API key.
- * @returns {object} A JSON-serializable runtime services info object.
- */
-export function buildRuntimeServicesInfo(options) {
-  const {
-    mode,
-    agentHostAlias = "localhost",
-    agentServerPort,
-    ingressPort,
-    // Accept legacy `vitePort` for one release so external callers keep working.
-    vitePort,
-    frontendPort = vitePort,
-    frontendKind = "vite",
-    automation,
-  } = options;
-
-  if (agentServerPort === undefined || agentServerPort === null) {
-    // Without this the URL becomes `http://localhost:undefined` and ends up
-    // verbatim in the agent's system prompt, which is worse than failing fast.
-    throw new Error(
-      "buildRuntimeServicesInfo: agentServerPort is required " +
-        "(otherwise the agent_server URL would be `http://localhost:undefined`).",
-    );
-  }
-
-  const services = {
-    agent_server: {
-      description:
-        "The OpenHands Agent Server this agent is running inside. " +
-        "Tool calls (terminal, file_editor, browser, etc.) execute here.",
-      // From the agent's POV, the agent-server it's *inside* is on
-      // localhost, regardless of where the host is.
-      url_from_agent: `http://localhost:${agentServerPort}`,
-    },
-  };
-
-  if (ingressPort !== undefined) {
-    services.ingress = {
-      description:
-        "Unified entry point. Routes /api/automation/* to the automation " +
-        "backend, /api/* and /sockets to the agent-server, and /* to the " +
-        "frontend.",
-      url_from_agent: `http://${agentHostAlias}:${ingressPort}`,
-    };
-  }
-
-  if (frontendPort !== undefined) {
-    services.frontend = {
-      kind: frontendKind,
-      description:
-        frontendKind === "static"
-          ? "Static-file server hosting the agent-canvas production build."
-          : "Vite dev server hosting the agent-canvas frontend.",
-      url_from_agent: `http://${agentHostAlias}:${frontendPort}`,
-    };
-  }
-
-  // Require an explicit port so we don't bake `:undefined` into the
-  // automation URL when the caller passes `automation: {}`.
-  if (automation?.port !== undefined && automation.port !== null) {
-    const apiPrefix = automation.apiPrefix ?? "/api/automation";
-    const authEnvVar = automation.authEnvVar ?? "OPENHANDS_AUTOMATION_API_KEY";
-    const baseUrl = `http://${agentHostAlias}:${automation.port}`;
-    services.automation = {
-      description:
-        "OpenHands Automations service. All routes are mounted under " +
-        `'${apiPrefix}'. Authenticate with header ` +
-        `'X-Session-API-Key: $${authEnvVar}'.`,
-      url_from_agent: baseUrl,
-      api_prefix: apiPrefix,
-      docs_url: `${baseUrl}${apiPrefix}/docs`,
-      openapi_url: `${baseUrl}${apiPrefix}/openapi.json`,
-      auth_env_var: authEnvVar,
-    };
-  }
-
-  return {
-    mode,
-    agent_host_alias: agentHostAlias,
-    services,
-  };
-}
+// Re-export so existing importers (dev-with-automation.mjs, tests) keep
+// resolving `buildRuntimeServicesInfo` from this module. The implementation
+// now lives in ./runtime-services-info.mjs (imported at the top of this file).
+export { buildRuntimeServicesInfo };
 
 export function buildNpmScriptCommand(
   scriptName,

package/scripts/dev-with-automation.mjs

@@ -119,6 +119,38 @@ function logError(message) {
   console.error(`${c.red}✗${c.reset} ${message}`);
 }
 
+/**
+ * Parse one JSON log line produced by the SDK's JsonFormatter and return a
+ * single-line human-readable string + an appropriate ANSI color.
+ *
+ * Returns null for non-JSON lines so callers can fall back to the raw text.
+ *
+ * @param {string} rawLine
+ * @returns {{ text: string; color: string } | null}
+ */
+function parseAgentServerLogLine(rawLine) {
+  try {
+    const obj = JSON.parse(rawLine);
+    if (!obj.levelname || obj.message === undefined) return null;
+    const level = obj.levelname.padEnd(8);
+    const location =
+      obj.filename && obj.lineno ? `  ${obj.filename}:${obj.lineno}` : "";
+    const text = `${level} ${obj.message}${location}`;
+    const lvl = obj.levelname;
+    const color =
+      lvl === "DEBUG"
+        ? c.dim
+        : lvl === "WARNING"
+          ? c.yellow
+          : lvl === "ERROR" || lvl === "CRITICAL"
+            ? c.red
+            : c.blue;
+    return { text, color };
+  } catch {
+    return null;
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Configuration
 // ═══════════════════════════════════════════════════════════════════════════
@@ -521,6 +553,7 @@ function spawnService(name, command, args, options = {}) {
   );
 
   const color = options.color || c.reset;
+  const parseLogLine = options.parseLogLine;
 
   proc.stdout.on("data", (data) => {
     data
@@ -528,7 +561,8 @@ function spawnService(name, command, args, options = {}) {
       .split("\n")
       .filter(Boolean)
       .forEach((line) => {
-        logService(name, line.trim(), color);
+        const parsed = parseLogLine ? parseLogLine(line.trim()) : null;
+        logService(name, parsed ? parsed.text : line.trim(), parsed ? parsed.color : color);
       });
   });
 
@@ -538,7 +572,8 @@ function spawnService(name, command, args, options = {}) {
       .split("\n")
       .filter(Boolean)
       .forEach((line) => {
-        logService(name, line.trim(), c.yellow);
+        const parsed = parseLogLine ? parseLogLine(line.trim()) : null;
+        logService(name, parsed ? parsed.text : line.trim(), parsed ? parsed.color : c.yellow);
       });
   });
 
@@ -699,6 +734,11 @@ function startAgentServer(config) {
     // Ensure the agent-server uses the resolved key from config. This is
     // LOCAL_BACKEND_API_KEY when set, or the auto-generated persisted key.
     OH_SESSION_API_KEYS_0: config.sessionApiKey,
+    // Emit structured JSON log lines instead of Rich-formatted output.
+    // Rich wraps long messages across multiple lines and prepends its own
+    // timestamp; LOG_JSON=true produces one JSON object per record which
+    // parseAgentServerLogLine re-formats into a clean single-line entry.
+    LOG_JSON: "true",
   };
 
   spawnService(
@@ -715,6 +755,7 @@ function startAgentServer(config) {
       cwd: safeConfig.workspacesPath,
       env: agentServerEnv,
       color: c.blue,
+      parseLogLine: parseAgentServerLogLine,
     },
   );
 }
@@ -796,8 +837,10 @@ function startAutomationBackend(config) {
           join(config.stateDir, "workspaces"),
         // Session API key for self-hosted auth — shared with agent-server via X-Session-API-Key header
         AUTOMATION_LOCAL_API_KEY: config.sessionApiKey,
-        // CORS: allow localhost origins for dev
-        AUTOMATION_CORS_ORIGINS: `http://localhost:${config.ingressPort},http://127.0.0.1:${config.ingressPort},http://localhost:3001,http://127.0.0.1:3001`,
+        // CORS: allow localhost origins for dev, unless explicitly overridden.
+        AUTOMATION_CORS_ORIGINS:
+          process.env.AUTOMATION_CORS_ORIGINS ||
+          `http://localhost:${config.ingressPort},http://127.0.0.1:${config.ingressPort},http://localhost:3001,http://127.0.0.1:3001`,
         FILE_STORE: "local",
         LOCAL_STORAGE_PATH: join(config.stateDir, "storage"),
         OPENHANDS_SUPPRESS_BANNER: "1",
@@ -1269,6 +1312,13 @@ function startStaticFrontend(config, staticDir) {
   logService("static", `Starting on port ${config.vitePort}...`, c.magenta);
   logService("static", `Serving from: ${staticDir}`, c.dim);
 
+  // Build the runtime-services info JSON so the pre-built frontend can
+  // populate the agent's <RUNTIME_SERVICES> system-prompt block without
+  // VITE_RUNTIME_SERVICES_INFO baked in at build time.
+  const runtimeServicesInfo = config.launchAgentServer
+    ? JSON.stringify(buildAutomationRuntimeServicesInfo(config))
+    : null;
+
   const staticServerScript = join(projectRoot, "scripts", "static-server.mjs");
   spawnService(
     "static",
@@ -1288,6 +1338,10 @@ function startStaticFrontend(config, staticDir) {
       ...(config.launchAgentServer && config.isPublic
         ? ["--auth-required"]
         : []),
+      // Inject runtime-services info so the agent knows what's reachable.
+      ...(runtimeServicesInfo
+        ? ["--runtime-services-info", runtimeServicesInfo]
+        : []),
       // Proxy routes only to services that this launch mode started.
       ...buildRouteArgs(getLocalServiceRoutes(config)),
       // Reject known API prefixes that have no backend — returns 503

package/scripts/runtime-services-info.mjs

@@ -0,0 +1,199 @@
+/**
+ * Single source of truth for the `<RUNTIME_SERVICES>` block.
+ *
+ * Builds a structured description of the services that are reachable from
+ * inside the agent's sandbox. The frontend forwards it (verbatim, as a JSON
+ * string) and renders it into the system prompt via
+ * `AgentContext.system_message_suffix`, so the agent sees a
+ * `<RUNTIME_SERVICES>` block listing what's available without having to probe.
+ *
+ * Two callers share this one definition:
+ *   - the dev launchers (scripts/dev-*.mjs), which know the stack as a set of
+ *     ports and bake the result into `VITE_RUNTIME_SERVICES_INFO` at build time;
+ *   - docker/entrypoint.sh, which runs this file as a CLI (see the bottom of
+ *     this module) because in a container the URLs are *runtime* config — the
+ *     ports and base URLs are overridable at `docker run` and therefore cannot
+ *     be baked into the image at build time. The JSON it prints is injected
+ *     into index.html at serve time by scripts/static-server.mjs.
+ *
+ * URLs are written from the *agent's* point of view (i.e. as the agent should
+ * curl/fetch them from inside its sandbox), which is deliberately not the
+ * browser's point of view.
+ */
+
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+
+/**
+ * @param {object} options
+ * @param {string} [options.mode] - Human-readable mode label (e.g. "dev:safe").
+ * @param {string} [options.agentHostAlias="localhost"] - Hostname the agent
+ *   uses to reach host-side services (ingress, frontend, port-derived
+ *   automation). Also surfaced as `agent_host_alias`.
+ * @param {number} [options.agentServerPort] - Port the agent-server listens on.
+ *   Used to derive the agent_server URL when `agentServerUrl` is not given.
+ * @param {string} [options.agentServerUrl] - Explicit agent_server URL, from
+ *   the agent's POV. Takes precedence over `agentServerPort`; used by the
+ *   Docker image, which serves over `127.0.0.1` to avoid IPv6 loopback issues
+ *   and honors an overridable `AGENT_SERVER_URL`. One of `agentServerUrl` /
+ *   `agentServerPort` is required (else the URL would be `:undefined`).
+ * @param {number} [options.ingressPort] - Ingress port (omit if no ingress).
+ * @param {number} [options.frontendPort] - Frontend port (Vite dev server
+ *   or static-file server). Omit if no frontend is exposed.
+ * @param {number} [options.vitePort] - Deprecated alias for `frontendPort`,
+ *   accepted for backward compat with older launchers. Remove after one release.
+ * @param {"vite"|"static"} [options.frontendKind="vite"] - Whether the
+ *   frontend port hosts Vite or a static build. Only affects the description.
+ * @param {object} [options.automation] - Automation backend info. Skipped
+ *   entirely unless `.url` or `.port` is provided, so passing `{}` is safe.
+ * @param {string} [options.automation.url] - Explicit automation base URL, from
+ *   the agent's POV. Takes precedence over `.port`; used by the Docker image to
+ *   honor an overridable `AUTOMATION_BASE_URL`.
+ * @param {number} [options.automation.port] - Automation backend port (used to
+ *   derive the base URL when `.url` is not given).
+ * @param {string} [options.automation.apiPrefix="/api/automation"] - Path
+ *   prefix all automation routes are mounted under.
+ * @param {string} [options.automation.authEnvVar="OPENHANDS_AUTOMATION_API_KEY"]
+ *   - Env var holding the API key.
+ * @returns {object} A JSON-serializable runtime services info object.
+ */
+export function buildRuntimeServicesInfo(options) {
+  const {
+    mode,
+    agentHostAlias = "localhost",
+    agentServerPort,
+    agentServerUrl,
+    ingressPort,
+    // Accept legacy `vitePort` for one release so external callers keep working.
+    vitePort,
+    frontendPort = vitePort,
+    frontendKind = "vite",
+    automation,
+  } = options;
+
+  // Prefer an explicit URL (containers reach the agent-server over a specific
+  // host/scheme), else derive it from the port. From the agent's POV the
+  // agent-server it's *inside* is on the loopback host, regardless of where
+  // the host machine is.
+  const agentServerUrlResolved =
+    agentServerUrl ??
+    (agentServerPort != null ? `http://localhost:${agentServerPort}` : null);
+  if (!agentServerUrlResolved) {
+    // Without this the URL becomes `http://localhost:undefined` and ends up
+    // verbatim in the agent's system prompt, which is worse than failing fast.
+    throw new Error(
+      "buildRuntimeServicesInfo: agentServerPort or agentServerUrl is required " +
+        "(otherwise the agent_server URL would be `http://localhost:undefined`).",
+    );
+  }
+
+  const services = {
+    agent_server: {
+      description:
+        "The OpenHands Agent Server this agent is running inside. " +
+        "Tool calls (terminal, file_editor, browser, etc.) execute here.",
+      url_from_agent: agentServerUrlResolved,
+    },
+  };
+
+  if (ingressPort !== undefined) {
+    services.ingress = {
+      description:
+        "Unified entry point. Routes /api/automation/* to the automation " +
+        "backend, /api/* and /sockets to the agent-server, and /* to the " +
+        "frontend.",
+      url_from_agent: `http://${agentHostAlias}:${ingressPort}`,
+    };
+  }
+
+  if (frontendPort !== undefined) {
+    services.frontend = {
+      kind: frontendKind,
+      description:
+        frontendKind === "static"
+          ? "Static-file server hosting the agent-canvas production build."
+          : "Vite dev server hosting the agent-canvas frontend.",
+      url_from_agent: `http://${agentHostAlias}:${frontendPort}`,
+    };
+  }
+
+  // Prefer an explicit base URL, else derive from the port. Require one of the
+  // two so we don't bake `:undefined` into the URL when the caller passes
+  // `automation: {}`.
+  const automationBaseUrl =
+    automation?.url ??
+    (automation?.port != null
+      ? `http://${agentHostAlias}:${automation.port}`
+      : null);
+  if (automationBaseUrl) {
+    const apiPrefix = automation.apiPrefix ?? "/api/automation";
+    const authEnvVar = automation.authEnvVar ?? "OPENHANDS_AUTOMATION_API_KEY";
+    services.automation = {
+      description:
+        "OpenHands Automations service. All routes are mounted under " +
+        `'${apiPrefix}'. Authenticate with header ` +
+        `'X-Session-API-Key: $${authEnvVar}'.`,
+      url_from_agent: automationBaseUrl,
+      api_prefix: apiPrefix,
+      docs_url: `${automationBaseUrl}${apiPrefix}/docs`,
+      openapi_url: `${automationBaseUrl}${apiPrefix}/openapi.json`,
+      auth_env_var: authEnvVar,
+    };
+  }
+
+  return {
+    mode,
+    agent_host_alias: agentHostAlias,
+    services,
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// CLI — used by docker/entrypoint.sh to emit the JSON at container startup.
+// ─────────────────────────────────────────────────────────────────────────────
+
+export function parseArgs(argv) {
+  const options = { automation: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const flag = argv[i];
+    switch (flag) {
+      case "--mode":
+        options.mode = argv[++i];
+        break;
+      case "--agent-host-alias":
+        options.agentHostAlias = argv[++i];
+        break;
+      case "--agent-server-url":
+        options.agentServerUrl = argv[++i] || undefined;
+        break;
+      case "--automation-url":
+        options.automation.url = argv[++i] || undefined;
+        break;
+      case "--automation-api-prefix":
+        options.automation.apiPrefix = argv[++i];
+        break;
+      case "--automation-auth-env":
+        options.automation.authEnvVar = argv[++i];
+        break;
+      default:
+        throw new Error(`Unknown flag: ${flag}`);
+    }
+  }
+  // Omit the automation entry entirely when no URL was supplied, rather than
+  // advertising a backend the agent cannot reach.
+  if (!options.automation.url) delete options.automation;
+  return options;
+}
+
+const isMainModule =
+  process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+
+if (isMainModule) {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    process.stdout.write(JSON.stringify(buildRuntimeServicesInfo(options)));
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+}

package/scripts/static-server.mjs

@@ -75,6 +75,7 @@ export function parseArgs(argv = process.argv.slice(2)) {
     rejectPrefixes: [],
     sessionApiKey: null,
     authRequired: false,
+    runtimeServicesInfo: null,
   };
 
   for (let i = 0; i < argv.length; i++) {
@@ -110,6 +111,9 @@ export function parseArgs(argv = process.argv.slice(2)) {
       case "--session-api-key":
         config.sessionApiKey = argv[++i] || null;
         break;
+      case "--runtime-services-info":
+        config.runtimeServicesInfo = argv[++i] || null;
+        break;
       case "--auth-required":
         config.authRequired = true;
         break;
@@ -167,6 +171,12 @@ OPTIONS:
   --auth-required              Inject authRequired flag into index.html so the
                                pre-built frontend shows the API key entry screen
                                (public mode) without VITE_AUTH_REQUIRED baked in.
+  --runtime-services-info <json>
+                               Inject a JSON description of the local runtime
+                               services into index.html so the pre-built
+                               frontend can populate the agent's
+                               <RUNTIME_SERVICES> system-prompt block without
+                               VITE_RUNTIME_SERVICES_INFO baked in.
   --reject-prefix <prefix>     Return 503 for requests matching <prefix>
                                instead of SPA-fallbacking to index.html;
                                may be repeated. Useful in --frontend-only
@@ -208,8 +218,19 @@ ROUTING:
  * - `authRequired`: sets `window.__AGENT_CANVAS_AUTH_REQUIRED__ = true` so the
  *   pre-built frontend shows the API key entry screen (public mode) without
  *   VITE_AUTH_REQUIRED baked in.
+ *
+ * - `runtimeServicesInfo`: a JSON string describing the local services
+ *   (agent-server, automation, …), exposed as
+ *   `window.__AGENT_CANVAS_RUNTIME_SERVICES_INFO__`. Read by
+ *   `parseRuntimeServicesInfo()` in `agent-server-adapter.ts` as a fallback
+ *   when `VITE_RUNTIME_SERVICES_INFO` is empty, so static builds (Docker /
+ *   published binary) still populate the agent's `<RUNTIME_SERVICES>` block.
  */
-function makeConfigInjectionScript(sessionApiKey, authRequired) {
+function makeConfigInjectionScript(
+  sessionApiKey,
+  authRequired,
+  runtimeServicesInfo,
+) {
   const parts = [];
 
   if (sessionApiKey) {
@@ -236,6 +257,16 @@ function makeConfigInjectionScript(sessionApiKey, authRequired) {
     parts.push(`window.__AGENT_CANVAS_AUTH_REQUIRED__=true;`);
   }
 
+  if (runtimeServicesInfo) {
+    // Stored as the raw JSON string so the browser-side parser
+    // (parseRuntimeServicesInfo) can JSON.parse it exactly like the
+    // VITE_RUNTIME_SERVICES_INFO env var. JSON.stringify produces a safe JS
+    // string literal for the inline <script>.
+    parts.push(
+      `window.__AGENT_CANVAS_RUNTIME_SERVICES_INFO__=${JSON.stringify(runtimeServicesInfo)};`,
+    );
+  }
+
   if (parts.length === 0) return "";
 
   return `<script>(function(){${parts.join("")}}());</script>`;
@@ -249,7 +280,7 @@ async function serveInjectedIndexHtml(
   req,
   res,
   indexPath,
-  { sessionApiKey, authRequired } = {},
+  { sessionApiKey, authRequired, runtimeServicesInfo } = {},
 ) {
   let content;
   try {
@@ -258,7 +289,11 @@ async function serveInjectedIndexHtml(
     return false;
   }
 
-  const script = makeConfigInjectionScript(sessionApiKey, authRequired);
+  const script = makeConfigInjectionScript(
+    sessionApiKey,
+    authRequired,
+    runtimeServicesInfo,
+  );
   // Inject right before </head> so the key is available before any app code runs.
   // replace() targets the first (and only) </head> in well-formed HTML.
   const injected = content.includes("</head>")
@@ -500,7 +535,9 @@ async function handleStatic(
   }
 
   const needsInjection =
-    injectionOpts.sessionApiKey || injectionOpts.authRequired;
+    injectionOpts.sessionApiKey ||
+    injectionOpts.authRequired ||
+    injectionOpts.runtimeServicesInfo;
 
   // Serve index.html with runtime config injection when configured.
   if (needsInjection && filePath.endsWith("index.html")) {
@@ -553,6 +590,7 @@ export function startStaticServer(config) {
   const injectionOpts = {
     sessionApiKey: config.sessionApiKey || null,
     authRequired: config.authRequired || false,
+    runtimeServicesInfo: config.runtimeServicesInfo || null,
   };
   const rejectPrefixes = config.rejectPrefixes ?? [];
 

package/build/assets/acp-providers-DZEi8wDz.js

@@ -1 +0,0 @@
-import{t as e}from"./declaration-IA661TBv.js";import{t}from"./vendor~root-layout~home~conversation-panel~conversation~launch~settings~settings-index~agen~jxrvuot9-Cwz6a1DC.js";var n=`cli-generic`,r=new Set([`default`,`default (recommended)`]);function i(e){if(typeof e!=`string`)return null;let t=e.trim();return!t||r.has(t.toLowerCase())||t===`acp-managed`?null:t}function a(e){for(let t of[e.runtimeName,e.runtimeId,e.configured,e.sdkLlm]){let e=i(t);if(e)return e}return e.providerDefault??null}var o={"claude-code":{icon:`claude-code`,description_key:e.ONBOARDING$AGENT_CLAUDE_CODE_DESCRIPTION},codex:{icon:`codex`,description_key:e.ONBOARDING$AGENT_CODEX_DESCRIPTION},"gemini-cli":{icon:`gemini`,description_key:e.ONBOARDING$AGENT_GEMINI_CLI_DESCRIPTION}},s=Object.entries(o).map(([e,n])=>{let r=t(e);return{key:e,display_name:r?.display_name??e,default_command:r?[...r.default_command]:[],available_models:r?.available_models?.map(e=>({id:e.id,label:e.label})),default_model:r?.default_model??void 0,description_key:n.description_key,icon:n.icon}}),c=`custom`;function l(n){let r=n?t(n):null;if(!r)return[];let i=[];return r.api_key_env_var&&i.push({name:r.api_key_env_var,secret:!0,hint_key:e.ONBOARDING$ACP_SECRET_API_KEY_HINT}),r.base_url_env_var&&i.push({name:r.base_url_env_var,hint_key:e.ONBOARDING$ACP_SECRET_BASE_URL_HINT}),i}function u(e){if(e)return s.find(t=>t.key===e)}function d(e){let t=u(e);return t?t.display_name:null}function f(e){return u(e)?.icon??`cli-generic`}function p(e,t){return t?u(e)?.available_models?.find(e=>e.id===t)?.label??t:null}function m(e,t={}){if(e===`openhands`)return{agent_kind:`openhands`};let n=e===c,r=n?void 0:u(e);if(!n&&!r&&!t.allowUnknownServer)return null;let i=t.model===void 0?r?.default_model??null:t.model;return{agent_kind:`acp`,acp_server:e,acp_command:t.command??[],acp_args:[],acp_model:i??null}}export{u as a,p as c,m as i,f as l,s as n,d as o,n as r,l as s,c as t,a as u};