@sellable/install 0.1.796 → 0.1.797-wip.runtime-ux.20261004.2

package/container/Dockerfile

@@ -3,12 +3,12 @@ FROM ${HERMES_IMAGE}
 
 USER root
 
-ARG INSTALLER_PACKAGE=@sellable/install@0.1.796
+ARG INSTALLER_PACKAGE=@sellable/install@0.1.797-wip.runtime-ux.20261004.2
 ARG MCP_PACKAGE=@sellable/mcp@0.1.957
 ARG INSTALLER_INTEGRITY
 ARG MCP_INTEGRITY=sha512-tIZuO5IEanT/afamDIWdorUNMdqZA6xnjL9jGAmGqYIlIqkXdHB9slWiwfLfmM44iEp7OT98IBHJlvbpMThk6A==
 
-RUN test "${INSTALLER_PACKAGE}" = "@sellable/install@0.1.796" \
+RUN test "${INSTALLER_PACKAGE}" = "@sellable/install@0.1.797-wip.runtime-ux.20261004.2" \
     && test "${MCP_PACKAGE}" = "@sellable/mcp@0.1.957" \
     && test -n "${INSTALLER_INTEGRITY}" \
     && test "$(npm view "${INSTALLER_PACKAGE}" dist.integrity)" = "${INSTALLER_INTEGRITY}" \
@@ -23,9 +23,9 @@ RUN test "${INSTALLER_PACKAGE}" = "@sellable/install@0.1.796" \
     && mkdir -p /opt/sellable-agent/install-root /opt/sellable-agent/mcp-root \
     && npm install --prefix /opt/sellable-agent/install-root --omit=dev --ignore-scripts --no-audit --no-fund "${INSTALLER_PACKAGE}" \
     && npm install --prefix /opt/sellable-agent/mcp-root --omit=dev --ignore-scripts --no-audit --no-fund "${MCP_PACKAGE}" \
-    && node --input-type=module -e "import { readFileSync } from 'node:fs'; const install = JSON.parse(readFileSync('/opt/sellable-agent/install-root/node_modules/@sellable/install/package.json')); const mcp = JSON.parse(readFileSync('/opt/sellable-agent/mcp-root/node_modules/@sellable/mcp/package.json')); if (install.name !== '@sellable/install' || install.version !== '0.1.796' || mcp.name !== '@sellable/mcp' || mcp.version !== '0.1.957') throw new Error('package identity rejected');" \
+    && node --input-type=module -e "import { readFileSync } from 'node:fs'; const install = JSON.parse(readFileSync('/opt/sellable-agent/install-root/node_modules/@sellable/install/package.json')); const mcp = JSON.parse(readFileSync('/opt/sellable-agent/mcp-root/node_modules/@sellable/mcp/package.json')); if (install.name !== '@sellable/install' || install.version !== '0.1.797-wip.runtime-ux.20261004.2' || mcp.name !== '@sellable/mcp' || mcp.version !== '0.1.957') throw new Error('package identity rejected');" \
     && node --input-type=module -e "import { buildExternalRuntimeClosure } from '/opt/sellable-agent/install-root/node_modules/@sellable/install/lib/sellable-agent/external-runtime-builder.mjs'; const built = buildExternalRuntimeClosure({ mcpPackageRoot: '/opt/sellable-agent/mcp-root/node_modules/@sellable/mcp', mcpNodeModulesRoot: '/opt/sellable-agent/mcp-root/node_modules', hermesSourceRoot: '/opt/hermes', ownerUid: 0, ownerGid: 0 }); if (!built.closureDigest) throw new Error('runtime closure rejected');" \
-    && node --input-type=module -e "import { chmodSync, writeFileSync } from 'node:fs'; const release = { installerPackage: '@sellable/install@0.1.796', installerIntegrity: process.argv[1], mcpPackage: '@sellable/mcp@0.1.957', mcpIntegrity: process.argv[2] }; writeFileSync('/opt/sellable-agent/release.json', JSON.stringify(release) + '\\n', { mode: 0o444 }); chmodSync('/opt/sellable-agent/release.json', 0o444);" "${INSTALLER_INTEGRITY}" "${MCP_INTEGRITY}" \
+    && node --input-type=module -e "import { chmodSync, writeFileSync } from 'node:fs'; const release = { installerPackage: '@sellable/install@0.1.797-wip.runtime-ux.20261004.2', installerIntegrity: process.argv[1], mcpPackage: '@sellable/mcp@0.1.957', mcpIntegrity: process.argv[2] }; writeFileSync('/opt/sellable-agent/release.json', JSON.stringify(release) + '\\n', { mode: 0o444 }); chmodSync('/opt/sellable-agent/release.json', 0o444);" "${INSTALLER_INTEGRITY}" "${MCP_INTEGRITY}" \
     && npm cache clean --force
 
 COPY entrypoint.sh /usr/local/bin/sellable-agent-container-entrypoint

package/container/README.md

@@ -3,7 +3,7 @@
 This image is a dedicated Agent worker/runtime boundary beside an existing Hermes dashboard. It never replaces or reconfigures the dashboard container.
 
 Build from this directory after
