@sellable/install 0.1.810 → 0.1.813

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

@@ -1,5 +1,5 @@
-// 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.
+// Shared by the control plane and the runtime. A custom Runs API step always
+// names the workspace model connection that serves it.
 export const ENDPOINT_MODEL_SELECTION_ALLOWLIST = Object.freeze({
   openrouter: Object.freeze([
     // Retained for existing saved selections; the UI shortlist excludes Opus.
@@ -49,25 +49,22 @@ export function normalizeRunsApiBaseUrl(value) {
   }
 }
 
-// One model: provider, model, effort and, for a custom Runs API, its URL.
-// A custom step may also name the workspace's own model connection
-// (modelConnectionId), which is always https. Skew: an older runtime refuses
-// that unknown key as "invalid", so Verify & save refuses a connection step
-// on a machine that cannot fetch its key per attempt.
+// One model: provider, model, effort and, for a custom Runs API, its URL and
+// the workspace's own model connection (modelConnectionId), always https.
+// Skew: an older runtime refuses that unknown key as "invalid", so Verify &
+// save refuses a connection step on a machine that cannot fetch its key per
+// attempt.
 function compileEndpointModelStep(value, extraKeys = []) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const custom = Object.hasOwn(value, "runsApiBaseUrl");
-  const connection = Object.hasOwn(value, "modelConnectionId");
   if (
     Object.keys(value)
       .filter((key) => !extraKeys.includes(key))
       .sort()
       .join(",") !==
-    (connection
+    (custom
       ? "model,modelConnectionId,provider,reasoningEffort,runsApiBaseUrl"
-      : custom
-        ? "model,provider,reasoningEffort,runsApiBaseUrl"
-        : "model,provider,reasoningEffort")
+      : "model,provider,reasoningEffort")
   )
     return null;
   const { provider, model, reasoningEffort } = value;
@@ -95,7 +92,7 @@ function compileEndpointModelStep(value, extraKeys = []) {
     return null;
   const { modelConnectionId } = value;
   if (
-    connection &&
+    custom &&
     (typeof modelConnectionId !== "string" ||
       !/^[A-Za-z0-9_-]{1,128}$/.test(modelConnectionId) ||
       !runsApiBaseUrl.startsWith("https://"))
@@ -105,8 +102,7 @@ function compileEndpointModelStep(value, extraKeys = []) {
     provider,
     model,
     reasoningEffort,
-    ...(custom ? { runsApiBaseUrl } : {}),
-    ...(connection ? { modelConnectionId } : {}),
+    ...(custom ? { runsApiBaseUrl, modelConnectionId } : {}),
   });
 }
 

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

@@ -1,36 +1,12 @@
-export const RUNS_API_CONNECTIONS_ENV: "SELLABLE_AGENT_RUNS_API_CONNECTIONS_JSON";
+/** The connection fields the OpenAI-protocol Runs adapter reads. */
 export type RunsApiConnection = Readonly<{
-  runtimeId: string;
-  workspaceId: string;
-  agentId: string;
   baseUrl: string;
-  apiKeyFile: string;
-  /** Absent: serves every endpoint of its agent. */
-  endpointIds?: string[];
-  workKinds: Array<"STANDARD" | "OPENER" | "REPLY" | "FOLLOW_UP">;
   models: Array<{
     provider: string;
     model: string;
     reasoningEfforts: string[];
   }>;
-  localRoot?: string;
-  toolEndpointIds?: string[];
-  name?: string;
   protocol?: "runs-api" | "openai-chat" | "openai-responses";
   structuredOutputs?: boolean;
 }>;
-export function runsApiConnectionId(connection: RunsApiConnection): string;
-export function runsApiConnectionServesEndpoint(
-  connection: RunsApiConnection,
-  endpointId: string
-): boolean;
-export function parseRunsApiConnections(raw: unknown): RunsApiConnection[];
-export function runsApiConnectionsForRuntime(
-  raw: unknown,
-  runtime: {
-    runtimeId: string;
-    workspaceId: string;
-    agentId: string;
-  }
-): RunsApiConnection[];
 export function createConfiguredRunsClient(options: any): Promise<any>;

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

@@ -1,17 +1,9 @@
 import { createHash } from "node:crypto";
-import {
-  compileEndpointModelSelection,
-  normalizeRunsApiBaseUrl,
-} from "./endpoint-model-selection.mjs";
+import { compileEndpointModelSelection } from "./endpoint-model-selection.mjs";
 import { createHermesRunsClient } from "./hermes-runs-client.mjs";
-import { createOpenAiRunsClient } from "./openai-runs-client.mjs";
 import { createPinnedFetch } from "./public-endpoint-guard.mjs";
 import { createWorkspaceConnectionRunsClient } from "./workspace-connection-client.mjs";
 
-export const RUNS_API_CONNECTIONS_ENV =
-  "SELLABLE_AGENT_RUNS_API_CONNECTIONS_JSON";
-const id = (value) =>
-  typeof value === "string" && /^[A-Za-z0-9_.:-]{1,128}$/.test(value);
 const record = (value) =>
   value && typeof value === "object" && !Array.isArray(value);
 const stable = (value) =>
@@ -23,187 +15,6 @@ const stable = (value) =>
           .map((key) => `${JSON.stringify(key)}:${stable(value[key])}`)
           .join(",")}}`
       : JSON.stringify(value);
-const fail = () => {
-  throw new Error("runs_api_connection_configuration_rejected");
-};
-
-// Only the control plane's machine configuration supplies this registry. It
-// contains credential file references, never credentials or request input.
-export function parseRunsApiConnections(raw) {
-  if (raw === undefined || raw === "") return [];
-  if (typeof raw !== "string" || Buffer.byteLength(raw) > 64 * 1024) fail();
-  let entries;
-  try {
-    entries = JSON.parse(raw);
-  } catch {
-    fail();
-  }
-  if (!Array.isArray(entries) || entries.length > 32) fail();
-  const seen = new Set();
-  return entries.map((entry) => {
-    if (
-      !record(entry) ||
-      Object.keys(entry).some(
-        (key) =>
-          ![
-            "runtimeId",
-            "workspaceId",
-            "agentId",
-            "baseUrl",
-            "apiKeyFile",
-            "endpointIds",
-            "workKinds",
-            "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
-      ) ||
-      entry.apiKeyFile
-        .split("/")
-        .some((part) => part === "." || part === "..") ||
-      // Absent: the connection serves every endpoint of its agent.
-      (entry.endpointIds !== undefined &&
-        (!Array.isArray(entry.endpointIds) ||
-          !entry.endpointIds.length ||
-          entry.endpointIds.length > 64 ||
-          !entry.endpointIds.every(id))) ||
-      !Array.isArray(entry.workKinds) ||
-      !entry.workKinds.length ||
-      !entry.workKinds.every((kind) =>
-        ["STANDARD", "OPENER", "REPLY", "FOLLOW_UP"].includes(kind)
-      ) ||
-      !Array.isArray(entry.models) ||
-      !entry.models.length ||
-      entry.models.length > 16
-    )
-      fail();
-    const baseUrl = normalizeRunsApiBaseUrl(entry.baseUrl);
-    if (!baseUrl) fail();
-    const identity = `${entry.runtimeId}:${baseUrl}`;
-    if (seen.has(identity)) fail();
-    seen.add(identity);
-    const models = entry.models.map((model) => {
-      if (
-        !record(model) ||
-        Object.keys(model).sort().join(",") !==
-          "model,provider,reasoningEfforts" ||
-        !Array.isArray(model.reasoningEfforts) ||
-        !model.reasoningEfforts.length ||
-        model.reasoningEfforts.some(
-          (reasoningEffort) =>
-            compileEndpointModelSelection({
-              provider: model.provider,
-              model: model.model,
-              reasoningEffort,
-              runsApiBaseUrl: baseUrl,
-            }) === "invalid"
-        )
-      )
-        fail();
-      return { ...model, reasoningEfforts: [...model.reasoningEfforts] };
-    });
-    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` ||
-        url.hostname !== "127.0.0.1" ||
-        url.protocol !== "http:" ||
-        url.pathname !== "/" ||
-        !url.port ||
-        Number(url.port) < 1024 ||
-        models.some(
-          (model) =>
-            model.provider !== "claude-code" ||
-            !/^claude-[a-z0-9-]{1,100}$/.test(model.model) ||
-            model.reasoningEfforts.some(
-              (effort) => !["low", "medium", "high"].includes(effort)
-            )
-        )
-      )
-        fail();
-    }
-    // When present, only runs on these endpoints get their own allowed tools
-    // from the image-owned service. When absent, a run gets the tools its own
-    // signed turn descriptor allows, and a run allowed none stays tool-free.
-    if (
-      entry.toolEndpointIds !== undefined &&
-      (entry.localRoot === undefined ||
-        !Array.isArray(entry.toolEndpointIds) ||
-        !entry.toolEndpointIds.length ||
-        !entry.toolEndpointIds.every(id) ||
-        new Set(entry.toolEndpointIds).size !== entry.toolEndpointIds.length ||
-        (entry.endpointIds !== undefined &&
-          entry.toolEndpointIds.some(
-            (value) => !entry.endpointIds.includes(value)
-          )))
-    )
-      fail();
-    return Object.freeze({
-      ...entry,
-      baseUrl,
-      models,
-      ...(entry.endpointIds === undefined
-        ? {}
-        : { endpointIds: [...entry.endpointIds] }),
-      workKinds: [...entry.workKinds],
-      ...(entry.toolEndpointIds === undefined
-        ? {}
-        : { toolEndpointIds: [...entry.toolEndpointIds] }),
-    });
-  });
-}
-
-/** Whether a trusted connection may serve runs of this endpoint. */
-export function runsApiConnectionServesEndpoint(connection, endpointId) {
-  return (
-    connection.endpointIds === undefined ||
-    connection.endpointIds.includes(endpointId)
-  );
-}
-
-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) =>
-      connection.runtimeId === runtime.runtimeId &&
-      connection.workspaceId === runtime.workspaceId &&
-      connection.agentId === runtime.agentId
-  );
-}
-
 // Exactly the members the endpoint-connection-key verb returns. The key follows
 // the saved key's rule (16-1024 characters), never the key-file rule; the
 // remote tool's values are checked where the create body is built.
