feat: enable codex stdio code agent runtime

scripts/code-agent-chat-smoke.mjs

@@ -1,12 +1,16 @@
 #!/usr/bin/env node
 import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import http from "node:http";
 import https from "node:https";
+import os from "node:os";
+import path from "node:path";
 
 import {
   handleCodeAgentChat,
   validateCodeAgentChatSchema
 } from "../internal/cloud/code-agent-chat.mjs";
+import { createCodexStdioSessionManager } from "../internal/cloud/codex-stdio-session.mjs";
 import {
   classifyCodexRunnerCapability,
   classifyCodeAgentChatReadiness,
@@ -220,6 +224,136 @@ async function runLocalContractSmoke() {
   assert.equal(runnerCapability.blocker, "controlled-readonly-not-long-lived");
   logOk("read-only runner pwd uses a reusable session but remains partial capability");
 
+  const stdioWorkspaceRoot = await mkdtemp(path.join(os.tmpdir(), `hwlab-code-agent-stdio-smoke-${process.pid}-`));
+  const stdioWorkspace = path.join(stdioWorkspaceRoot, "workspace");
+  const stdioCodexHome = path.join(stdioWorkspaceRoot, "codex-home");
+  const stdioSkillsDir = path.join(stdioWorkspaceRoot, "skills");
+  await mkdir(stdioWorkspace, { recursive: true });
+  await mkdir(path.join(stdioSkillsDir, "aaa-stdio-smoke-skill"), { recursive: true });
+  await mkdir(stdioCodexHome, { recursive: true });
+  await writeFile(path.join(stdioWorkspace, "README.md"), "stdio smoke workspace\n");
+  await writeFile(path.join(stdioSkillsDir, "aaa-stdio-smoke-skill", "SKILL.md"), [
+    "---",
+    "name: aaa-stdio-smoke-skill",
+    "description: Stdio smoke skill summary.",
+    "---",
+    "",
+    "# Stdio Smoke"
+  ].join("\n"));
+  try {
+    const stdioManager = createCodexStdioSessionManager({
+      idFactory: () => "ses_code_agent_chat_smoke_stdio",
+      createRpcClient: async () => ({
+        async initialize() {
+          return { tools: ["codex", "codex-reply"] };
+        },
+        async listTools() {
+          return ["codex", "codex-reply"];
+        },
+        async callTool(name, toolArgs) {
+          return {
+            structuredContent: {
+              threadId: "thread_code_agent_chat_smoke_stdio",
+              content: `${name} fixture reply for ${toolArgs?.threadId ?? "new-thread"}`
+            }
+          };
+        },
+        close() {}
+      })
+    });
+    const stdioEnv = {
+      PATH: process.env.PATH,
+      OPENAI_API_KEY: "test-openai-key-material",
+      CODEX_HOME: stdioCodexHome,
+      HWLAB_CODE_AGENT_PROVIDER: "codex-stdio",
+      HWLAB_CODE_AGENT_MODEL: "gpt-test",
+      HWLAB_CODE_AGENT_CODEX_STDIO_ENABLED: "1",
+      HWLAB_CODE_AGENT_CODEX_STDIO_SUPERVISOR: "repo-owned",
+      HWLAB_CODE_AGENT_CODEX_WORKSPACE: stdioWorkspace,
+      HWLAB_CODE_AGENT_CODEX_SANDBOX: "workspace-write",
+      HWLAB_CODE_AGENT_SKILLS_DIRS: stdioSkillsDir,
+      HWLAB_CODE_AGENT_OPENAI_BASE_URL: "http://127.0.0.1:65535/v1/responses"
+    };
+    const stdioPwd = await handleCodeAgentChat(
+      {
+        conversationId: "cnv_code-agent-chat-stdio",
+        traceId: "trc_code-agent-chat-stdio-pwd",
+        message: "请 pwd、ls .、列出可用 skills，并做一次 workspace 写入读取清理 smoke"
+      },
+      {
+        now: () => "2026-05-22T00:02:10.000Z",
+        codexStdioManager: stdioManager,
+        env: stdioEnv
+      }
+    );
+    validateCodeAgentChatSchema(stdioPwd);
+    assert.equal(stdioPwd.status, "completed");
+    assert.equal(stdioPwd.provider, "codex-stdio");
+    assert.equal(stdioPwd.backend, "hwlab-cloud-api/codex-mcp-stdio");
+    assert.equal(stdioPwd.runner.kind, "codex-mcp-stdio-runner");
+    assert.equal(stdioPwd.sessionMode, "codex-mcp-stdio-long-lived");
+    assert.equal(stdioPwd.implementationType, "repo-owned-codex-mcp-stdio-session");
+    assert.equal(stdioPwd.capabilityLevel, "long-lived-codex-stdio-session");
+    assert.equal(stdioPwd.workspace, stdioWorkspace);
+    assert.equal(stdioPwd.sandbox, "workspace-write");
+    assert.equal(stdioPwd.runner.codexStdio, true);
+    assert.equal(stdioPwd.runner.writeCapable, true);
+    assert.equal(stdioPwd.runner.durableSession, true);
+    assert.equal(stdioPwd.session.longLivedSession, true);
+    assert.equal(stdioPwd.session.codexStdio, true);
+    assert.equal(stdioPwd.sessionReuse.reused, false);
+    assert.equal(stdioPwd.sessionReuse.turn, 1);
+    assert.equal(stdioPwd.codexStdioFeasibility.ready, true);
+    assert.equal(stdioPwd.codexStdioFeasibility.runtimeContract.stdioProtocol.status, "wired");
+    assert.equal(stdioPwd.codexStdioFeasibility.runtimeContract.lifecycleSupervisor.status, "present");
+    assert.equal(stdioPwd.codexStdioFeasibility.runtimeContract.workspaceMount.status, "ready");
+    assert.equal(stdioPwd.codexStdioFeasibility.runtimeContract.codexHome.status, "ready");
+    assert.equal(stdioPwd.longLivedSessionGate.status, "pass");
+    assert.equal(stdioPwd.longLivedSessionGate.pass, true);
+    assert.ok(stdioPwd.toolCalls.some((call) => call.name === "codex" && call.status === "completed"));
+    assert.ok(stdioPwd.toolCalls.some((call) => call.name === "pwd" && call.status === "completed"));
+    assert.ok(stdioPwd.toolCalls.some((call) => call.name === "ls" && call.status === "completed"));
+    assert.ok(stdioPwd.toolCalls.some((call) => call.name === "skills.discover" && call.status === "completed"));
+    assert.ok(stdioPwd.toolCalls.some((call) => call.name === "workspace.smoke.write" && call.status === "completed"));
+    assert.ok(stdioPwd.toolCalls.some((call) => call.name === "workspace.smoke.read" && call.status === "completed"));
+    assert.ok(stdioPwd.toolCalls.some((call) => call.name === "workspace.smoke.cleanup" && call.status === "completed"));
+    assert.equal(stdioPwd.skills.status, "ready");
+    assert.ok(stdioPwd.skills.items.some((skill) => skill.name === "aaa-stdio-smoke-skill"));
+    assert.equal(stdioPwd.runnerTrace.runnerKind, "codex-mcp-stdio-runner");
+    assert.equal(stdioPwd.runnerTrace.sessionMode, "codex-mcp-stdio-long-lived");
+    assert.ok(stdioPwd.runnerTrace.events.includes("tool:workspace.pwd:completed"));
+    assert.ok(stdioPwd.runnerTrace.events.includes("tool:workspace.smoke.cleanup:completed"));
+    assert.equal(classifyCodexRunnerCapability(stdioPwd, { httpStatus: 200 }).capabilityPass, true);
+
+    const stdioSecondTurn = await handleCodeAgentChat(
+      {
+        conversationId: "cnv_code-agent-chat-stdio",
+        traceId: "trc_code-agent-chat-stdio-reuse",
+        message: "继续复用同一个 session 并 ls ."
+      },
+      {
+        now: () => "2026-05-22T00:02:11.000Z",
+        codexStdioManager: stdioManager,
+        env: stdioEnv
+      }
+    );
+    validateCodeAgentChatSchema(stdioSecondTurn);
+    assert.equal(stdioSecondTurn.status, "completed");
+    assert.equal(stdioSecondTurn.provider, "codex-stdio");
+    assert.equal(stdioSecondTurn.sessionId, stdioPwd.sessionId);
+    assert.equal(stdioSecondTurn.session.sessionId, stdioPwd.session.sessionId);
+    assert.equal(stdioSecondTurn.session.threadId, "thread_code_agent_chat_smoke_stdio");
+    assert.equal(stdioSecondTurn.sessionReuse.reused, true);
+    assert.equal(stdioSecondTurn.sessionReuse.turn, 2);
+    assert.ok(stdioSecondTurn.toolCalls.some((call) => call.name === "codex-reply" && call.status === "completed"));
+    assert.ok(stdioSecondTurn.toolCalls.some((call) => call.name === "ls" && call.status === "completed"));
+    assert.equal(classifyCodexRunnerCapability(stdioSecondTurn, { httpStatus: 200 }).capabilityPass, true);
+    assert.equal(JSON.stringify(stdioSecondTurn).includes("test-openai-key-material"), false);
+    logOk("codex stdio runner passes long-lived workspace-write session capability");
+  } finally {
+    await rm(stdioWorkspaceRoot, { recursive: true, force: true });
+  }
+
   const runnerSecondTurn = await handleCodeAgentChat(
     {
       conversationId: "cnv_code-agent-chat-runner-pwd",

scripts/deploy-desired-state-plan.test.mjs

@@ -52,7 +52,7 @@ async function makeFixture({
   const providerEnv =
     serviceId === "hwlab-cloud-api" && deployCodeAgentProviderEnv
       ? {
-          HWLAB_CODE_AGENT_PROVIDER: "openai",
+          HWLAB_CODE_AGENT_PROVIDER: "codex-stdio",
           HWLAB_CODE_AGENT_MODEL: "gpt-5.5",
           HWLAB_CODE_AGENT_OPENAI_BASE_URL: providerBaseUrl,
           OPENAI_API_KEY: "secretRef:hwlab-code-agent-provider/openai-api-key"
@@ -61,7 +61,7 @@ async function makeFixture({
   const workloadProviderEnv =
     serviceId === "hwlab-cloud-api" && workloadCodeAgentProviderEnv
       ? [
-          { name: "HWLAB_CODE_AGENT_PROVIDER", value: "openai" },
+          { name: "HWLAB_CODE_AGENT_PROVIDER", value: "codex-stdio" },
           { name: "HWLAB_CODE_AGENT_MODEL", value: "gpt-5.5" },
           { name: "HWLAB_CODE_AGENT_OPENAI_BASE_URL", value: providerBaseUrl },
           {
@@ -219,6 +219,9 @@ test("passes when cloud-api preserves provider env and DEV egress contract", asy
   assert.equal(plan.cloudApiDb.sslMode.deployMatches, true);
   assert.equal(plan.cloudApiDb.sslMode.workloadMatches, true);
   assert.equal(plan.codeAgentProvider.ready, true);
+  assert.equal(plan.codeAgentProvider.provider, "codex-stdio");
+  assert.equal(plan.codeAgentProvider.runtimeProvider, "openai-responses");
+  assert.equal(plan.codeAgentProvider.backend, "hwlab-cloud-api/codex-mcp-stdio");
   assert.equal(plan.codeAgentProvider.secretRef.present, true);
   assert.equal(plan.codeAgentProvider.egress.deployMatchesDevProxy, true);
   assert.deepEqual(plan.diagnostics, []);

scripts/dev-artifact-publish.mjs

@@ -342,8 +342,10 @@ function ensureCodeAgentRuntimeBase() {
   process.env.HWLAB_CODE_AGENT_CODEX_SANDBOX = process.env.HWLAB_CODE_AGENT_CODEX_SANDBOX || "workspace-write";
   process.env.HWLAB_CODE_AGENT_CODEX_STDIO_ENABLED = process.env.HWLAB_CODE_AGENT_CODEX_STDIO_ENABLED || "1";
   process.env.HWLAB_CODE_AGENT_CODEX_STDIO_SUPERVISOR = process.env.HWLAB_CODE_AGENT_CODEX_STDIO_SUPERVISOR || "repo-owned";
+  process.env.HWLAB_CODE_AGENT_PROVIDER = process.env.HWLAB_CODE_AGENT_PROVIDER || "codex-stdio";
   process.env.CODEX_HOME = codexHome;
   process.env.HWLAB_CODE_AGENT_CODEX_COMMAND = process.env.HWLAB_CODE_AGENT_CODEX_COMMAND || "/app/node_modules/.bin/codex";
+  process.env.HWLAB_CODE_AGENT_SKILLS_DIRS = process.env.HWLAB_CODE_AGENT_SKILLS_DIRS || "/app/skills:/root/.agents/skills:/home/ubuntu/.agents/skills";
 
   mkdirSync(path.dirname(workspace), { recursive: true });
   if (!existsSync(workspace)) {
@@ -821,6 +823,8 @@ function dockerfile(baseImage, port) {
     "ENV HWLAB_CODE_AGENT_CODEX_STDIO_ENABLED=1",
     "ENV HWLAB_CODE_AGENT_CODEX_STDIO_SUPERVISOR=repo-owned",
     "ENV HWLAB_CODE_AGENT_CODEX_COMMAND=/app/node_modules/.bin/codex",
+    "ENV HWLAB_CODE_AGENT_PROVIDER=codex-stdio",
+    "ENV HWLAB_CODE_AGENT_SKILLS_DIRS=/app/skills:/root/.agents/skills:/home/ubuntu/.agents/skills",
     "ENV HWLAB_ENVIRONMENT=$HWLAB_ENVIRONMENT",
     "ENV HWLAB_SERVICE_ID=$HWLAB_SERVICE_ID",
     "ENV HWLAB_ARTIFACT_KIND=$HWLAB_ARTIFACT_KIND",
@@ -846,7 +850,7 @@ function dockerfile(baseImage, port) {
     "COPY skills ./skills",
     "COPY deploy ./deploy",
     "COPY reports ./reports",
-    "RUN mkdir -p /workspace /codex-home && rm -rf /workspace/hwlab && ln -s /app /workspace/hwlab && chmod -R a+rwX /app /workspace /codex-home && test -x /app/node_modules/.bin/codex && /app/node_modules/.bin/codex --version >/tmp/hwlab-codex-version.txt",
+    "RUN mkdir -p /workspace /codex-home && rm -rf /workspace/hwlab && ln -s /app /workspace/hwlab && chmod -R a+rwX /app /workspace /codex-home && test -x /app/node_modules/.bin/codex && /app/node_modules/.bin/codex --version >/tmp/hwlab-codex-version.txt && (test -x /app/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl/codex/codex || test -x /app/node_modules/@openai/codex-linux-arm64/vendor/aarch64-unknown-linux-musl/codex/codex)",
     `RUN node -e "const fs=require('node:fs'); fs.writeFileSync('/usr/local/bin/hwlab-dev-artifact-runtime.mjs', Buffer.from('${runtimeScriptBase64()}', 'base64')); fs.chmodSync('/usr/local/bin/hwlab-dev-artifact-runtime.mjs', 0o755);"`,
     `EXPOSE ${port}`,
     "CMD [\"node\", \"/usr/local/bin/hwlab-dev-artifact-runtime.mjs\"]",

scripts/src/deploy-contract-plan.mjs

@@ -375,7 +375,7 @@ function validateCloudApiDbSource(ctx, env) {
 
 function validateCloudApiCodeAgentSource(ctx, env) {
   const contract = DEV_CODE_AGENT_PROVIDER_CONTRACT;
-  expectEqual(ctx, env.HWLAB_CODE_AGENT_PROVIDER, contract.provider, "$.services.hwlab-cloud-api.env.HWLAB_CODE_AGENT_PROVIDER", "cloud API Code Agent provider");
+  expectEqual(ctx, env.HWLAB_CODE_AGENT_PROVIDER, contract.codeAgentProvider, "$.services.hwlab-cloud-api.env.HWLAB_CODE_AGENT_PROVIDER", "cloud API Code Agent provider");
   expectEqual(ctx, env.HWLAB_CODE_AGENT_MODEL, contract.model, "$.services.hwlab-cloud-api.env.HWLAB_CODE_AGENT_MODEL", "cloud API Code Agent model");
   expectEqual(ctx, env.HWLAB_CODE_AGENT_TIMEOUT_MS, "120000", "$.services.hwlab-cloud-api.env.HWLAB_CODE_AGENT_TIMEOUT_MS", "cloud API Code Agent hard timeout budget");
   expectEqual(
@@ -551,7 +551,7 @@ function validateCloudApiCodeAgentArtifacts(ctx, workloads) {
   const secretRef = contract.secretRefs[0];
   const container = mapByServiceId(listItems(workloads)).get("hwlab-cloud-api")?.spec?.template?.spec?.containers?.[0];
   const env = new Map((container?.env ?? []).map((entry) => [entry.name, entry]));
-  expectEqual(ctx, env.get("HWLAB_CODE_AGENT_PROVIDER")?.value, contract.provider, "deploy/k8s/base/workloads.yaml.hwlab-cloud-api.env.HWLAB_CODE_AGENT_PROVIDER", "cloud API workload Code Agent provider");
+  expectEqual(ctx, env.get("HWLAB_CODE_AGENT_PROVIDER")?.value, contract.codeAgentProvider, "deploy/k8s/base/workloads.yaml.hwlab-cloud-api.env.HWLAB_CODE_AGENT_PROVIDER", "cloud API workload Code Agent provider");
   expectEqual(ctx, env.get("HWLAB_CODE_AGENT_MODEL")?.value, contract.model, "deploy/k8s/base/workloads.yaml.hwlab-cloud-api.env.HWLAB_CODE_AGENT_MODEL", "cloud API workload Code Agent model");
   expectEqual(ctx, env.get("HWLAB_CODE_AGENT_TIMEOUT_MS")?.value, "120000", "deploy/k8s/base/workloads.yaml.hwlab-cloud-api.env.HWLAB_CODE_AGENT_TIMEOUT_MS", "cloud API workload Code Agent hard timeout budget");
   expectEqual(

scripts/src/deploy-desired-state-plan.mjs

@@ -293,7 +293,7 @@ function inspectCodeAgentProviderDesiredState(ctx, deployService, workloadRecord
       path: "deploy.codeAgentProvider",
       message: "hwlab-cloud-api desired state must preserve Code Agent provider Secret ref and DEV egress proxy env",
       expected: {
-        provider: DEV_CODE_AGENT_PROVIDER_CONTRACT.provider,
+        provider: DEV_CODE_AGENT_PROVIDER_CONTRACT.codeAgentProvider,
         secretRef: `${DEV_CODE_AGENT_PROVIDER_CONTRACT.secretRefs[0].secretName}/${DEV_CODE_AGENT_PROVIDER_CONTRACT.secretRefs[0].secretKey}`,
         egressTarget: DEV_CODE_AGENT_PROVIDER_CONTRACT.egress.target
       },

scripts/src/dev-deploy-apply.test.mjs

@@ -28,7 +28,7 @@ function codeAgentDeploy(env = {}) {
       {
         serviceId: "hwlab-cloud-api",
         env: {
-          HWLAB_CODE_AGENT_PROVIDER: "openai",
+          HWLAB_CODE_AGENT_PROVIDER: "codex-stdio",
           HWLAB_CODE_AGENT_MODEL: "gpt-5.5",
           HWLAB_CODE_AGENT_OPENAI_BASE_URL: codeAgentBaseUrl,
           OPENAI_API_KEY: "secretRef:hwlab-code-agent-provider/openai-api-key",
@@ -59,7 +59,7 @@ function codeAgentWorkloads(envOverrides = []) {
                 {
                   name: "hwlab-cloud-api",
                   env: [
-                    { name: "HWLAB_CODE_AGENT_PROVIDER", value: "openai" },
+                    { name: "HWLAB_CODE_AGENT_PROVIDER", value: "codex-stdio" },
                     { name: "HWLAB_CODE_AGENT_MODEL", value: "gpt-5.5" },
                     { name: "HWLAB_CODE_AGENT_OPENAI_BASE_URL", value: codeAgentBaseUrl },
                     {
@@ -305,6 +305,9 @@ test("Code Agent provider desired state preserves Secret ref and egress base URL
 
   assert.equal(inspection.ready, true);
   assert.equal(inspection.status, "pass");
+  assert.equal(inspection.provider, "codex-stdio");
+  assert.equal(inspection.runtimeProvider, "openai-responses");
+  assert.equal(inspection.backend, "hwlab-cloud-api/codex-mcp-stdio");
   assert.equal(inspection.secretRef.present, true);
   assert.equal(inspection.secretMaterialRead, false);
   assert.equal(inspection.egress.deployMatchesDevProxy, true);

scripts/src/dev-gate-preflight.mjs

@@ -1320,10 +1320,10 @@ function inspectCodeAgentProviderStaticContract(deploy, workloads) {
   const deployBaseUrl = deployEnv[contract.egress.env];
   const workloadBaseUrl = workloadEnv.get(contract.egress.env)?.value;
   const egressChecks = [
-    ["deployEnv.HWLAB_CODE_AGENT_PROVIDER", deployEnv.HWLAB_CODE_AGENT_PROVIDER, contract.provider],
+    ["deployEnv.HWLAB_CODE_AGENT_PROVIDER", deployEnv.HWLAB_CODE_AGENT_PROVIDER, contract.codeAgentProvider],
     ["deployEnv.HWLAB_CODE_AGENT_MODEL", deployEnv.HWLAB_CODE_AGENT_MODEL, contract.model],
     ["deployEnv.HWLAB_CODE_AGENT_OPENAI_BASE_URL", deployBaseUrl, contract.egress.defaultBaseUrl],
-    ["workloadEnv.HWLAB_CODE_AGENT_PROVIDER", workloadEnv.get("HWLAB_CODE_AGENT_PROVIDER")?.value, contract.provider],
+    ["workloadEnv.HWLAB_CODE_AGENT_PROVIDER", workloadEnv.get("HWLAB_CODE_AGENT_PROVIDER")?.value, contract.codeAgentProvider],
     ["workloadEnv.HWLAB_CODE_AGENT_MODEL", workloadEnv.get("HWLAB_CODE_AGENT_MODEL")?.value, contract.model],
     ["workloadEnv.HWLAB_CODE_AGENT_OPENAI_BASE_URL", workloadBaseUrl, contract.egress.defaultBaseUrl]
   ];
@@ -1340,7 +1340,9 @@ function inspectCodeAgentProviderStaticContract(deploy, workloads) {
   return {
     contractVersion: contract.contractVersion,
     environment: contract.environment,
-    provider: contract.runtimeProvider,
+    provider: contract.codeAgentProvider,
+    runtimeProvider: contract.runtimeProvider,
+    backend: contract.backend,
     model: contract.model,
     ready:
       missingDeployEnv.length === 0 &&

scripts/validate-contract.mjs

@@ -200,7 +200,7 @@ assert.equal(cloudApiWorkloadEnv.HWLAB_CLOUD_DB_SERVICE_NAMESPACE, undefined, "c
 assert.equal(cloudApiWorkloadEnv.HWLAB_CLOUD_DB_HOST, undefined, "cloud-api workload DB alias host is optional");
 assert.equal(cloudApiWorkloadEnv.HWLAB_CLOUD_DB_PORT, undefined, "cloud-api workload DB alias port is optional");
 assertCloudApiDbOptionalAlias(k8sServices);
-assert.equal(cloudApi.env.HWLAB_CODE_AGENT_PROVIDER, "openai", "cloud-api Code Agent provider");
+assert.equal(cloudApi.env.HWLAB_CODE_AGENT_PROVIDER, DEV_CODE_AGENT_PROVIDER_CONTRACT.codeAgentProvider, "cloud-api Code Agent provider");
 assert.equal(cloudApi.env.HWLAB_CODE_AGENT_MODEL, DEV_CODE_AGENT_PROVIDER_CONTRACT.model, "cloud-api Code Agent model");
 assert.equal(
   cloudApi.env.HWLAB_CODE_AGENT_OPENAI_BASE_URL,
@@ -265,7 +265,7 @@ function assertCodeAgentProviderWorkloadContract(env) {
   const contract = DEV_CODE_AGENT_PROVIDER_CONTRACT;
   const secretRef = contract.secretRefs[0];
   const apiKey = env[secretRef.env]?.valueFrom?.secretKeyRef;
-  assert.equal(env.HWLAB_CODE_AGENT_PROVIDER?.value, contract.provider, "cloud-api workload Code Agent provider");
+  assert.equal(env.HWLAB_CODE_AGENT_PROVIDER?.value, contract.codeAgentProvider, "cloud-api workload Code Agent provider");
   assert.equal(env.HWLAB_CODE_AGENT_MODEL?.value, contract.model, "cloud-api workload Code Agent model");
   assert.equal(
     env.HWLAB_CODE_AGENT_OPENAI_BASE_URL?.value,