-`@sellable/install@0.1.796` is
+`@sellable/install@0.1.797-wip.runtime-ux.20261004.2` is
 published:
 
 ```sh

package/lib/sellable-agent/fly-admin-image/Dockerfile

@@ -169,7 +169,7 @@ COPY fly-admin-image/start-admin-runtime /usr/local/lib/sellable-agent/admin-run
 COPY fly-customer-image/customer-runtime.mjs /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime.mjs
 COPY hermes-first-welcome.mjs /usr/local/lib/sellable-agent/hermes-first-welcome.mjs
 COPY fly-customer-image/hermes-runs-client.mjs /usr/local/lib/sellable-agent/fly-customer-image/hermes-runs-client.mjs
-COPY fly-customer-image/endpoint-model-selection.mjs fly-customer-image/runs-api-connections.mjs fly-customer-image/claude-code-runs-api.mjs fly-customer-image/claude-code-mcp-session.mjs /usr/local/lib/sellable-agent/fly-customer-image/
+COPY fly-customer-image/endpoint-model-selection.mjs fly-customer-image/runs-api-connections.mjs fly-customer-image/claude-code-runs-api.mjs fly-customer-image/claude-code-mcp-session.mjs fly-customer-image/openai-runs-client.mjs fly-customer-image/runs-api-health-check.mjs /usr/local/lib/sellable-agent/fly-customer-image/
 COPY fly-customer-image/opener-stage-execution.mjs /usr/local/lib/sellable-agent/fly-customer-image/opener-stage-execution.mjs
 COPY fly-customer-image/endpoint-uat-completion-gate.mjs /usr/local/lib/sellable-agent/fly-customer-image/endpoint-uat-completion-gate.mjs
 COPY fly-customer-image/customer-runtime-phase-telemetry.mjs /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime-phase-telemetry.mjs

package/lib/sellable-agent/fly-customer-image/Dockerfile

@@ -8,7 +8,7 @@ ENV PLAYWRIGHT_BROWSERS_PATH=/opt/hermes/.playwright
 
 ARG MCP_PACKAGE=@sellable/mcp@0.1.957
 ARG MCP_INTEGRITY=sha512-tIZuO5IEanT/afamDIWdorUNMdqZA6xnjL9jGAmGqYIlIqkXdHB9slWiwfLfmM44iEp7OT98IBHJlvbpMThk6A==
-ARG INSTALLER_PACKAGE=@sellable/install@0.1.796
+ARG INSTALLER_PACKAGE=@sellable/install@0.1.797-wip.runtime-ux.20261004.2
 ARG ADMIN_MCP_PACKAGE=@sellable/admin-mcp@0.1.202
 ARG ADMIN_MCP_INTEGRITY=sha512-ym3aye/0vQ8tfULJlKz9JFOxvIQsl1G+n3np+TTgK/tecwNblBo/j3AkTnRqH9iomKzPbZzP+n4tEQsvsU8ByA==
 ARG TUS_JS_CLIENT_VERSION=4.3.1
@@ -98,7 +98,7 @@ COPY hermes-memory-reconcile.sh /opt/sellable/share/hermes-memory-reconcile.sh
 COPY hermes-endpoint-cron.mjs /opt/sellable/bin/hermes-endpoint-cron
 COPY fly-customer-image/model-auth-store.mjs /usr/local/lib/sellable-agent/fly-customer-image/model-auth-store.mjs
 COPY fly-customer-image/hermes-runs-client.mjs /usr/local/lib/sellable-agent/fly-customer-image/hermes-runs-client.mjs
-COPY fly-customer-image/endpoint-model-selection.mjs fly-customer-image/runs-api-connections.mjs /usr/local/lib/sellable-agent/fly-customer-image/
+COPY fly-customer-image/endpoint-model-selection.mjs fly-customer-image/runs-api-connections.mjs fly-customer-image/openai-runs-client.mjs fly-customer-image/runs-api-health-check.mjs /usr/local/lib/sellable-agent/fly-customer-image/
 COPY fly-customer-image/opener-stage-execution.mjs /usr/local/lib/sellable-agent/fly-customer-image/opener-stage-execution.mjs
 COPY fly-customer-image/endpoint-uat-completion-gate.mjs /usr/local/lib/sellable-agent/fly-customer-image/endpoint-uat-completion-gate.mjs
 COPY fly-customer-image/customer-runtime-phase-telemetry.mjs /usr/local/lib/sellable-agent/fly-customer-image/customer-runtime-phase-telemetry.mjs

package/lib/sellable-agent/fly-customer-image/claude-code-runs-api.d.mts

@@ -38,6 +38,9 @@ export type ClaudeRunsApiOptions = {
   maxConcurrency?: number;
   maxToolConcurrency?: number;
   toolLanes?: ClaudeRunsToolLanes | null;
+  checkAuthentication?: () => Promise<
+    "READY" | "SIGN_IN_REQUIRED" | "UNAVAILABLE"
+  >;
 };
 export function validateClaudeRunsRequest(
   body: unknown,
@@ -75,3 +78,9 @@ export function startConfiguredClaudeRunsApis(options?: {
   readToken?: (path: string) => string;
   toolLanes?: ClaudeRunsToolLanes | null;
 }): Promise<{ stop(): Promise<void> }>;
+
+export function readClaudeAuthentication(options: {
+  root: string;
+  execFileImpl?: any;
+  timeoutMs?: number;
+}): Promise<"READY" | "SIGN_IN_REQUIRED" | "UNAVAILABLE">;

package/lib/sellable-agent/fly-customer-image/claude-code-runs-api.mjs

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 import {
   appendFileSync,
@@ -195,6 +195,42 @@ export function claudeInvocation(request, root, mcpSpecPath = null) {
   };
 }
 
+// Uses the same isolated environment as generation. Only a typed status leaves
+// this boundary; CLI stdout can contain account identity and is never forwarded.
+export function readClaudeAuthentication({
+  root,
+  execFileImpl = execFile,
+  timeoutMs = 8_000,
+} = {}) {
+  const invocation = claudeInvocation(
+    { instructions: "", input: "", model: "claude-opus", effort: "high" },
+    root
+  );
+  return new Promise((resolve) => {
+    execFileImpl(
+      invocation.command,
+      ["auth", "status"],
+      {
+        cwd: invocation.options.cwd,
+        env: invocation.options.env,
+        timeout: timeoutMs,
+        maxBuffer: 16 * 1024,
+        encoding: "utf8",
+      },
+      (error, stdout) => {
+        try {
+          const value = JSON.parse(stdout);
+          if (value.loggedIn === false) return resolve("SIGN_IN_REQUIRED");
+          if (!error && value.loggedIn === true) return resolve("READY");
+        } catch {
+          /* A missing or incompatible CLI is unavailable, never ready. */
+        }
+        resolve("UNAVAILABLE");
+      }
+    );
+  });
+}
+
 export function parseClaudeResult(stdout, request) {
   const result = JSON.parse(stdout);
   const models = Object.keys(result.modelUsage ?? {});
@@ -314,14 +350,36 @@ export function startClaudeRun(
 export function createClaudeRunsApi({
   token,
   connection,
-  execute = (request) =>
-    startClaudeRun(request, { root: connection.localRoot }),
+  execute = (request) => {
+    let activeRun;
+    let stopped = false;
+    return {
+      promise: (async () => {
+        const state = await checkAuthentication();
+        if (stopped) throw new Error("claude_runs_cancelled");
+        if (state !== "READY")
+          throw new Error(
+            state === "SIGN_IN_REQUIRED"
+              ? "claude_runs_sign_in_required"
+              : "claude_runs_auth_check_unavailable"
+          );
+        activeRun = startClaudeRun(request, { root: connection.localRoot });
+        return activeRun.promise;
+      })(),
+      stop() {
+        stopped = true;
+        activeRun?.stop();
+      },
+    };
+  },
   audit = () => {},
   maxConcurrency = 2,
   // Tool lanes (replies, follow-ups) have their own slots so a batch of
   // openers can never crowd them out.
   maxToolConcurrency = 2,
   toolLanes = null,
+  checkAuthentication = () =>
+    readClaudeAuthentication({ root: connection.localRoot }),
 } = {}) {
   if (!/^[a-f0-9]{64}$/.test(token ?? ""))
     throw new Error("claude_runs_key_rejected");
@@ -403,9 +461,13 @@ export function createClaudeRunsApi({
       req.headers["x-sellable-agent-id"] !== connection.agentId
     )
       return json(res, 403, { error: "claude_runs_scope_rejected" });
-    if (req.method === "GET" && req.url === "/health")
+    if (req.method === "GET" && req.url === "/health") {
+      const authentication = await checkAuthentication().catch(
+        () => "UNAVAILABLE"
+      );
       return json(res, 200, {
-        ok: true,
+        ok: authentication === "READY",
+        authentication,
         provider: "claude-code",
         active: inFlight.plain + inFlight.tools,
         toolActive: inFlight.tools,
@@ -414,6 +476,7 @@ export function createClaudeRunsApi({
           agentId: connection.agentId,
         },
       });
+    }
     if (req.method === "POST" && req.url === "/v1/runs") {
       if (full("plain") && (!connection.toolEndpointIds || full("tools")))
         return json(res, 429, { error: "claude_runs_busy" });
@@ -471,7 +534,15 @@ export function createClaudeRunsApi({
                   : "run.failed",
                 run.stopping && error.message === "claude_runs_cancelled"
                   ? { status: "cancelled" }
-                  : { status: "failed", error: "claude_runs_generation_failed" }
+                  : {
+                      status: "failed",
+                      error: [
+                        "claude_runs_sign_in_required",
+                        "claude_runs_auth_check_unavailable",
+                      ].includes(error.message)
+                        ? error.message
+                        : "claude_runs_generation_failed",
+                    }
               )
           )
           .finally(() => inFlight[pool]--);

package/lib/sellable-agent/fly-customer-image/customer-runtime.mjs

@@ -126,7 +126,7 @@ const RUNTIME_GENERATION = Number(
 const BOOT_SESSION_ID = randomUUID();
 const HERMES_VERSION = process.env.SELLABLE_AGENT_HERMES_VERSION ?? "0.21.5";
 const INSTALLER_PACKAGE =
-  process.env.SELLABLE_AGENT_INSTALLER_PACKAGE ?? "@sellable/install@0.1.796";
+  process.env.SELLABLE_AGENT_INSTALLER_PACKAGE ?? "@sellable/install@0.1.797-wip.runtime-ux.20261004.2";
 const MCP_PACKAGE =
   process.env.SELLABLE_AGENT_MCP_PACKAGE ?? "@sellable/mcp@0.1.957";
 export const ENDPOINT_MAX_CONCURRENT_RUNS = 10;

package/lib/sellable-agent/fly-customer-image/endpoint-model-selection.d.mts

@@ -1,10 +1,13 @@
 export const ENDPOINT_MODEL_SELECTION_ALLOWLIST: Readonly<{
   openrouter: readonly [
     "anthropic/claude-opus-5.5",
+    "deepseek/deepseek-v4-flash-0731",
+    "openai/gpt-6-luna",
     "anthropic/claude-sonnet-5.5",
   ];
 }>;
 export const ENDPOINT_MODEL_REASONING_EFFORTS: readonly [
+  "none",
   "low",
   "medium",
   "high",
@@ -15,6 +18,7 @@ export type EndpointModelSelection = Readonly<{
   model: string;
   reasoningEffort: (typeof ENDPOINT_MODEL_REASONING_EFFORTS)[number];
   runsApiBaseUrl?: string;
+  fallbackPolicy?: "STOP" | "PRODUCT_DEFAULT";
 }>;
 export function normalizeRunsApiBaseUrl(value: unknown): string | null;
 export function compileEndpointModelSelection(

package/lib/sellable-agent/fly-customer-image/endpoint-model-selection.mjs

@@ -2,11 +2,15 @@
 // requested destination here; the runtime must also match a trusted connection.
 export const ENDPOINT_MODEL_SELECTION_ALLOWLIST = Object.freeze({
   openrouter: Object.freeze([
+    // Retained for existing saved selections; the UI shortlist excludes Opus.
     "anthropic/claude-opus-5.5",
+    "deepseek/deepseek-v4-flash-0731",
+    "openai/gpt-6-luna",
     "anthropic/claude-sonnet-5.5",
   ]),
 });
 export const ENDPOINT_MODEL_REASONING_EFFORTS = Object.freeze([
+  "none",
   "low",
   "medium",
   "high",
@@ -45,13 +49,22 @@ export function compileEndpointModelSelection(value) {
   if (value === undefined || value === null) return null;
   if (typeof value !== "object" || Array.isArray(value)) return "invalid";
   const custom = Object.hasOwn(value, "runsApiBaseUrl");
+  const hasFallbackPolicy = Object.hasOwn(value, "fallbackPolicy");
   if (
-    Object.keys(value).sort().join(",") !==
+    Object.keys(value)
+      .filter((key) => key !== "fallbackPolicy")
+      .sort()
+      .join(",") !==
     (custom
       ? "model,provider,reasoningEffort,runsApiBaseUrl"
       : "model,provider,reasoningEffort")
   )
     return "invalid";
+  if (
+    hasFallbackPolicy &&
+    !["STOP", "PRODUCT_DEFAULT"].includes(value.fallbackPolicy)
+  )
+    return "invalid";
   const { provider, model, reasoningEffort } = value;
   if (
     typeof provider !== "string" ||
@@ -80,5 +93,6 @@ export function compileEndpointModelSelection(value) {
     model,
     reasoningEffort,
     ...(custom ? { runsApiBaseUrl } : {}),
+    ...(hasFallbackPolicy ? { fallbackPolicy: value.fallbackPolicy } : {}),
   });
 }

package/lib/sellable-agent/fly-customer-image/hermes-runs-client.mjs

@@ -244,7 +244,7 @@ export function validateOpenerOutputContract(value) {
   return JSON.parse(stableJson(value));
 }
 
-function compileCreateBody(input, openerStage = false) {
+function compileCreateBody(input, openerStage = false, verification = false) {
   if (!exactObject(input)) throw new Error("hermes_runs_submit_rejected");
   const allowed = [
     "conversationHistory",
@@ -252,7 +252,7 @@ function compileCreateBody(input, openerStage = false) {
     "instructions",
     "correlation",
     "outputContract",
-    ...(openerStage ? [] : ["modelSelection"]),
+    ...(openerStage && !verification ? [] : ["modelSelection"]),
   ];
   if (Object.keys(input).some((key) => !allowed.includes(key))) {
     throw new Error("hermes_runs_submit_rejected");
@@ -624,8 +624,8 @@ export function createHermesRunsClient(options = {}) {
       signal: init.signal ?? AbortSignal.timeout(timeoutMs),
     });
   };
-  const submit = async (compiled, { signal } = {}, openerStage = false) => {
-    const body = compileCreateBody(compiled, openerStage);
+  const submit = async (compiled, { signal } = {}, openerStage = false, verification = false) => {
+    const body = compileCreateBody(compiled, openerStage, verification);
     let response;
     try {
       response = await request("/v1/runs", {
@@ -667,6 +667,8 @@ export function createHermesRunsClient(options = {}) {
   return Object.freeze({
     fixtureIdentity: HERMES_RUNS_FIXTURE_IDENTITY,
     submit: (compiled, options) => submit(compiled, options),
+    // Fixed operator verification uses the existing tool-free session policy.
+    submitVerification: (compiled, options) => submit(compiled, options, true, true),
     // Only this reserved session prefix receives the pinned tool-free bridge policy.
     submitOpenerStage: (compiled, options) => submit(compiled, options, true),
     async status(runId, { signal } = {}) {

package/lib/sellable-agent/fly-customer-image/openai-runs-client.d.mts

@@ -0,0 +1,7 @@
+import type { RunsApiConnection } from "./runs-api-connections.mjs";
+export function createOpenAiRunsClient(options: {
+  connection: RunsApiConnection;
+  responseSchema?: unknown;
+  modelSelection?: { provider: string; model: string; reasoningEffort: string };
+  fetchImpl?: typeof fetch;
+}): any;

package/lib/sellable-agent/fly-customer-image/openai-runs-client.mjs

@@ -0,0 +1,271 @@
+import { randomBytes } from "node:crypto";
+import { createHermesRunsClient } from "./hermes-runs-client.mjs";
+
+async function boundedJson(response) {
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("empty_response");
+  let size = 0;
+  const chunks = [];
+  try {
+    while (true) {
+      const value = await reader.read();
+      if (value.done) break;
+      size += value.value.byteLength;
+      if (size > 512 * 1024) {
+        await reader.cancel();
+        throw new Error("response_too_large");
+      }
+      chunks.push(value.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+
+/** Text/structured-output adapter. All calls remain on the approved origin;
+ * tools, retries and provider/model fallback are deliberately not synthesized.
+ * The existing native client still validates the normalized run lifecycle. */
+export function createOpenAiRunsClient({
+  connection,
+  responseSchema,
+  modelSelection,
+  fetchImpl = fetch,
+}) {
+  const runs = new Map();
+  const json = (value, status = 200) =>
+    new Response(JSON.stringify(value), {
+      status,
+      headers: { "content-type": "application/json" },
+    });
+  const bridge = async (url, init = {}) => {
+    const path = String(url).slice(connection.baseUrl.length);
+    if (path === "/v1/runs" && init.method === "POST") {
+      const request = JSON.parse(init.body);
+      if (
+        !request.model &&
+        modelSelection &&
+        request.session_id?.startsWith("sellable_opener_stage_")
+      ) {
+        request.provider = modelSelection.provider;
+        request.model = modelSelection.model;
+        request.model_options = {
+          ...request.model_options,
+          reasoning_effort: modelSelection.reasoningEffort,
+        };
+      }
+      const model = connection.models.find(
+        (item) =>
+          item.provider === request.provider &&
+          item.model === request.model &&
+          item.reasoningEfforts.includes(
+            request.model_options?.reasoning_effort
+          )
+      );
+      if (!model) return json({ error: "model_not_allowed" }, 403);
+      const run = {
+        run_id: `run_${randomBytes(16).toString("hex")}`,
+        status: "running",
+        controller: new AbortController(),
+      };
+      const schema =
+        request.model_options?.sellable_opener_output_contract?.schema ??
+        responseSchema;
+      const structured = schema && connection.structuredOutputs !== false;
+      const instructions =
+        structured || !schema
+          ? request.instructions
+          : `${request.instructions}\nReturn only JSON conforming to this schema:\n${JSON.stringify(schema)}`;
+      const history = (request.conversation_history ?? []).map(
+        ({ role, content }) => ({ role, content })
+      );
+      const effort = request.model_options?.reasoning_effort;
+      const responses = connection.protocol === "openai-responses";
+      const body = responses
+        ? {
+            model: request.model,
+            instructions,
+            input: [...history, { role: "user", content: request.input }],
+            stream: false,
+            store: false,
+            max_output_tokens: 4096,
+            ...(effort && effort !== "none" ? { reasoning: { effort } } : {}),
+            ...(structured
+              ? {
+                  text: {
+                    format: {
+                      type: "json_schema",
+                      name: "endpoint_output",
+                      strict: true,
+                      schema,
+                    },
+                  },
+                }
+              : {}),
+          }
+        : {
+            model: request.model,
+            messages: [
+              { role: "system", content: instructions },
+              ...history,
+              { role: "user", content: request.input },
+            ],
+            stream: false,
+            max_tokens: 4096,
+            ...(effort && effort !== "none"
+              ? { reasoning_effort: effort }
+              : {}),
+            ...(structured
+              ? {
+                  response_format: {
+                    type: "json_schema",
+                    json_schema: {
+                      name: "endpoint_output",
+                      strict: true,
+                      schema,
+                    },
+                  },
+                }
+              : {}),
+          };
+      runs.set(run.run_id, run);
+      run.promise = (async () => {
+        try {
+          const response = await fetchImpl(
+            `${connection.baseUrl}/${responses ? "responses" : "chat/completions"}`,
+            {
+              method: "POST",
+              headers: {
+                authorization: init.headers.authorization,
+                "content-type": "application/json",
+              },
+              body: JSON.stringify(body),
+              redirect: "error",
+              signal: AbortSignal.any([
+                run.controller.signal,
+                AbortSignal.timeout(750_000),
+              ]),
+            }
+          );
+          if (!response.ok)
+            throw new Error(
+              response.status === 401 || response.status === 403
+                ? "access_denied"
+                : "provider_unavailable"
+            );
+          const value = await boundedJson(response);
+          const output = responses
+            ? (value.output ?? [])
+                .filter((item) => item.type === "message")
+                .flatMap((item) => item.content ?? [])
+                .filter((item) => item.type === "output_text")
+                .map((item) => item.text)
+                .join("")
+            : value.choices?.[0]?.message?.content;
+          if (
+            typeof output !== "string" ||
+            !output.trim() ||
+            Buffer.byteLength(output) > 48 * 1024 ||
+            (responses
+              ? value.status !== "completed"
+              : value.choices?.[0]?.finish_reason !== "stop") ||
+            typeof value.model !== "string" ||
+            !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(value.model) ||
+            (value.model !== request.model &&
+              !new RegExp(
+                `^${request.model.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}-[0-9]{4}-?[0-9]{2}-?[0-9]{2}$`
+              ).test(value.model))
+          )
+            throw new Error("output_rejected");
+          Object.assign(run, {
+            status: "completed",
+            output,
+            runtime: { provider: request.provider, model: value.model },
+            usage: {
+              input_tokens:
+                value.usage?.input_tokens ?? value.usage?.prompt_tokens ?? 0,
+              output_tokens:
+                value.usage?.output_tokens ??
+                value.usage?.completion_tokens ??
+                0,
+            },
+          });
+        } catch (error) {
+          Object.assign(run, {
+            status: "failed",
+            error:
+              error.message === "access_denied"
+                ? "connection_access_denied"
+                : "connection_generation_failed",
+          });
+        }
+      })();
+      return json({ run_id: run.run_id, status: "started" }, 202);
+    }
+    const match = /^\/v1\/runs\/(run_[a-f0-9]{32})(?:\/(events|stop))?$/.exec(
+      path
+    );
+    const run = match && runs.get(match[1]);
+    if (!run) return json({ error: "run_missing" }, 404);
+    const snapshot = () => ({
+      run_id: run.run_id,
+      status: run.status,
+      ...(run.status === "completed"
+        ? { output: run.output, runtime: run.runtime, usage: run.usage }
+        : run.status === "failed"
+          ? { error: run.error }
+          : {}),
+    });
+    if (match[2] === "stop") {
+      run.controller.abort();
+      // Aborting HTTP cannot prove cancellation at a remote inference server.
+      return json({ error: "stop_uncertain" }, 409);
+    }
+    if (match[2] === "events") {
+      if (init.signal?.aborted) throw new Error("stream_aborted");
+      let closed = false;
+      let abort;
+      const cleanup = () => {
+        closed = true;
+        init.signal?.removeEventListener("abort", abort);
+      };
+      return new Response(
+        new ReadableStream({
+          start(controller) {
+            abort = () => {
+              if (!closed) {
+                cleanup();
+                controller.error(new Error("stream_aborted"));
+              }
+            };
+            init.signal?.addEventListener("abort", abort, { once: true });
+            if (init.signal?.aborted) {
+              abort();
+              return;
+            }
+            void run.promise.then(() => {
+              if (closed) return;
+              cleanup();
+              controller.enqueue(
+                new TextEncoder().encode(
+                  `data: ${JSON.stringify({ event: run.status === "completed" ? "run.completed" : "run.failed", timestamp: new Date().toISOString(), ...snapshot() })}\n\n`
+                )
+              );
+              controller.close();
+            });
+          },
+          cancel() {
+            cleanup();
+          },
+        }),
+        { headers: { "content-type": "text/event-stream" } }
+      );
+    }
+    return json(snapshot());
+  };
+  return createHermesRunsClient({
+    baseUrl: connection.baseUrl,
+    apiKeyFile: connection.apiKeyFile,
+    fetchImpl: bridge,
+  });
+}

package/lib/sellable-agent/fly-customer-image/runs-api-connections.d.mts

@@ -14,7 +14,11 @@ export type RunsApiConnection = Readonly<{
   }>;
   localRoot?: string;
   toolEndpointIds?: string[];
+  name?: string;
+  protocol?: "runs-api" | "openai-chat" | "openai-responses";
+  structuredOutputs?: boolean;
 }>;
+export function runsApiConnectionId(connection: RunsApiConnection): string;
 export function parseRunsApiConnections(raw: unknown): RunsApiConnection[];
 export function runsApiConnectionsForRuntime(
   raw: unknown,

package/lib/sellable-agent/fly-customer-image/runs-api-connections.mjs

@@ -4,6 +4,7 @@ import {
   normalizeRunsApiBaseUrl,
 } from "./endpoint-model-selection.mjs";
 import { createHermesRunsClient } from "./hermes-runs-client.mjs";
+import { createOpenAiRunsClient } from "./openai-runs-client.mjs";
 
 export const RUNS_API_CONNECTIONS_ENV =
   "SELLABLE_AGENT_RUNS_API_CONNECTIONS_JSON";
@@ -53,9 +54,21 @@ export function parseRunsApiConnections(raw) {
             "models",
             "localRoot",
             "toolEndpointIds",
+            "name",
+            "protocol",
+            "structuredOutputs",
           ].includes(key)
       ) ||
       ![entry.runtimeId, entry.workspaceId, entry.agentId].every(id) ||
+      (entry.protocol !== undefined &&
+        !["runs-api", "openai-chat", "openai-responses"].includes(
+          entry.protocol
+        )) ||
+      (entry.structuredOutputs !== undefined &&
+        typeof entry.structuredOutputs !== "boolean") ||
+      (entry.name !== undefined &&
+        (typeof entry.name !== "string" ||
+          !/^[\p{L}\p{N} .()_-]{1,80}$/u.test(entry.name))) ||
       typeof entry.apiKeyFile !== "string" ||
       !/^\/(?:opt\/data|run\/secrets)\/[A-Za-z0-9_./-]{1,250}$/.test(
         entry.apiKeyFile
@@ -105,6 +118,7 @@ export function parseRunsApiConnections(raw) {
     if (entry.localRoot !== undefined) {
       const url = new URL(baseUrl);
       if (
+        (entry.protocol !== undefined && entry.protocol !== "runs-api") ||
         typeof entry.localRoot !== "string" ||
         !/^\/opt\/data\/[A-Za-z0-9_-]{1,80}$/.test(entry.localRoot) ||
         entry.apiKeyFile !== `${entry.localRoot}/api-key` ||
@@ -150,6 +164,20 @@ export function parseRunsApiConnections(raw) {
   });
 }
 
+export function runsApiConnectionId(connection) {
+  return `runs_${createHash("sha256")
+    .update(
+      JSON.stringify([
+        connection.runtimeId,
+        connection.workspaceId,
+        connection.agentId,
+        connection.baseUrl,
+      ])
+    )
+    .digest("hex")
+    .slice(0, 24)}`;
+}
+
 export function runsApiConnectionsForRuntime(raw, runtime) {
   return parseRunsApiConnections(raw).filter(
     (connection) =>
@@ -194,14 +222,20 @@ export function createConfiguredRunsClient({
     throw new Error("runs_api_connection_not_authorized");
   // This client instance retains one destination and one credential for the
   // entire attempt, including stream/status/stop, even if settings later change.
-  const client = clientFactory({
-    baseUrl: connection.baseUrl,
-    apiKeyFile: connection.apiKeyFile,
-    scopeHeaders: {
-      "x-sellable-workspace-id": connection.workspaceId,
-      "x-sellable-agent-id": connection.agentId,
-    },
-  });
+  const client = connection.protocol?.startsWith("openai-")
+    ? createOpenAiRunsClient({
+        connection,
+        responseSchema: claim.revision?.outputSchema,
+        modelSelection: model,
+      })
+    : clientFactory({
+        baseUrl: connection.baseUrl,
+        apiKeyFile: connection.apiKeyFile,
+        scopeHeaders: {
+          "x-sellable-workspace-id": connection.workspaceId,
+          "x-sellable-agent-id": connection.agentId,
+        },
+      });
   return Object.freeze({
     ...client,
     submit(compiled, options) {

package/lib/sellable-agent/fly-customer-image/runs-api-health-check.d.mts

@@ -0,0 +1,9 @@
+export function checkRunsApiConnection(
+  request: any,
+  options?: any
+): Promise<{ connectionId: string; state: string; checkedAt: string }>;
+
+export function verifyRunsApiSelection(
+  request: any,
+  options?: any
+): Promise<any>;

package/lib/sellable-agent/fly-customer-image/runs-api-health-check.mjs

@@ -0,0 +1,261 @@
+import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { compileEndpointModelSelection } from "./endpoint-model-selection.mjs";
+import { createHermesRunsClient } from "./hermes-runs-client.mjs";
+import {
+  createConfiguredRunsClient,
+  RUNS_API_CONNECTIONS_ENV,
+  runsApiConnectionId,
+  runsApiConnectionsForRuntime,
+} from "./runs-api-connections.mjs";
+
+// Fixed read-only machine command. Callers supply identities, never a URL,
+// credential path, shell command, or prompt. The installed registry authorizes
+// the destination again on the machine before a credential is read.
+export async function checkRunsApiConnection(
+  request,
+  {
+    env = process.env,
+    fetchImpl = fetch,
+    readToken = (path) => readFile(path, "utf8"),
+  } = {}
+) {
+  const checkedAt = new Date().toISOString();
+  const result = (state) => ({
+    connectionId: request.connectionId,
+    state,
+    checkedAt,
+  });
+  if (request.runtimeId !== env.SELLABLE_RUNTIME_ID)
+    return result("NOT_CONFIGURED");
+  const connection = runsApiConnectionsForRuntime(
+    env[RUNS_API_CONNECTIONS_ENV],
+    request
+  ).find(
+    (candidate) =>
+      runsApiConnectionId(candidate) === request.connectionId &&
+      candidate.endpointIds.includes(request.endpointId)
+  );
+  if (!connection) return result("NOT_CONFIGURED");
+  try {
+    const token = (await readToken(connection.apiKeyFile)).trim();
+    if (!token || token.length > 8192 || /[\r\n]/.test(token))
+      return result("UNAVAILABLE");
+    const response = await fetchImpl(
+      `${connection.baseUrl}/${connection.protocol?.startsWith("openai-") ? "models" : "health"}`,
+      {
+        headers: {
+          authorization: `Bearer ${token}`,
+          ...(connection.protocol?.startsWith("openai-") ? {} : {
+            "x-sellable-workspace-id": connection.workspaceId,
+            "x-sellable-agent-id": connection.agentId,
+          }),
+        },
+        redirect: "error",
+        signal: AbortSignal.timeout(12_000),
+      }
+    );
+    if (response.status === 401 || response.status === 403)
+      return result("ACCESS_DENIED");
+    if (!response.ok) return result("UNAVAILABLE");
+    const reader = response.body?.getReader();
+    if (!reader) return result("UNAVAILABLE");
+    let text = "";
+    let size = 0;
+    try {
+      const decoder = new TextDecoder();
+      while (true) {
+        const chunk = await reader.read();
+        if (chunk.done) break;
+        size += chunk.value.byteLength;
+        if (size > 16_384) {
+          await reader.cancel();
+          return result("UNAVAILABLE");
+        }
+        text += decoder.decode(chunk.value, { stream: true });
+      }
+      text += decoder.decode();
+    } finally {
+      reader.releaseLock();
+    }
+    const health = JSON.parse(text);
+    if (connection.localRoot) {
+      if (
+        health.provider !== "claude-code" ||
+        health.scope?.workspaceId !== connection.workspaceId ||
+        health.scope?.agentId !== connection.agentId
+      )
+        return result("ACCESS_DENIED");
+      if (health.authentication === "SIGN_IN_REQUIRED")
+        return result("SIGN_IN_REQUIRED");
+      return result(
+        health.authentication === "READY" && health.ok === true
+          ? "READY"
+          : "UNAVAILABLE"
+      );
+    }
+    return result(
+      (
+        connection.protocol?.startsWith("openai-")
+          ? Array.isArray(health.data)
+          : health.ok === true
+      )
+        ? "REACHABLE"
+        : "UNAVAILABLE"
+    );
+  } catch {
+    return result("UNAVAILABLE");
+  }
+}
+
+export async function verifyRunsApiSelection(
+  request,
+  {
+    env = process.env,
+    makeDefaultClient = createHermesRunsClient,
+    makeConfiguredClient = createConfiguredRunsClient,
+    health = checkRunsApiConnection,
+  } = {}
+) {
+  const result = (state, servedRuntime) => ({
+    connectionId: request.connectionId,
+    state,
+    checkedAt: new Date().toISOString(),
+    ...(servedRuntime ? { servedRuntime } : {}),
+  });
+  if (
+    request.runtimeId !== env.SELLABLE_RUNTIME_ID ||
+    !/^[A-Za-z0-9_-]{1,128}$/.test(request.profileId ?? "")
+  )
+    return result("NOT_CONFIGURED");
+  const selection = compileEndpointModelSelection(request.modelSelection);
+  if (selection === "invalid") return result("NOT_CONFIGURED");
+  let verificationWorkKind = "STANDARD";
+  if (selection?.runsApiBaseUrl) {
+    const connection = runsApiConnectionsForRuntime(
+      env[RUNS_API_CONNECTIONS_ENV],
+      request
+    ).find(
+      (item) =>
+        runsApiConnectionId(item) === request.connectionId &&
+        item.baseUrl === selection.runsApiBaseUrl
+    );
+    if (!connection?.endpointIds.includes(request.endpointId))
+      return result("NOT_CONFIGURED");
+    verificationWorkKind = connection.workKinds.includes("STANDARD")
+      ? "STANDARD"
+      : connection.workKinds[0];
+    if (connection.localRoot) {
+      const readiness = await health(request, { env });
+      if (readiness.state !== "READY") return readiness;
+    }
+  } else if (request.connectionId !== (selection ? "openrouter" : "default"))
+    return result("NOT_CONFIGURED");
+  const apiKeyFile =
+    env.SELLABLE_AGENT_SERVER_AUTHENTICATED_KIND === "ADMIN"
+      ? "/run/sellable-agent/admin-runtime/api-server-key"
+      : `/run/sellable-agent/${request.profileId}/api-server-key`;
+  let client;
+  let run;
+  try {
+    client = selection?.runsApiBaseUrl
+      ? makeConfiguredClient({
+          apiKeyFile,
+          env,
+          claim: {
+            runtime: { runtimeId: request.runtimeId },
+            attempt: {
+              workspaceId: request.workspaceId,
+              agentId: request.agentId,
+              endpointId: request.endpointId,
+            },
+            run: {
+              modelSelection: selection,
+              productExecution: { workKind: verificationWorkKind },
+            },
+          },
+        })
+      : makeDefaultClient({ apiKeyFile });
+    const compiled = {
+      input: "Connection verification. Reply with SELLABLE_CONNECTION_OK.",
+      instructions:
+        "This is a connection check. Do not use tools or take actions. Return exactly SELLABLE_CONNECTION_OK and nothing else.",
+      conversationHistory: [],
+      correlation: `connection-check-${randomUUID()}`,
+      ...(selection ? { modelSelection: selection } : {}),
+    };
+    const signal = AbortSignal.timeout(70_000);
+    // Default Hermes gets the tool-free verification prefix. A Runs service
+    // owns its own tool policy; the Claude and OpenAI adapters are tool-free.
+    run = await (
+      selection?.runsApiBaseUrl ? client.submit : client.submitVerification
+    )(compiled, { signal });
+    await client.streamEvents(run.runId, { signal, onEvent: async () => {} });
+    const status = await client.status(run.runId, { signal });
+    const served = status.servedRuntime;
+    if (
+      status.status !== "completed" ||
+      typeof status.output !== "string" ||
+      status.output.trim() !== "SELLABLE_CONNECTION_OK" ||
+      !served
+    )
+      return result("UNAVAILABLE");
+    if (
+      selection &&
+      (served.provider !== selection.provider ||
+        (served.model !== selection.model &&
+          !served.model.startsWith(`${selection.model}-`)))
+    )
+      return result("UNAVAILABLE");
+    return result("READY", served);
+  } catch {
+    if (client && run)
+      await client
+        .stop(run.runId, { signal: AbortSignal.timeout(3_000) })
+        .catch(() => {});
+    return result("UNAVAILABLE");
+  }
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(process.argv[1]).href
+) {
+  try {
+    const raw = process.argv[2];
+    if (!raw || raw.length > 4096) throw new Error();
+    const request = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
+    const verify = request.action === "VERIFY";
+    if (
+      Object.keys(request)
+        .filter(
+          (key) => !["action", "profileId", "modelSelection"].includes(key)
+        )
+        .sort()
+        .join(",") !==
+        "agentId,connectionId,endpointId,runtimeId,workspaceId" ||
+      [
+        request.agentId,
+        request.connectionId,
+        request.endpointId,
+        request.runtimeId,
+        request.workspaceId,
+      ].some(
+        (value) =>
+          typeof value !== "string" || !/^[A-Za-z0-9_.:-]{1,128}$/.test(value)
+      ) ||
+      (request.action !== undefined && !verify)
+    )
+      throw new Error();
+    process.stdout.write(
+      JSON.stringify(
+        await (verify
+          ? verifyRunsApiSelection(request)
+          : checkRunsApiConnection(request))
+      )
+    );
+  } catch {
+    process.exitCode = 1;
+  }
+}

package/lib/sellable-agent/host-bootstrap.mjs

@@ -38,7 +38,7 @@ import { installAgentHostServices } from "./service-installer.mjs";
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
 const VERSION = "sellable-agent-host-bootstrap/v1";
 const RECEIPT_VERSION = "sellable-agent-host-registration/v1";
-const INSTALLER_PACKAGE = "@sellable/install@0.1.796";
+const INSTALLER_PACKAGE = "@sellable/install@0.1.797-wip.runtime-ux.20261004.2";
 const MCP_PACKAGE = "@sellable/mcp@0.1.957";
 const HERMES_VERSION = "0.18.0";
 const SHA256 = /^[a-f0-9]{64}$/;

package/lib/sellable-agent/host-worker.mjs

@@ -1546,7 +1546,7 @@ export function compileClaimToProfileDesired(activeClaim, config) {
       ]) ||
       pinned.hermesCli !== "hermes" ||
       pinned.hermesVersion !== "0.18.0" ||
-      pinned.installerPackage !== "@sellable/install@0.1.796" ||
+      pinned.installerPackage !== "@sellable/install@0.1.797-wip.runtime-ux.20261004.2" ||
       pinned.mcpPackage !== "@sellable/mcp@0.1.957" ||
       !Array.isArray(policy.toolInclude) ||
       policy.toolInclude.length === 0 ||

package/lib/sellable-agent/profile-materializer.mjs

@@ -312,7 +312,7 @@ function validateDesired(desired) {
     desired.serviceCredentialGeneration < 1 ||
     desired.hermesCli !== "hermes" ||
     desired.hermesVersion !== "0.18.0" ||
-    desired.installerPackage !== "@sellable/install@0.1.796" ||
+    desired.installerPackage !== "@sellable/install@0.1.797-wip.runtime-ux.20261004.2" ||
     desired.mcpPackage !== "@sellable/mcp@0.1.957" ||
     !Array.isArray(desired.toolInclude) ||
     desired.toolInclude.length === 0 ||

package/lib/sellable-agent/provisioning-adapter.mjs

@@ -25,7 +25,7 @@ import { fileURLToPath } from "node:url";
 import { deriveContainedProfileId } from "./profile-materializer.mjs";
 
 export const PROVISIONING_ACTION = "PROVISION_HERMES_PROFILE";
-export const PINNED_INSTALL_PACKAGE = "@sellable/install@0.1.796";
+export const PINNED_INSTALL_PACKAGE = "@sellable/install@0.1.797-wip.runtime-ux.20261004.2";
 export const PINNED_MCP_PACKAGE = "@sellable/mcp@0.1.957";
 const PINNED_INSTALL_VERSION = PINNED_INSTALL_PACKAGE.slice(
   PINNED_INSTALL_PACKAGE.lastIndexOf("@") + 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/install",
-  "version": "0.1.796",
+  "version": "0.1.797-wip.runtime-ux.20261004.2",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code, Codex, and Hermes",
   "bin": {