@sellable/install 0.1.794 → 0.1.795-wip.runtime-ux.20261004.1

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

@@ -0,0 +1,98 @@
+// Shared by the control plane and the runtime. A custom Runs API is only a
+// 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",
+  "xhigh",
+]);
+
+export function normalizeRunsApiBaseUrl(value) {
+  if (
+    typeof value !== "string" ||
+    value.length > 1_024 ||
+    value !== value.trim()
+  )
+    return null;
+  try {
+    const url = new URL(value);
+    if (
+      url.username ||
+      url.password ||
+      url.search ||
+      url.hash ||
+      /[\\\s]/.test(value) ||
+      (url.protocol !== "https:" &&
+        !(
+          url.protocol === "http:" &&
+          ["127.0.0.1", "[::1]"].includes(url.hostname)
+        ))
+    )
+      return null;
+    return `${url.origin}${url.pathname.replace(/\/$/, "")}`;
+  } catch {
+    return null;
+  }
+}
+
+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)
+      .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" ||
+    typeof model !== "string" ||
+    !ENDPOINT_MODEL_REASONING_EFFORTS.includes(reasoningEffort)
+  )
+    return "invalid";
+  if (
+    !custom &&
+    (!Object.hasOwn(ENDPOINT_MODEL_SELECTION_ALLOWLIST, provider) ||
+      !ENDPOINT_MODEL_SELECTION_ALLOWLIST[provider].includes(model))
+  )
+    return "invalid";
+  const runsApiBaseUrl = custom
+    ? normalizeRunsApiBaseUrl(value.runsApiBaseUrl)
+    : null;
+  if (
+    custom &&
+    (!runsApiBaseUrl ||
+      !/^[a-z][a-z0-9_-]{0,63}$/.test(provider) ||
+      !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}$/.test(model))
+  )
+    return "invalid";
+  return Object.freeze({
+    provider,
+    model,
+    reasoningEffort,
+    ...(custom ? { runsApiBaseUrl } : {}),
+    ...(hasFallbackPolicy ? { fallbackPolicy: value.fallbackPolicy } : {}),
+  });
+}

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

@@ -7,6 +7,11 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname, isAbsolute } from "node:path";
+import {
+  compileEndpointModelSelection,
+  normalizeRunsApiBaseUrl,
+} from "./endpoint-model-selection.mjs";
+export { ENDPOINT_MODEL_SELECTION_ALLOWLIST } from "./endpoint-model-selection.mjs";
 
 const LOOPBACK_ORIGIN = "http://127.0.0.1:8642";
 const RUN_ID = /^run_[a-f0-9]{32}$/;
@@ -206,37 +211,12 @@ function canonicalHistory(value) {
   return result;
 }
 
-// The models a caller may name for one endpoint run. The server checks the
-// same list before it hands the run over; the runtime checks it again here so
-// a run can never reach Hermes with a model that was not reviewed.
-export const ENDPOINT_MODEL_SELECTION_ALLOWLIST = Object.freeze({
-  openrouter: Object.freeze([
-    "anthropic/claude-opus-5.5",
-    "anthropic/claude-sonnet-5.5",
-  ]),
-});
-const ENDPOINT_MODEL_REASONING_EFFORTS = Object.freeze([
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-]);
-
 export function validateEndpointModelSelection(value) {
-  if (
-    !exactObject(value) ||
-    Object.keys(value).sort().join(",") !== "model,provider,reasoningEffort" ||
-    !Object.hasOwn(ENDPOINT_MODEL_SELECTION_ALLOWLIST, value.provider) ||
-    !ENDPOINT_MODEL_SELECTION_ALLOWLIST[value.provider].includes(value.model) ||
-    !ENDPOINT_MODEL_REASONING_EFFORTS.includes(value.reasoningEffort)
-  ) {
+  const compiled = compileEndpointModelSelection(value);
+  if (!compiled || compiled === "invalid") {
     throw new Error("hermes_runs_model_selection_rejected");
   }
-  return Object.freeze({
-    provider: value.provider,
-    model: value.model,
-    reasoningEffort: value.reasoningEffort,
-  });
+  return compiled;
 }
 
 export function validateOpenerOutputContract(value) {
@@ -264,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",
@@ -272,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");
@@ -606,12 +586,19 @@ function submitNotAdmitted(response, value) {
 export function createHermesRunsClient(options = {}) {
   const {
     apiKeyFile,
+    baseUrl = LOOPBACK_ORIGIN,
+    scopeHeaders = {},
     fixture,
     fetchImpl = fetch,
     timeoutMs = 20_000,
   } = options;
   assertFixture(fixture);
+  const origin = normalizeRunsApiBaseUrl(baseUrl);
   if (
+    !origin ||
+    !exactObject(scopeHeaders) ||
+    Object.keys(scopeHeaders).some(key => !["x-sellable-workspace-id", "x-sellable-agent-id"].includes(key)) ||
+    Object.values(scopeHeaders).some(value => typeof value !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(value)) ||
     typeof fetchImpl !== "function" ||
     !Number.isSafeInteger(timeoutMs) ||
     timeoutMs < 100 ||
@@ -624,9 +611,11 @@ export function createHermesRunsClient(options = {}) {
     if (!path.startsWith("/v1/runs")) {
       throw new Error("hermes_runs_path_rejected");
     }
-    return fetchImpl(`${LOOPBACK_ORIGIN}${path}`, {
+    return fetchImpl(`${origin}${path}`, {
       ...init,
+      redirect: "error",
       headers: {
+        ...scopeHeaders,
         authorization: `Bearer ${apiKey}`,
         ...(init.body === undefined
           ? {}
@@ -635,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", {
@@ -678,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

@@ -0,0 +1,30 @@
+export const RUNS_API_CONNECTIONS_ENV: "SELLABLE_AGENT_RUNS_API_CONNECTIONS_JSON";
+export type RunsApiConnection = Readonly<{
+  runtimeId: string;
+  workspaceId: string;
+  agentId: string;
+  baseUrl: string;
+  apiKeyFile: string;
+  endpointIds: string[];
+  workKinds: Array<"STANDARD" | "OPENER" | "REPLY" | "FOLLOW_UP">;
+  models: Array<{
+    provider: string;
+    model: string;
+    reasoningEfforts: string[];
+  }>;
+  localRoot?: 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,
+  runtime: {
+    runtimeId: string;
+    workspaceId: string;
+    agentId: string;
+  }
+): RunsApiConnection[];
+export function createConfiguredRunsClient(options: any): any;