@runuai/host 0.9.90 → 0.9.91

package/lib/agents/factory.ts

@@ -21,6 +21,7 @@ import "./kimi";
 import "./grok";
 import "./cursor";
 import "./opencode";
+import "./uai";
 
 import { agentClisReady } from "../standard-image";
 import { factoryFor, supportsExecutionProfile } from "./registry";

package/lib/agents/types.ts

@@ -54,6 +54,9 @@ export const RosterAgent = z.object({
   initialPrompt: z.string().optional(), // first-turn instructions, this task only
   skills: z.array(RosterSkill).optional(), // ADR-046 reference material
   permissions: z.array(z.string()).optional(), // ADR-048 `uai` CLI capabilities
+  // ADR-128: which upstream protocol a Uai-engine model speaks — resolved
+  // cloud-side from the model catalog; selects the delegated adapter.
+  uaiProvider: z.enum(["anthropic", "openai"]).optional(),
 });
 export type RosterAgent = z.infer<typeof RosterAgent>;
 

package/lib/agents/uai.ts

@@ -0,0 +1,87 @@
+/**
+ * The Uai Managed Engine (ADR-128) — not a harness, a delegation.
+ *
+ * The customer picks "Uai Managed Engine" and one of Uai's models; under
+ * the hood this adapter spawns the EXISTING claude or codex adapter
+ * (chosen by the model's provider, resolved cloud-side into
+ * `agent.uaiProvider`) with the environment pointed at the inference
+ * gateway: base URL swapped, the agent's own task token as the API
+ * credential, and the host's real provider credentials explicitly
+ * BLANKED so a BYO host's Claude subscription can never be billed for a
+ * Uai-engine turn. The gateway meters usage server-side and the cloud
+ * debits credits — this file never sees money.
+ *
+ * The model slug passes through verbatim: the underlying CLI sends it as
+ * the request's `model`, and the gateway maps slug → upstream id.
+ */
+
+import { factoryFor, register } from "./registry";
+import type { AgentSession, AgentSessionFactory } from "./types";
+
+const DEFAULT_GATEWAY_URL = "https://inference.runuai.com";
+
+export function gatewayUrl(): string {
+  return process.env.UAI_INFERENCE_GATEWAY_URL || DEFAULT_GATEWAY_URL;
+}
+
+/** The env override set for a delegated session. Exported for tests. */
+export function uaiGatewayEnv(
+  provider: "anthropic" | "openai",
+  url: string,
+  taskToken: string,
+): Record<string, string> {
+  if (provider === "openai") {
+    return {
+      OPENAI_BASE_URL: url,
+      OPENAI_API_KEY: taskToken,
+    };
+  }
+  return {
+    ANTHROPIC_BASE_URL: url,
+    ANTHROPIC_AUTH_TOKEN: taskToken,
+    // Explicit blanks WIN over the claude adapter's passEnv inheritance
+    // (same mechanism its communicator profile uses to scrub) — the host's
+    // real credential must never ride a gateway-billed session.
+    ANTHROPIC_API_KEY: "",
+    CLAUDE_CODE_OAUTH_TOKEN: "",
+  };
+}
+
+const create: AgentSessionFactory["create"] = async (args): Promise<AgentSession> => {
+  const provider = args.agent.uaiProvider === "openai" ? "openai" : "anthropic";
+  const delegateKind = provider === "openai" ? "codex" : "claude";
+  const delegate = factoryFor(delegateKind);
+  if (!delegate) {
+    throw new Error(`uai engine: no ${delegateKind} adapter registered to delegate to`);
+  }
+  const taskToken = args.agentEnv?.UAI_TASK_TOKEN;
+  if (!taskToken) {
+    // agentCliEnv mints no token for a permissionless non-secretary agent;
+    // the gateway authenticates with exactly that token, so the engine
+    // needs it. The default crew grants permissions, so this is rare.
+    throw new Error(
+      "uai engine: this agent has no task token (no CLI permissions) — grant it at least one permission or use a direct engine",
+    );
+  }
+  return delegate.create({
+    ...args,
+    agentEnv: {
+      ...(args.agentEnv ?? {}),
+      ...uaiGatewayEnv(provider, gatewayUrl(), taskToken),
+    },
+  });
+};
+
+register({
+  kind: "uai",
+  label: "Uai Managed Engine",
+  // The model catalog is cloud data (ADR-128); the composer sources it from
+  // /api/org/inference/models, never from host capabilities. Advertising an
+  // empty list here simply marks the kind spawnable on this host.
+  supportedModels: () => [],
+  supportedEfforts: () => [],
+  // Always available: the engine needs no host-side credential — auth is
+  // the per-agent task token, billing is the org's credits.
+  available: () => true,
+  create,
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.90",
+  "version": "0.9.91",
   "description": "Uai host — runs ephemeral AI tasks in containers on a machine you control.",
   "license": "MIT",
   "author": "Uai Tech <team@runuai.com>",

package/src/main.ts

@@ -2919,6 +2919,9 @@ function expectTaskAgents(value: unknown): TaskAgent[] {
     // effort was previously dropped here even though the protocol + adapters
     // carry it — fixed alongside skills (ADR-046).
     if (typeof row.effort === "string") out.effort = row.effort;
+    if (row.uaiProvider === "anthropic" || row.uaiProvider === "openai") {
+      out.uaiProvider = row.uaiProvider;
+    }
     if (typeof row.defaultPrompt === "string") {
       out.defaultPrompt = row.defaultPrompt;
     }

package/src/protocol.ts

@@ -173,6 +173,8 @@ export type PermissionDecision = { kind: "accept" } | { kind: "decline" };
  * `effort` (when set) is the CLI reasoning level, passed through like `model`.
  */
 export interface TaskAgent {
+  /** ADR-128: upstream protocol of a Uai-engine model (kind "uai"). */
+  uaiProvider?: "anthropic" | "openai";
   id: string;
   label: string;
   kind: string;