@@ -260,17 +71,15 @@ function customRunsClient(client, claim, remoteTools) {
 export async function createConfiguredRunsClient({
   apiKeyFile,
   claim,
-  env = process.env,
   clientFactory = createHermesRunsClient,
   fetchConnectionKey,
   chainStep = 0,
   createFetch = createPinnedFetch,
 }) {
   const selection = claim?.run?.modelSelection;
-  // A workspace connection never uses the registry, even on a matching URL:
-  // its key is fetched for this attempt and lives only in these closures, and
-  // every request goes through the address guard. URL and model come from
-  // the signed claim, never from the key response.
+  // A workspace connection's key is fetched for this attempt and lives only in
+  // these closures, and every request goes through the address guard. URL and
+  // model come from the signed claim, never from the key response.
   if (selection?.modelConnectionId) {
     const step = compileEndpointModelSelection(selection);
     if (!step || step === "invalid") throw new Error("runs_api_model_rejected");
@@ -305,46 +114,9 @@ export async function createConfiguredRunsClient({
       }
     );
   }
-  if (!selection?.runsApiBaseUrl) return clientFactory({ apiKeyFile });
-  const model = compileEndpointModelSelection(selection);
-  if (!model || model === "invalid") throw new Error("runs_api_model_rejected");
-  const connection = runsApiConnectionsForRuntime(
-    env[RUNS_API_CONNECTIONS_ENV],
-    {
-      runtimeId: claim.runtime?.runtimeId,
-      workspaceId: claim.attempt?.workspaceId,
-      agentId: claim.attempt?.agentId,
-    }
-  ).find((value) => value.baseUrl === model.runsApiBaseUrl);
-  const workKind = claim.run.productExecution?.workKind ?? "STANDARD";
-  if (
-    !connection ||
-    env.SELLABLE_RUNTIME_ID !== connection.runtimeId ||
-    !runsApiConnectionServesEndpoint(connection, claim.attempt.endpointId) ||
-    !connection.workKinds.includes(workKind) ||
-    !connection.models.some(
-      (allowed) =>
-        allowed.provider === model.provider &&
-        allowed.model === model.model &&
-        allowed.reasoningEfforts.includes(model.reasoningEffort)
-    )
-  )
-    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 = 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 customRunsClient(client, claim);
+  // A custom URL is served only through a workspace connection: no other
+  // client, credential or socket is opened for it.
+  if (selection?.runsApiBaseUrl)
+    throw new Error("runs_api_connection_unavailable");
+  return clientFactory({ apiKeyFile });
 }

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

@@ -1,4 +1,3 @@
-import { readFile } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import {
   compileEndpointModelSelection,
@@ -6,124 +5,23 @@ import {
   endpointModelSelectionSource,
 } from "./endpoint-model-selection.mjs";
 import { createHermesRunsClient } from "./hermes-runs-client.mjs";
-import {
-  createConfiguredRunsClient,
-  RUNS_API_CONNECTIONS_ENV,
-  runsApiConnectionId,
-  runsApiConnectionServesEndpoint,
-  runsApiConnectionsForRuntime,
-} from "./runs-api-connections.mjs";
 import { probeRunsClient } from "./workspace-connection-client.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) => ({
+// credential path, shell command, or prompt. The machine holds no connection
+// registry, so no id names a connection it can check: a workspace connection
+// is probed by the server and shape-checked here by VERIFY.
+export async function checkRunsApiConnection(request) {
+  return {
     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 &&
-      runsApiConnectionServesEndpoint(candidate, 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");
-  }
+    state: "NOT_CONFIGURED",
+    checkedAt: new Date().toISOString(),
+  };
 }
 
 export async function verifyRunsApiSelection(
   request,
-  {
-    env = process.env,
-    makeDefaultClient = createHermesRunsClient,
-    makeConfiguredClient = createConfiguredRunsClient,
-    health = checkRunsApiConnection,
-  } = {}
+  { env = process.env, makeDefaultClient = createHermesRunsClient } = {}
 ) {
   const result = (state, servedRuntime) => ({
     connectionId: request.connectionId,
@@ -146,29 +44,7 @@ export async function verifyRunsApiSelection(
   // machine holds none to probe with. This is a shape check only; the server
   // performs the connectivity probe (228-05).
   if (selection?.modelConnectionId) return result("REACHABLE");
-  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 ||
-      !runsApiConnectionServesEndpoint(connection, 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 !== endpointModelSelectionSource(selection))
+  if (request.connectionId !== endpointModelSelectionSource(selection))
     return result("NOT_CONFIGURED");
   const apiKeyFile =
     env.SELLABLE_AGENT_SERVER_AUTHENTICATED_KIND === "ADMIN"
@@ -176,30 +52,13 @@ export async function verifyRunsApiSelection(
       : `/run/sellable-agent/${request.profileId}/api-server-key`;
   let client;
   try {
-    client = selection?.runsApiBaseUrl
-      ? await 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 });
+    client = makeDefaultClient({ apiKeyFile });
   } catch {
     return result("UNAVAILABLE");
   }
   const probe = await probeRunsClient(client, selection, {
     signal: AbortSignal.timeout(70_000),
-    submitVerification: !selection?.runsApiBaseUrl,
+    submitVerification: true,
   });
   return result(probe.state, probe.servedRuntime);
 }

package/lib/sellable-agent/fly-runtime-identity.mjs

@@ -530,8 +530,11 @@ const RETRYABLE_WORKER_CONTROL_STATUSES = new Set([
   408, 425, 429, 500, 502, 503, 504,
 ]);
 
-class WorkerControlResponseError extends Error {
-  constructor(code, { retryable = false, status = null } = {}) {
+export class WorkerControlResponseError extends Error {
+  constructor(
+    code,
+    { retryable = false, status = /** @type {number | null} */ (null) } = {}
+  ) {
     super(code);
     this.name = "WorkerControlResponseError";
     this.retryable = retryable;

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

@@ -38,8 +38,8 @@ 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.810";
-const MCP_PACKAGE = "@sellable/mcp@0.1.958";
+const INSTALLER_PACKAGE = "@sellable/install@0.1.813";
+const MCP_PACKAGE = "@sellable/mcp@0.1.959";
 const HERMES_VERSION = "0.18.0";
 const SHA256 = /^[a-f0-9]{64}$/;
 const SHA256_16 = /^[a-f0-9]{16}$/;

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

@@ -1546,8 +1546,8 @@ export function compileClaimToProfileDesired(activeClaim, config) {
       ]) ||
       pinned.hermesCli !== "hermes" ||
       pinned.hermesVersion !== "0.18.0" ||
-      pinned.installerPackage !== "@sellable/install@0.1.810" ||
-      pinned.mcpPackage !== "@sellable/mcp@0.1.958" ||
+      pinned.installerPackage !== "@sellable/install@0.1.813" ||
+      pinned.mcpPackage !== "@sellable/mcp@0.1.959" ||
       !Array.isArray(policy.toolInclude) ||
       policy.toolInclude.length === 0 ||
       !Number.isSafeInteger(slack.generation) ||

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

@@ -312,8 +312,8 @@ function validateDesired(desired) {
     desired.serviceCredentialGeneration < 1 ||
     desired.hermesCli !== "hermes" ||
     desired.hermesVersion !== "0.18.0" ||
-    desired.installerPackage !== "@sellable/install@0.1.810" ||
-    desired.mcpPackage !== "@sellable/mcp@0.1.958" ||
+    desired.installerPackage !== "@sellable/install@0.1.813" ||
+    desired.mcpPackage !== "@sellable/mcp@0.1.959" ||
     !Array.isArray(desired.toolInclude) ||
     desired.toolInclude.length === 0 ||
     desired.toolInclude.some((tool) => !/^[a-z][a-z0-9_]{0,127}$/.test(tool)) ||

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

@@ -25,8 +25,8 @@ 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.810";
-export const PINNED_MCP_PACKAGE = "@sellable/mcp@0.1.958";
+export const PINNED_INSTALL_PACKAGE = "@sellable/install@0.1.813";
+export const PINNED_MCP_PACKAGE = "@sellable/mcp@0.1.959";
 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.810",
+  "version": "0.1.813",
   "type": "module",
   "description": "One-command installer for Sellable MCP in Claude Code, Codex, and Hermes",
   "bin": {

package/lib/sellable-agent/fly-customer-image/claude-code-mcp-session.d.mts

@@ -1 +0,0 @@
-export function tagEndpointSession(line: string, sessionId: string): string;