mirrors/pikasTech-HWLAB
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: 接入真实 Codex stdio trace

Browse Source
This commit is contained in:
Code Queue Review
2026-05-24 02:49:11 +00:00
parent 35bbbee951
commit e166a6ff20
12 changed files with 1791 additions and 3702 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scripts/code-agent-chat-smoke.mjs
+111 -529
View File
@@ -37,52 +37,30 @@ function logOk(name) {
process.stdout.write(`[code-agent-chat-smoke] ok ${name}\n`);
}
function runnerTraceLabels(payload) {
return Array.isArray(payload?.runnerTrace?.events)
? payload.runnerTrace.events.map((event) => event?.label ?? event).filter(Boolean)
: [];
}
async function runLocalContractSmoke() {
const completed = await handleCodeAgentChat(
{
conversationId: "cnv_code-agent-chat-smoke",
traceId: "trc_code-agent-chat-smoke",
projectId: "prj_code-agent-chat-smoke",
message: "请用一句话说明当前 HWLAB 工作台可以做什么。"
},
{
now: () => "2026-05-22T00:00:00.000Z",
callProvider: async ({ providerPlan }) => ({
provider: providerPlan.provider,
model: providerPlan.model,
backend: providerPlan.backend,
content: "HWLAB 工作台可以用 Code Agent 对话来整理任务、查看资源并保持硬件变更受控。",
usage: null,
providerTrace: {
source: "schema-smoke-provider"
}
})
}
);
validateCodeAgentChatSchema(completed);
assert.equal(completed.conversationId, "cnv_code-agent-chat-smoke");
assert.equal(completed.sessionId, "cnv_code-agent-chat-smoke");
assert.match(completed.messageId, /^msg_/);
assert.equal(completed.status, "completed");
assert.equal(completed.createdAt, "2026-05-22T00:00:00.000Z");
assert.equal(completed.updatedAt, "2026-05-22T00:00:00.000Z");
assert.equal(completed.traceId, "trc_code-agent-chat-smoke");
assert.equal(completed.error, undefined);
assert.match(completed.reply.content, /Code Agent/);
logOk("completed schema");
const sourceReadiness = classifyCodeAgentChatReadiness(completed, { realDevLive: false });
assert.equal(sourceReadiness.status, "blocked");
assert.equal(sourceReadiness.level, "SOURCE");
assert.equal(sourceReadiness.devLiveReplyPass, false);
logOk("local stub completion is not #143 DEV-LIVE pass");
const echoReadiness = classifyCodeAgentChatReadiness({
...completed,
conversationId: "cnv_code-agent-chat-smoke-echo",
sessionId: "cnv_code-agent-chat-smoke-echo",
messageId: "msg_code-agent-chat-smoke-echo",
status: "completed",
createdAt: "2026-05-22T00:00:00.000Z",
updatedAt: "2026-05-22T00:00:00.000Z",
traceId: "trc_code-agent-chat-smoke-echo",
provider: "echo-mock",
model: "mock-model",
backend: "hwlab-cloud-api/echo-mock"
backend: "hwlab-cloud-api/echo-mock",
reply: {
messageId: "msg_code-agent-chat-smoke-echo",
role: "assistant",
content: "mock reply",
createdAt: "2026-05-22T00:00:00.000Z"
}
}, { realDevLive: true, httpStatus: 200 });
assert.equal(echoReadiness.status, "blocked");
assert.equal(echoReadiness.level, "BLOCKED/untrusted-completion");
@@ -91,138 +69,48 @@ async function runLocalContractSmoke() {
assert.match(echoReadiness.reason, /echo\/mock\/stub/u);
logOk("echo/mock completion is not real DEV-LIVE pass");
const failed = await handleCodeAgentChat(
{
traceId: "trc_code-agent-chat-smoke-failed",
message: "你好"
},
{
now: () => "2026-05-22T00:01:00.000Z",
env: {
PATH: "",
HWLAB_CODE_AGENT_PROVIDER: "codex-cli",
HWLAB_CODE_AGENT_MODEL: "gpt-test",
HWLAB_CODE_AGENT_CODEX_COMMAND: "/tmp/hwlab-missing-codex"
for (const [index, message] of [
"列出可以使用的skill",
"pwd",
"ls .",
"rg --files .",
"请用cat读取 package.json"
].entries()) {
const blocked = await handleCodeAgentChat(
{
conversationId: `cnv_code-agent-chat-blocked-${index}`,
traceId: `trc_code-agent-chat-blocked-${index}`,
message
},
{
now: () => "2026-05-22T00:01:00.000Z",
env: {
PATH: "",
HWLAB_CODE_AGENT_PROVIDER: "codex-cli",
HWLAB_CODE_AGENT_MODEL: "gpt-test",
HWLAB_CODE_AGENT_CODEX_COMMAND: "/tmp/hwlab-missing-codex"
}
}
}
);
validateCodeAgentChatSchema(failed);
assert.match(failed.conversationId, /^cnv_/);
assert.match(failed.sessionId, /^cnv_/);
assert.match(failed.messageId, /^msg_/);
assert.equal(failed.status, "failed");
assert.equal(failed.createdAt, "2026-05-22T00:01:00.000Z");
assert.equal(failed.updatedAt, "2026-05-22T00:01:00.000Z");
assert.equal(failed.traceId, "trc_code-agent-chat-smoke-failed");
assert.equal(failed.provider, "codex-cli");
assert.equal(failed.model, "gpt-test");
assert.equal(failed.backend, "hwlab-cloud-api/codex-cli");
assert.equal(failed.error.code, "codex_cli_binary_missing");
assert.equal(failed.error.blocker.code, "codex_cli_binary_missing");
assert.match(failed.error.nextEvidence, /HWLAB_CODE_AGENT_CODEX_COMMAND|PATH/u);
assert.match(failed.error.message, /Codex CLI command is not available/);
assert.deepEqual(failed.error.missingCommands, ["/tmp/hwlab-missing-codex"]);
assert.ok(failed.error.missingEnv.includes("OPENAI_API_KEY"));
assert.equal(failed.availability.status, "partial");
assert.match(failed.availability.blocker, /Codex CLI command/u);
assert.equal(failed.availability.reason, "codex_cli_binary_missing");
assert.equal(failed.availability.runner.ready, true);
assert.equal(failed.availability.codexStdio.runtimeContract.binary.status, "missing");
assert.equal(failed.availability.codexStdio.runtimeContract.lifecycleSupervisor.status, "blocked");
assert.equal(failed.availability.codexStdio.runtimeContract.stdioProtocol.status, "blocked");
assert.ok(failed.availability.codexStdio.blockerCodes.includes("codex_cli_binary_missing"));
assert.ok(failed.availability.codexStdio.blockerCodes.includes("runner_lifecycle_missing"));
assert.ok(failed.availability.codexStdio.blockerCodes.includes("stdio_protocol_not_wired"));
assert.match(failed.availability.summary, /受控只读 runner/u);
assert.match(failed.availability.summary, /hwlab-code-agent-provider\/openai-api-key/u);
assert.equal(JSON.stringify(failed).includes("sk-"), false);
assert.equal(Object.hasOwn(failed, "reply"), false);
logOk("failed provider-gap schema");
const credentialReadiness = classifyCodeAgentChatReadiness(failed, { realDevLive: true });
assert.equal(credentialReadiness.status, "blocked");
assert.equal(credentialReadiness.level, "BLOCKED");
assert.equal(credentialReadiness.blocker, "runtime");
assert.equal(credentialReadiness.devLiveReplyPass, false);
logOk("codex binary missing blocker readiness");
const upstreamBlocked = classifyCodeAgentChatReadiness({
...failed,
error: {
code: "provider_unavailable",
message: "OpenAI Responses returned HTTP 502: request rejected",
providerStatus: 502,
missingEnv: []
},
availability: {
status: "available"
}
}, { realDevLive: true, httpStatus: 200 });
assert.equal(upstreamBlocked.status, "blocked");
assert.equal(upstreamBlocked.level, "BLOCKED/provider");
assert.equal(upstreamBlocked.blocker, "provider-upstream");
assert.equal(upstreamBlocked.providerStatus, 502);
assert.equal(upstreamBlocked.devLiveReplyPass, false);
logOk("provider 502 blocker readiness");
const completedLivePayload = {
...completed,
provider: "openai-responses",
model: "gpt-5.5",
backend: "hwlab-cloud-api/openai-responses"
};
const runnerPwd = await handleCodeAgentChat(
{
conversationId: "cnv_code-agent-chat-runner-pwd",
traceId: "trc_code-agent-chat-runner-pwd",
message: "用pwd列出你当前的工作目录"
},
{
now: () => "2026-05-22T00:02:00.000Z",
env: {
PATH: process.env.PATH,
HWLAB_CODE_AGENT_WORKSPACE: process.cwd()
}
}
);
validateCodeAgentChatSchema(runnerPwd);
assert.equal(runnerPwd.status, "completed");
assert.equal(runnerPwd.provider, "codex-readonly-runner");
assert.equal(runnerPwd.workspace, process.cwd());
assert.equal(runnerPwd.sandbox, "read-only");
assert.equal(runnerPwd.capabilityLevel, "read-only-session-tools");
assert.equal(runnerPwd.session.status, "idle");
assert.equal(runnerPwd.session.workspace, process.cwd());
assert.equal(runnerPwd.session.sandbox, "read-only");
assert.equal(runnerPwd.session.idleTimeoutMs, 1800000);
assert.equal(runnerPwd.session.lastTraceId, "trc_code-agent-chat-runner-pwd");
assert.equal(runnerPwd.sessionMode, "controlled-readonly-session-registry");
assert.equal(runnerPwd.implementationType, "controlled-readonly-session-registry");
assert.equal(runnerPwd.runner.session, "controlled-readonly-session-registry");
assert.equal(runnerPwd.runner.codexStdio, false);
assert.equal(runnerPwd.runner.longLivedSession, true);
assert.equal(runnerPwd.runner.writeCapable, false);
assert.equal(runnerPwd.runner.durableSession, false);
assert.equal(runnerPwd.sessionReuse.reused, false);
assert.equal(runnerPwd.sessionReuse.turn, 1);
assert.equal(runnerPwd.sessionReuse.status, "idle");
assert.ok(runnerPwd.runnerLimitations.includes("not-codex-stdio"));
assert.equal(runnerPwd.codexStdioFeasibility.status, "blocked");
assert.ok(runnerPwd.codexStdioFeasibility.blockerCodes.includes("stdio_protocol_not_wired"));
assert.equal(runnerPwd.codexStdioFeasibility.runtimeContract.stdioProtocol.status, "blocked");
assert.equal(runnerPwd.codexStdioFeasibility.runtimeContract.lifecycleSupervisor.status, "blocked");
assert.equal(runnerPwd.longLivedSessionGate.status, "blocked");
assert.equal(runnerPwd.longLivedSessionGate.pass, false);
assert.ok(runnerPwd.longLivedSessionGate.blockers.some((blocker) => blocker.code === "codex_stdio_blocked_readonly_session_available"));
assert.equal(runnerPwd.toolCalls[0].name, "pwd");
assert.equal(runnerPwd.toolCalls[0].status, "completed");
const runnerCapability = classifyCodexRunnerCapability(runnerPwd, { httpStatus: 200 });
assert.equal(runnerCapability.status, "blocked");
assert.equal(runnerCapability.capabilityPass, false);
assert.equal(runnerCapability.blocker, "controlled-readonly-not-long-lived");
logOk("read-only runner pwd uses a reusable session but remains partial capability");
);
validateCodeAgentChatSchema(blocked);
assert.equal(blocked.status, "failed");
assert.equal(blocked.provider, "codex-stdio");
assert.equal(blocked.backend, "hwlab-cloud-api/codex-mcp-stdio");
assert.equal(blocked.error.code, "codex_cli_binary_missing");
assert.equal(Object.hasOwn(blocked, "reply"), false);
assert.deepEqual(blocked.toolCalls, []);
assert.ok(blocked.runnerLimitations.includes("no-controlled-readonly-fallback"));
assert.ok(blocked.runnerLimitations.includes("no-text-fallback"));
assert.equal(blocked.availability.ready, false);
assert.equal(blocked.availability.partialReady, false);
assert.equal(blocked.runnerTrace.traceId, `trc_code-agent-chat-blocked-${index}`);
assert.ok(runnerTraceLabels(blocked).includes("request:accepted"));
assert.ok(runnerTraceLabels(blocked).includes("codex-stdio:blocked"));
assert.equal(blocked.runnerTrace.lastEvent.errorCode, "codex_cli_binary_missing");
assert.equal(blocked.runnerTrace.lastEvent.waitingFor, "codex-stdio-readiness");
assert.equal(JSON.stringify(blocked).includes("sk-"), false);
}
logOk("skills/pwd/ls/rg/cat prompts fail with Codex stdio blocker instead of local fallback");
const stdioWorkspaceRoot = await mkdtemp(path.join(os.tmpdir(), `hwlab-code-agent-stdio-smoke-${process.pid}-`));
const stdioWorkspace = path.join(stdioWorkspaceRoot, "workspace");
@@ -243,6 +131,7 @@ async function runLocalContractSmoke() {
let fakeCodex = null;
try {
fakeCodex = await createFakeCodexCommand();
const rpcCalls = [];
const stdioManager = createCodexStdioSessionManager({
idFactory: () => "ses_code_agent_chat_smoke_stdio",
createRpcClient: async () => ({
@@ -253,6 +142,7 @@ async function runLocalContractSmoke() {
return ["codex", "codex-reply"];
},
async callTool(name, toolArgs) {
rpcCalls.push({ name, toolArgs });
return {
structuredContent: {
threadId: "thread_code_agent_chat_smoke_stdio",
@@ -281,12 +171,14 @@ async function runLocalContractSmoke() {
{
conversationId: "cnv_code-agent-chat-stdio",
traceId: "trc_code-agent-chat-stdio-pwd",
message: "请 pwd、ls .、列出可用 skills，并做一次 workspace 写入读取清理 smoke"
message: "列出可以使用的skill"
},
{
now: () => "2026-05-22T00:02:10.000Z",
codexStdioManager: stdioManager,
env: stdioEnv
env: stdioEnv,
skillsDirs: [stdioSkillsDir],
skillsDirsExact: true
}
);
validateCodeAgentChatSchema(stdioPwd);
@@ -313,20 +205,24 @@ async function runLocalContractSmoke() {
assert.equal(stdioPwd.codexStdioFeasibility.runtimeContract.codexHome.status, "ready");
assert.equal(stdioPwd.longLivedSessionGate.status, "pass");
assert.equal(stdioPwd.longLivedSessionGate.pass, true);
assert.equal(stdioPwd.providerTrace.sidecarOnly, true);
assert.equal(stdioPwd.providerTrace.toolName, "workspace-sidecar");
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.equal(stdioPwd.providerTrace.toolName, "codex");
assert.equal(stdioPwd.providerTrace.threadId, "thread_code_agent_chat_smoke_stdio");
assert.equal(Object.hasOwn(stdioPwd.providerTrace, "sidecarOnly"), false);
assert.equal(rpcCalls[0].name, "codex");
assert.match(rpcCalls[0].toolArgs.prompt, /列出可以使用的skill/u);
assert.ok(stdioPwd.toolCalls.some((call) => call.name === "codex" && 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.ok(runnerTraceLabels(stdioPwd).includes("session:created"));
assert.ok(runnerTraceLabels(stdioPwd).includes("prompt:sent"));
assert.ok(runnerTraceLabels(stdioPwd).includes("tool:codex:started"));
assert.ok(runnerTraceLabels(stdioPwd).includes("tool:codex:output_chunk"));
assert.ok(runnerTraceLabels(stdioPwd).includes("tool:codex:completed"));
assert.ok(runnerTraceLabels(stdioPwd).includes("assistant:chunk"));
assert.ok(runnerTraceLabels(stdioPwd).includes("assistant:completed"));
assert.equal(classifyCodexRunnerCapability(stdioPwd, { httpStatus: 200 }).capabilityPass, true);
const stdioSecondTurn = await handleCodeAgentChat(
@@ -338,7 +234,9 @@ async function runLocalContractSmoke() {
{
now: () => "2026-05-22T00:02:11.000Z",
codexStdioManager: stdioManager,
env: stdioEnv
env: stdioEnv,
skillsDirs: [stdioSkillsDir],
skillsDirsExact: true
}
);
validateCodeAgentChatSchema(stdioSecondTurn);
@@ -346,12 +244,15 @@ async function runLocalContractSmoke() {
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, null);
assert.equal(stdioSecondTurn.session.threadId, "thread_code_agent_chat_smoke_stdio");
assert.equal(stdioSecondTurn.sessionReuse.reused, true);
assert.equal(stdioSecondTurn.sessionReuse.turn, 2);
assert.equal(stdioSecondTurn.providerTrace.sidecarOnly, true);
assert.equal(stdioSecondTurn.providerTrace.toolName, "workspace-sidecar");
assert.ok(stdioSecondTurn.toolCalls.some((call) => call.name === "ls" && call.status === "completed"));
assert.equal(stdioSecondTurn.providerTrace.toolName, "codex-reply");
assert.equal(Object.hasOwn(stdioSecondTurn.providerTrace, "sidecarOnly"), false);
assert.ok(stdioSecondTurn.toolCalls.some((call) => call.name === "codex-reply" && call.status === "completed"));
assert.ok(runnerTraceLabels(stdioSecondTurn).includes("session:reused"));
assert.ok(runnerTraceLabels(stdioSecondTurn).includes("prompt:sent"));
assert.ok(runnerTraceLabels(stdioSecondTurn).includes("tool:codex-reply: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");
@@ -361,349 +262,30 @@ async function runLocalContractSmoke() {
await rm(fakeCodex.root, { recursive: true, force: true });
}
}
const runnerSecondTurn = await handleCodeAgentChat(
{
conversationId: "cnv_code-agent-chat-runner-pwd",
traceId: "trc_code-agent-chat-runner-session-reuse",
message: "ls ."
},
{
now: () => "2026-05-22T00:02:01.000Z",
env: {
PATH: process.env.PATH,
HWLAB_CODE_AGENT_WORKSPACE: process.cwd()
}
const completedCodexPayload = {
conversationId: "cnv_code-agent-chat-stdio-http",
sessionId: "ses_code-agent-chat-stdio-http",
messageId: "msg_code-agent-chat-stdio-http",
status: "completed",
createdAt: "2026-05-22T00:05:00.000Z",
updatedAt: "2026-05-22T00:05:00.000Z",
traceId: "trc_code-agent-chat-stdio-http",
provider: "codex-stdio",
model: "gpt-5.5",
backend: "hwlab-cloud-api/codex-mcp-stdio",
runner: { kind: "codex-mcp-stdio-runner", codexStdio: true, writeCapable: true, durableSession: true },
sessionMode: "codex-mcp-stdio-long-lived",
implementationType: "repo-owned-codex-mcp-stdio-session",
capabilityLevel: "long-lived-codex-stdio-session",
reply: {
messageId: "msg_code-agent-chat-stdio-http",
role: "assistant",
content: "real stdio reply",
createdAt: "2026-05-22T00:05:00.000Z"
}
);
validateCodeAgentChatSchema(runnerSecondTurn);
assert.equal(runnerSecondTurn.status, "completed");
assert.equal(runnerSecondTurn.sessionId, runnerPwd.sessionId);
assert.equal(runnerSecondTurn.session.sessionId, runnerPwd.session.sessionId);
assert.equal(runnerSecondTurn.sessionReuse.reused, true);
assert.equal(runnerSecondTurn.sessionReuse.turn, 2);
assert.equal(runnerSecondTurn.session.lastTraceId, "trc_code-agent-chat-runner-session-reuse");
assert.equal(runnerSecondTurn.toolCalls[0].name, "ls");
assert.equal(runnerSecondTurn.toolCalls[0].status, "completed");
assert.match(runnerSecondTurn.reply.content, /package\.json/u);
logOk("same conversation reuses controlled read-only session registry");
const fallbackCapability = classifyCodexRunnerCapability(completedLivePayload, { httpStatus: 200 });
assert.equal(fallbackCapability.status, "blocked");
assert.equal(fallbackCapability.blocker, "openai-fallback-not-runner");
assert.equal(fallbackCapability.capabilityPass, false);
logOk("OpenAI fallback does not satisfy Codex runner capability");
const missingSkills = await handleCodeAgentChat(
{
conversationId: "cnv_code-agent-chat-missing-skills",
traceId: "trc_code-agent-chat-missing-skills",
message: "列出你可用的skills"
},
{
now: () => "2026-05-22T00:03:00.000Z",
env: {
PATH: process.env.PATH,
HWLAB_CODE_AGENT_WORKSPACE: process.cwd(),
HWLAB_CODE_AGENT_SKILLS_DIRS: "/tmp/hwlab-code-agent-smoke-missing-skills"
},
skillsDirs: ["/tmp/hwlab-code-agent-smoke-missing-skills"],
skillsDirsExact: true
}
);
validateCodeAgentChatSchema(missingSkills);
assert.equal(missingSkills.status, "failed");
assert.equal(missingSkills.error.code, "skills_unavailable");
assert.equal(missingSkills.skills.status, "blocked");
assert.equal(missingSkills.skills.blockers[0].sourceIssue, "pikasTech/HWLAB#136");
assert.equal(classifyCodexRunnerCapability(missingSkills, { httpStatus: 200 }).capabilityPass, false);
logOk("missing skills is structured blocker");
const boundedCat = await handleCodeAgentChat(
{
conversationId: "cnv_code-agent-chat-cat",
traceId: "trc_code-agent-chat-cat",
message: "请用cat读取 package.json"
},
{
now: () => "2026-05-22T00:04:00.000Z",
env: {
PATH: process.env.PATH,
HWLAB_CODE_AGENT_WORKSPACE: process.cwd()
}
}
);
validateCodeAgentChatSchema(boundedCat);
assert.equal(boundedCat.status, "completed");
assert.equal(boundedCat.toolCalls[0].name, "cat");
assert.equal(boundedCat.toolCalls[0].status, "completed");
assert.ok(boundedCat.toolCalls[0].stdout.length <= 4100);
assert.match(boundedCat.reply.content, /"name": "hwlab"/u);
logOk("bounded cat read-only tool capability");
const boundedRgFiles = await handleCodeAgentChat(
{
conversationId: "cnv_code-agent-chat-rg-files",
traceId: "trc_code-agent-chat-rg-files",
message: "rg --files ."
},
{
now: () => "2026-05-22T00:04:30.000Z",
env: {
PATH: process.env.PATH,
HWLAB_CODE_AGENT_WORKSPACE: process.cwd()
}
}
);
validateCodeAgentChatSchema(boundedRgFiles);
assert.equal(boundedRgFiles.status, "completed");
assert.equal(boundedRgFiles.toolCalls[0].name, "rg --files");
assert.equal(boundedRgFiles.toolCalls[0].status, "completed");
assert.ok(boundedRgFiles.toolCalls[0].stdout.length <= 4100);
assert.match(boundedRgFiles.reply.content, /受控只读 rg --files 结果/u);
logOk("bounded rg --files read-only tool capability");
const toolUnavailable = await handleCodeAgentChat(
{
conversationId: "cnv_code-agent-chat-tool-unavailable",
traceId: "trc_code-agent-chat-tool-unavailable",
message: "请用grep搜索 package.json"
},
{
now: () => "2026-05-22T00:04:40.000Z",
env: {
PATH: process.env.PATH,
HWLAB_CODE_AGENT_WORKSPACE: process.cwd()
}
}
);
validateCodeAgentChatSchema(toolUnavailable);
assert.equal(toolUnavailable.status, "failed");
assert.equal(toolUnavailable.error.code, "tool_unavailable");
assert.equal(toolUnavailable.toolCalls[0].status, "blocked");
assert.equal(classifyCodexRunnerCapability(toolUnavailable, { httpStatus: 200 }).capabilityPass, false);
logOk("tool unavailable is blocked, not completed runner capability");
const securityBlocked = await handleCodeAgentChat(
{
conversationId: "cnv_code-agent-chat-security-blocked",
traceId: "trc_code-agent-chat-security-blocked",
message: "请cat ../secret"
},
{
now: () => "2026-05-22T00:04:50.000Z",
env: {
PATH: process.env.PATH,
HWLAB_CODE_AGENT_WORKSPACE: process.cwd()
}
}
);
validateCodeAgentChatSchema(securityBlocked);
assert.equal(securityBlocked.status, "failed");
assert.equal(securityBlocked.error.code, "security_blocked");
assert.equal(securityBlocked.toolCalls[0].status, "blocked");
assert.equal(classifyCodexRunnerCapability(securityBlocked, { httpStatus: 200 }).capabilityPass, false);
logOk("security blocked path is structured");
const m3SkillCalls = [];
const m3SkillWrite = await handleCodeAgentChat(
{
conversationId: "cnv_code-agent-chat-m3-skill",
traceId: "trc_code-agent-chat-m3-skill",
message: "通过 HWLAB API 把 res_boxsimu_1 的 DO1 写成 true，然后读取 res_boxsimu_2 的 DI1。"
},
{
now: () => "2026-05-22T00:04:55.000Z",
env: {
PATH: process.env.PATH,
HWLAB_CODE_AGENT_WORKSPACE: process.cwd(),
HWLAB_CODE_AGENT_HWLAB_API_BASE_URL: "http://hwlab-cloud-api.hwlab-dev.svc.cluster.local:6667",
OPENAI_API_KEY: "must-not-be-used"
},
callProvider: async () => {
throw new Error("OpenAI fallback must not be used for M3 IO");
},
m3IoSkillRequestJson: async (url, request) => {
m3SkillCalls.push({ url, request });
return {
ok: true,
status: 200,
body: {
status: "succeeded",
accepted: true,
action: "do.write",
traceId: "trc_code-agent-chat-m3-skill",
operationId: "op_m3_do_write_smoke",
auditId: "aud_m3_do_write_smoke_succeeded",
evidenceId: "evd_m3_do_write_smoke_succeeded",
auditState: {
status: "written_non_durable"
},
evidenceState: {
status: "blocked",
sourceKind: "BLOCKED",
blocker: "runtime_durable_not_green",
writeStatus: "written_non_durable"
},
durableStatus: {
status: "degraded",
durable: false,
blocker: "runtime_durable_not_green"
},
result: {
value: true,
targetReadback: {
status: "succeeded",
value: true
}
},
controlPath: {
cloudApi: true,
gatewaySimu: true,
boxSimu: true,
patchPanel: true,
frontendBypass: false
}
}
};
}
}
);
validateCodeAgentChatSchema(m3SkillWrite);
assert.equal(m3SkillWrite.status, "completed");
assert.equal(m3SkillWrite.provider, "hwlab-skill-cli");
assert.equal(m3SkillWrite.toolCalls[0].name, "hwlab-agent-runtime.m3-io");
assert.equal(m3SkillWrite.toolCalls[0].route, "/v1/m3/io");
assert.equal(m3SkillWrite.toolCalls[0].method, "POST");
assert.equal(m3SkillWrite.toolCalls[0].operationId, "op_m3_do_write_smoke");
assert.equal(m3SkillWrite.toolCalls[0].auditId, "aud_m3_do_write_smoke_succeeded");
assert.equal(m3SkillWrite.toolCalls[0].evidenceId, "evd_m3_do_write_smoke_succeeded");
assert.equal(m3SkillWrite.toolCalls[0].readback.value, true);
assert.equal(m3SkillWrite.providerTrace.fallbackUsed, false);
assert.equal(m3SkillWrite.providerTrace.method, "POST");
assert.equal(m3SkillWrite.providerTrace.readback.value, true);
assert.equal(m3SkillWrite.runner.safety.directGatewayCallsAllowed, false);
assert.match(m3SkillWrite.reply.content, /HWLAB API \/v1\/m3\/io/u);
assert.match(m3SkillWrite.reply.content, /res_boxsimu_1:DO1=true/u);
assert.match(m3SkillWrite.reply.content, /res_boxsimu_2:DI1=true/u);
assert.equal(m3SkillCalls.length, 1);
assert.equal(m3SkillCalls[0].url, "http://hwlab-cloud-api.hwlab-dev.svc.cluster.local:6667/v1/m3/io");
assert.equal(m3SkillCalls[0].request.body.action, "do.write");
assert.equal(m3SkillCalls[0].request.body.value, true);
assert.equal(m3SkillCalls[0].url.includes("gateway-simu"), false);
assert.equal(m3SkillCalls[0].url.includes("box-simu"), false);
assert.equal(m3SkillCalls[0].url.includes("patch-panel"), false);
logOk("M3 Skill CLI routes through HWLAB API only");
const m3SkillFalseCalls = [];
const m3SkillWriteFalse = await handleCodeAgentChat(
{
conversationId: "cnv_code-agent-chat-m3-skill-false",
traceId: "trc_code-agent-chat-m3-skill-false",
message: "通过 HWLAB API 把 res_boxsimu_1 的 DO1 写成 false，然后读取 res_boxsimu_2 的 DI1。"
},
{
now: () => "2026-05-22T00:04:56.000Z",
env: {
PATH: process.env.PATH,
HWLAB_CODE_AGENT_WORKSPACE: process.cwd(),
HWLAB_CODE_AGENT_HWLAB_API_BASE_URL: "http://hwlab-cloud-api.hwlab-dev.svc.cluster.local:6667",
OPENAI_API_KEY: "must-not-be-used"
},
callProvider: async () => {
throw new Error("OpenAI fallback must not be used for M3 IO");
},
m3IoSkillRequestJson: async (url, request) => {
m3SkillFalseCalls.push({ url, request });
return {
ok: true,
status: 200,
body: {
status: "succeeded",
accepted: true,
action: "do.write",
traceId: "trc_code-agent-chat-m3-skill-false",
operationId: "op_m3_do_write_false_smoke",
auditId: "aud_m3_do_write_false_smoke_succeeded",
evidenceId: "evd_m3_do_write_false_smoke_succeeded",
auditState: {
status: "written_non_durable"
},
evidenceState: {
status: "blocked",
sourceKind: "BLOCKED",
blocker: "runtime_durable_not_green",
writeStatus: "written_non_durable"
},
durableStatus: {
status: "degraded",
durable: false,
blocker: "runtime_durable_not_green"
},
result: {
value: false,
targetReadback: {
status: "succeeded",
value: false
}
},
controlPath: {
cloudApi: true,
gatewaySimu: true,
boxSimu: true,
patchPanel: true,
frontendBypass: false
}
}
};
}
}
);
validateCodeAgentChatSchema(m3SkillWriteFalse);
assert.equal(m3SkillWriteFalse.status, "completed");
assert.equal(m3SkillWriteFalse.provider, "hwlab-skill-cli");
assert.equal(m3SkillWriteFalse.toolCalls[0].route, "/v1/m3/io");
assert.equal(m3SkillWriteFalse.toolCalls[0].method, "POST");
assert.equal(m3SkillWriteFalse.toolCalls[0].operationId, "op_m3_do_write_false_smoke");
assert.equal(m3SkillWriteFalse.toolCalls[0].readback.value, false);
assert.equal(m3SkillWriteFalse.providerTrace.fallbackUsed, false);
assert.match(m3SkillWriteFalse.reply.content, /HWLAB API \/v1\/m3\/io/u);
assert.match(m3SkillWriteFalse.reply.content, /res_boxsimu_1:DO1=false/u);
assert.match(m3SkillWriteFalse.reply.content, /res_boxsimu_2:DI1=false/u);
assert.equal(m3SkillFalseCalls.length, 1);
assert.equal(m3SkillFalseCalls[0].url, "http://hwlab-cloud-api.hwlab-dev.svc.cluster.local:6667/v1/m3/io");
assert.equal(m3SkillFalseCalls[0].request.body.action, "do.write");
assert.equal(m3SkillFalseCalls[0].request.body.value, false);
logOk("M3 Skill CLI handles user-direct false request through HWLAB API only");
const directToolCallPayload = JSON.parse(JSON.stringify(m3SkillWrite));
directToolCallPayload.toolCalls[0].hwlabApi = {
route: "/v1/m3/io",
redactedUrl: "http://hwlab-gateway-simu-1.hwlab-dev.svc.cluster.local:7101/v1/m3/io"
};
assert.throws(
() => validateCodeAgentChatSchema(directToolCallPayload),
/direct gateway\/box\/patch-panel target/u
);
const missingRouteToolCallPayload = JSON.parse(JSON.stringify(m3SkillWrite));
delete missingRouteToolCallPayload.toolCalls[0].route;
missingRouteToolCallPayload.toolCalls[0].blocker = null;
missingRouteToolCallPayload.toolCalls[0].status = "completed";
assert.throws(
() => validateCodeAgentChatSchema(missingRouteToolCallPayload),
/must show route \/v1\/m3\/io/u
);
logOk("M3 toolCall schema rejects direct hardware URLs and missing route evidence");
const completedHttp200Readiness = classifyCodeAgentChatReadiness(completedLivePayload, { realDevLive: true, httpStatus: 200 });
assert.equal(completedHttp200Readiness.status, "blocked");
assert.equal(completedHttp200Readiness.devLiveReplyPass, false);
assert.equal(completedHttp200Readiness.blocker, "untrusted-completion");
logOk("HTTP 200 OpenAI fallback completion is not full Code Agent pass");
for (const status of [400, 401, 403, 429, 500, 502, 503, 504]) {
const readiness = classifyCodeAgentChatReadiness(completedLivePayload, { realDevLive: true, httpStatus: status });
const readiness = classifyCodeAgentChatReadiness(completedCodexPayload, { realDevLive: true, httpStatus: status });
assert.equal(readiness.status, "blocked", `HTTP ${status} must block`);
assert.equal(readiness.blocker, "provider-upstream", `HTTP ${status} blocker`);
assert.equal(readiness.providerStatus, status, `HTTP ${status} providerStatus`);