unidesk-code-queue-runner
664 lines
22 KiB
JavaScript
664 lines
22 KiB
JavaScript
import assert from "node:assert/strict";
|
||
import test from "node:test";
|
||
|
||
import { classifyCodeAgentStatusSummary } from "./code-agent-status.mjs";
|
||
|
||
const liveRevision = Object.freeze({
|
||
healthLive: {
|
||
ok: true,
|
||
status: 200,
|
||
data: {
|
||
serviceId: "hwlab-cloud-api",
|
||
status: "ok",
|
||
commitId: "7de6edd2c41f54e4265e822d2593fa67057fa41a"
|
||
}
|
||
}
|
||
});
|
||
|
||
test("summarizes long-lived Code Agent as green with current deployment revision only", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
live: liveRevision,
|
||
availability: {
|
||
status: "codex-stdio-feasible",
|
||
ready: true,
|
||
provider: "codex-stdio",
|
||
mode: "codex-stdio",
|
||
backend: "hwlab-cloud-api/codex-stdio",
|
||
capabilityLevel: "long-lived-codex-stdio-session",
|
||
sessionMode: "codex-app-server-stdio-long-lived",
|
||
implementationType: "repo-owned-codex-app-server-stdio-session",
|
||
session: {
|
||
status: "idle",
|
||
lastTraceId: "trc_ready"
|
||
},
|
||
runner: {
|
||
kind: "codex-app-server-stdio-runner",
|
||
codexStdio: true
|
||
},
|
||
longLivedSessionGate: {
|
||
status: "pass"
|
||
},
|
||
codexStdioFeasibility: {
|
||
canStartLongLivedCodexStdio: true
|
||
},
|
||
providerTrace: {
|
||
protocol: "codex-app-server-jsonrpc-stdio",
|
||
command: "codex app-server --listen stdio://",
|
||
terminalStatus: "completed",
|
||
wireApi: "responses"
|
||
}
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "long-lived-session");
|
||
assert.equal(summary.label, "长会话可用");
|
||
assert.equal(summary.tone, "ok");
|
||
assert.equal(summary.codeAgentStatus, "codex-stdio-feasible");
|
||
assert.equal(summary.providerModeBackend, "codex-stdio / codex-stdio / hwlab-cloud-api/codex-stdio");
|
||
assert.equal(summary.capabilityLevel, "long-lived-codex-stdio-session");
|
||
assert.equal(summary.sessionSummary, "codex-app-server-stdio-long-lived / idle / idle");
|
||
assert.equal(summary.sessionLifecycleStatus, "idle");
|
||
assert.match(summary.sessionLifecycleHint, /新会话已建立/u);
|
||
assert.equal(summary.runnerKind, "codex-app-server-stdio-runner");
|
||
assert.equal(summary.protocol, "codex-app-server-jsonrpc-stdio");
|
||
assert.equal(summary.implementationType, "repo-owned-codex-app-server-stdio-session");
|
||
assert.equal(summary.providerTraceCommand, "codex app-server --listen stdio://");
|
||
assert.equal(summary.providerTraceTerminalStatus, "completed");
|
||
assert.match(summary.runtimePathLabel, /repo-owned Codex app-server stdio/u);
|
||
assert.equal(summary.readinessBlockers.length, 0);
|
||
assert.equal(summary.lastTraceId, "trc_ready");
|
||
assert.equal(summary.deploymentRevision, "7de6edd2c41f");
|
||
assert.equal(Object.keys(summary.fields).includes("sourceMain"), false);
|
||
});
|
||
|
||
test("does not mark legacy MCP-shaped Codex stdio as app-server long-lived session", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
latestMessage: {
|
||
status: "completed",
|
||
provider: "codex-stdio",
|
||
backend: "hwlab-cloud-api/codex-mcp-stdio",
|
||
capabilityLevel: "long-lived-codex-stdio-session",
|
||
sessionMode: "codex-mcp-stdio-long-lived",
|
||
implementationType: "repo-owned-codex-mcp-stdio-session",
|
||
runner: {
|
||
kind: "codex-mcp-stdio-runner",
|
||
codexStdio: true
|
||
},
|
||
longLivedSessionGate: {
|
||
status: "pass",
|
||
pass: true
|
||
},
|
||
providerTrace: {
|
||
protocol: "mcp-jsonrpc-stdio",
|
||
command: "codex mcp-server",
|
||
terminalStatus: "completed"
|
||
},
|
||
traceId: "trc_mcp"
|
||
}
|
||
});
|
||
|
||
assert.notEqual(summary.kind, "long-lived-session");
|
||
assert.notEqual(summary.tone, "ok");
|
||
assert.equal(summary.runtimePathLabel, "DEGRADED：MCP/其他 runner");
|
||
});
|
||
|
||
test("summarizes Codex app-server stdio thread as reusable long-lived session", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
latestMessage: {
|
||
status: "completed",
|
||
provider: "codex-stdio",
|
||
mode: "codex-stdio",
|
||
backend: "hwlab-cloud-api/codex-app-server-stdio",
|
||
capabilityLevel: "long-lived-codex-stdio-session",
|
||
sessionMode: "codex-app-server-stdio-long-lived",
|
||
implementationType: "repo-owned-codex-app-server-stdio-session",
|
||
session: {
|
||
sessionId: "ses_app_server",
|
||
threadId: "thread_app_server",
|
||
status: "idle",
|
||
lastTraceId: "trc_app_server",
|
||
codexStdio: true
|
||
},
|
||
sessionReuse: {
|
||
sessionId: "ses_app_server",
|
||
threadId: "thread_app_server",
|
||
reused: true,
|
||
turn: 2
|
||
},
|
||
runner: {
|
||
kind: "codex-app-server-stdio-runner",
|
||
codexStdio: true,
|
||
writeCapable: true,
|
||
durableSession: true
|
||
},
|
||
longLivedSessionGate: {
|
||
status: "pass"
|
||
},
|
||
providerTrace: {
|
||
protocol: "codex-app-server-jsonrpc-stdio",
|
||
threadId: "thread_app_server",
|
||
terminalStatus: "completed"
|
||
}
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "long-lived-session");
|
||
assert.equal(summary.tone, "ok");
|
||
assert.equal(summary.sessionIdStatus, "ses_app_server / thread_app_server / idle / idle");
|
||
assert.equal(summary.sessionLifecycleLabel, "继续当前会话");
|
||
assert.match(summary.sessionLifecycleHint, /可继续当前会话/u);
|
||
assert.equal(summary.fields.threadId, "thread_app_server");
|
||
});
|
||
|
||
test("does not mark Codex stdio-shaped fields green without runner and gate evidence", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
availability: {
|
||
status: "partial",
|
||
ready: true,
|
||
provider: "openai-responses",
|
||
mode: "openai",
|
||
backend: "hwlab-cloud-api/openai-responses",
|
||
capabilityLevel: "long-lived-codex-stdio-session",
|
||
sessionMode: "codex-mcp-stdio-long-lived",
|
||
runner: {
|
||
kind: "openai-responses-fallback",
|
||
codexStdio: false,
|
||
writeCapable: false
|
||
},
|
||
longLivedSessionGate: {
|
||
status: "blocked",
|
||
pass: false,
|
||
blockers: [{ code: "openai_responses_fallback_not_session" }]
|
||
}
|
||
}
|
||
});
|
||
|
||
assert.notEqual(summary.kind, "long-lived-session");
|
||
assert.notEqual(summary.tone, "ok");
|
||
assert.equal(summary.readinessBlockers.includes("openai_responses_fallback_not_session"), true);
|
||
});
|
||
|
||
test("maps degraded readonly session tools to warning, not green", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
availability: {
|
||
status: "partial",
|
||
ready: false,
|
||
provider: "codex-readonly-runner",
|
||
backend: "hwlab-cloud-api/controlled-readonly-session-registry",
|
||
capabilityLevel: "read-only-session-tools",
|
||
sessionMode: "controlled-readonly-session-registry",
|
||
workspace: "/workspace/hwlab",
|
||
sandbox: "read-only",
|
||
session: {
|
||
sessionId: "ses_readonly",
|
||
status: "idle",
|
||
lastTraceId: "trc_readonly",
|
||
workspace: "/workspace/hwlab",
|
||
sandbox: "read-only",
|
||
runnerKind: "hwlab-readonly-runner",
|
||
sessionMode: "controlled-readonly-session-registry"
|
||
},
|
||
runner: {
|
||
kind: "hwlab-readonly-runner",
|
||
writeCapable: false
|
||
},
|
||
toolCalls: [{ name: "pwd", status: "completed" }],
|
||
skills: { status: "not_requested", count: 0 },
|
||
runnerTrace: {
|
||
traceId: "trc_readonly",
|
||
runnerKind: "hwlab-readonly-runner",
|
||
sessionMode: "controlled-readonly-session-registry",
|
||
turn: 1
|
||
},
|
||
blockers: [
|
||
{ code: "stdio_protocol_not_wired" }
|
||
]
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "read-only-session-tools");
|
||
assert.equal(summary.label, "只读长会话工具");
|
||
assert.equal(summary.tone, "warn");
|
||
assert.equal(summary.sessionId, "ses_readonly");
|
||
assert.equal(summary.sessionIdStatus, "ses_readonly / idle / idle");
|
||
assert.equal(summary.workspace, "/workspace/hwlab");
|
||
assert.equal(summary.sandbox, "read-only");
|
||
assert.equal(summary.runnerKind, "hwlab-readonly-runner");
|
||
assert.equal(summary.toolCalls, "1/1 pwd(completed)");
|
||
assert.equal(summary.skills, "not_requested:count=0");
|
||
assert.match(summary.runnerTrace, /runnerKind=hwlab-readonly-runner/u);
|
||
assert.equal(summary.readinessBlockers.includes("stdio_protocol_not_wired"), true);
|
||
assert.equal(summary.lastTraceId, "trc_readonly");
|
||
});
|
||
|
||
test("summarizes Codex runtimeContract blockers from health availability", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
availability: {
|
||
status: "partial",
|
||
ready: false,
|
||
provider: "codex-readonly-runner",
|
||
backend: "hwlab-cloud-api/codex-readonly-runner",
|
||
capabilityLevel: "read-only-session-tools",
|
||
sessionMode: "controlled-readonly-session-registry",
|
||
runner: {
|
||
kind: "hwlab-readonly-runner",
|
||
writeCapable: false
|
||
},
|
||
runtimeContract: {
|
||
binary: { status: "missing" },
|
||
lifecycleSupervisor: { status: "blocked" },
|
||
stdioProtocol: { status: "blocked" }
|
||
}
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "read-only-session-tools");
|
||
assert.equal(summary.tone, "warn");
|
||
assert.equal(summary.readinessBlockers.includes("codex_cli_binary_missing"), true);
|
||
assert.equal(summary.readinessBlockers.includes("runner_lifecycle_missing"), true);
|
||
assert.equal(summary.readinessBlockers.includes("stdio_protocol_not_wired"), true);
|
||
});
|
||
|
||
test("maps text fallback to warning with safe labels", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
availability: {
|
||
status: "available",
|
||
ready: true,
|
||
provider: "openai-responses",
|
||
mode: "openai",
|
||
backend: "hwlab-cloud-api/openai-responses",
|
||
capabilityLevel: "text-chat-only",
|
||
runner: {
|
||
kind: "openai-responses-fallback"
|
||
}
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "fallback-text-chat-only");
|
||
assert.equal(summary.label, "会话降级");
|
||
assert.equal(summary.tone, "warn");
|
||
assert.equal(summary.provider, "openai-responses");
|
||
assert.equal(summary.capabilityLevel, "text-chat-only");
|
||
assert.equal(summary.sessionLifecycleStatus, "failed");
|
||
assert.match(summary.sessionLifecycleHint, /fallback\/text-only\/read-only/u);
|
||
});
|
||
|
||
test("maps stateless one-shot runner separately from long-lived sessions", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
latestMessage: {
|
||
status: "completed",
|
||
provider: "codex-cli",
|
||
backend: "hwlab-cloud-api/codex-cli",
|
||
capabilityLevel: "text-chat-only",
|
||
sessionMode: "ephemeral-one-shot",
|
||
runner: {
|
||
kind: "codex-cli-one-shot-ephemeral"
|
||
},
|
||
runnerLimitations: ["one-shot", "not-durable-session"],
|
||
traceId: "trc_one_shot"
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "stateless-one-shot");
|
||
assert.equal(summary.label, "一次性执行");
|
||
assert.equal(summary.tone, "warn");
|
||
assert.equal(summary.sessionMode, "ephemeral-one-shot");
|
||
assert.equal(summary.lastTraceId, "trc_one_shot");
|
||
});
|
||
|
||
test("summarizes active Code Agent running request as pending with trace and session context", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
latestMessage: {
|
||
role: "agent",
|
||
status: "running",
|
||
sourceKind: "PENDING",
|
||
traceId: "trc_pending_heavy_skills",
|
||
conversationId: "cnv_pending_heavy_skills",
|
||
sessionId: "cnv_pending_heavy_skills"
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "busy");
|
||
assert.equal(summary.label, "会话忙/请等待");
|
||
assert.equal(summary.tone, "pending");
|
||
assert.equal(summary.codeAgentStatus, "running");
|
||
assert.equal(summary.sessionId, "cnv_pending_heavy_skills");
|
||
assert.equal(summary.sessionLifecycleStatus, "busy");
|
||
assert.match(summary.sessionLifecycleHint, /会话忙\/请等待/u);
|
||
assert.equal(summary.lastTraceId, "trc_pending_heavy_skills");
|
||
assert.equal(summary.readinessBlockers.length, 0);
|
||
});
|
||
|
||
test("summarizes canceled Code Agent request with preserved retry context", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
latestMessage: {
|
||
role: "agent",
|
||
status: "canceled",
|
||
traceId: "trc_cancel_keep_context",
|
||
conversationId: "cnv_cancel_keep_context",
|
||
sessionId: "ses_cancel_keep_context",
|
||
session: {
|
||
sessionId: "ses_cancel_keep_context",
|
||
status: "canceled"
|
||
},
|
||
runnerTrace: {
|
||
traceId: "trc_cancel_keep_context",
|
||
sessionStatus: "canceled",
|
||
lastEvent: {
|
||
type: "cancel",
|
||
label: "cancel:canceled",
|
||
status: "canceled"
|
||
}
|
||
},
|
||
error: {
|
||
code: "codex_stdio_canceled",
|
||
message: "请求已取消"
|
||
}
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "canceled");
|
||
assert.equal(summary.label, "请求已取消");
|
||
assert.equal(summary.tone, "blocked");
|
||
assert.equal(summary.codeAgentStatus, "canceled");
|
||
assert.equal(summary.sessionId, "ses_cancel_keep_context");
|
||
assert.equal(summary.sessionStatus, "canceled");
|
||
assert.equal(summary.sessionLifecycleStatus, "interrupted");
|
||
assert.match(summary.sessionLifecycleHint, /已中断/u);
|
||
assert.equal(summary.lastTraceId, "trc_cancel_keep_context");
|
||
});
|
||
|
||
test("summarizes timed out Code Agent request with preserved trace context", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
latestMessage: {
|
||
role: "agent",
|
||
status: "timeout",
|
||
traceId: "trc_timeout_keep_context",
|
||
conversationId: "cnv_timeout_keep_context",
|
||
sessionId: "ses_timeout_keep_context",
|
||
session: {
|
||
sessionId: "ses_timeout_keep_context",
|
||
status: "timeout"
|
||
},
|
||
runnerTrace: {
|
||
traceId: "trc_timeout_keep_context",
|
||
sessionStatus: "timeout",
|
||
lastEvent: {
|
||
type: "session",
|
||
label: "session:timeout",
|
||
status: "timeout"
|
||
}
|
||
},
|
||
error: {
|
||
code: "codex_stdio_timeout",
|
||
message: "请求超时"
|
||
}
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "timeout");
|
||
assert.equal(summary.label, "等待超时");
|
||
assert.equal(summary.tone, "blocked");
|
||
assert.equal(summary.codeAgentStatus, "timeout");
|
||
assert.equal(summary.sessionId, "ses_timeout_keep_context");
|
||
assert.equal(summary.sessionStatus, "timeout");
|
||
assert.equal(summary.sessionLifecycleStatus, "failed");
|
||
assert.equal(summary.lastTraceId, "trc_timeout_keep_context");
|
||
});
|
||
|
||
test("surfaces expired and failed Code Agent session lifecycle hints", () => {
|
||
const expired = classifyCodeAgentStatusSummary({
|
||
latestMessage: {
|
||
status: "failed",
|
||
provider: "codex-stdio",
|
||
session: {
|
||
sessionId: "ses_expired_ui",
|
||
status: "expired",
|
||
codexStdio: true
|
||
},
|
||
error: {
|
||
code: "session_expired"
|
||
}
|
||
}
|
||
});
|
||
assert.equal(expired.kind, "session-expired");
|
||
assert.equal(expired.label, "会话已过期");
|
||
assert.equal(expired.sessionLifecycleStatus, "expired");
|
||
assert.match(expired.sessionLifecycleHint, /重新发送建立新的 Code Agent session/u);
|
||
|
||
const failed = classifyCodeAgentStatusSummary({
|
||
latestMessage: {
|
||
status: "failed",
|
||
provider: "codex-stdio",
|
||
session: {
|
||
sessionId: "ses_failed_ui",
|
||
status: "failed",
|
||
codexStdio: true
|
||
},
|
||
error: {
|
||
code: "session_failed"
|
||
}
|
||
}
|
||
});
|
||
assert.equal(failed.kind, "session-failed");
|
||
assert.equal(failed.label, "会话失败");
|
||
assert.equal(failed.sessionLifecycleStatus, "failed");
|
||
assert.match(failed.sessionLifecycleHint, /需重新发送建立新会话/u);
|
||
});
|
||
|
||
test("missing Code Agent session evidence is shown as lifecycle degradation", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
latestMessage: {
|
||
status: "completed",
|
||
provider: "codex-stdio",
|
||
capabilityLevel: "long-lived-codex-stdio-session",
|
||
sessionMode: "codex-app-server-stdio-long-lived",
|
||
implementationType: "repo-owned-codex-app-server-stdio-session",
|
||
runner: {
|
||
kind: "codex-app-server-stdio-runner",
|
||
codexStdio: true,
|
||
writeCapable: true
|
||
},
|
||
blocker: {
|
||
code: "code_agent_session_evidence_missing"
|
||
}
|
||
}
|
||
});
|
||
|
||
assert.notEqual(summary.tone, "ok");
|
||
assert.equal(summary.sessionLifecycleLabel, "会话降级");
|
||
assert.match(summary.sessionLifecycleHint, /会话证据不完整/u);
|
||
});
|
||
|
||
test("maps HWLAB Skill CLI API control to distinct green state when ready", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
latestMessage: {
|
||
status: "completed",
|
||
provider: "hwlab-skill-cli",
|
||
backend: "hwlab-cloud-api/hwlab-agent-runtime-skill-cli",
|
||
capabilityLevel: "hwlab-api-control-ready",
|
||
sessionMode: "controlled-m3-io-skill-cli",
|
||
session: {
|
||
status: "idle",
|
||
lastTraceId: "trc_skill"
|
||
},
|
||
toolCalls: [
|
||
{
|
||
type: "skill-cli",
|
||
route: "/v1/m3/io",
|
||
status: "completed",
|
||
controlReady: true
|
||
}
|
||
],
|
||
providerTrace: {
|
||
controlReady: true
|
||
}
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "skill-cli-api-control");
|
||
assert.equal(summary.label, "HWLAB Skill CLI 控制");
|
||
assert.equal(summary.tone, "ok");
|
||
assert.equal(summary.provider, "hwlab-skill-cli");
|
||
assert.equal(summary.capabilityLevel, "hwlab-api-control-ready");
|
||
});
|
||
|
||
test("maps blockers to blocked tone and redacts secret-like fields", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
availability: {
|
||
status: "blocked",
|
||
ready: false,
|
||
provider: "openai-responses",
|
||
backend: "Secret hwlab-code-agent-provider should not show",
|
||
capabilityLevel: "blocked",
|
||
reason: "OPENAI_API_KEY_missing",
|
||
error: {
|
||
code: "provider_unavailable",
|
||
providerStatus: 503
|
||
},
|
||
missingEnv: ["OPENAI_API_KEY"],
|
||
traceId: "trc_blocked"
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "blocked");
|
||
assert.equal(summary.label, "服务受阻");
|
||
assert.equal(summary.tone, "blocked");
|
||
assert.equal(summary.backend, "已隐藏");
|
||
assert.equal(summary.readinessBlockers.includes("provider_config_blocked"), true);
|
||
assert.equal(summary.readinessBlockers.includes("provider_unavailable"), true);
|
||
assert.equal(summary.readinessBlockers.includes("provider_http_503"), true);
|
||
assert.equal(summary.lastTraceId, "trc_blocked");
|
||
});
|
||
|
||
test("uses structured readiness current blockers and ignores stale provider blockers", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
live: {
|
||
restIndex: {
|
||
ok: true,
|
||
status: 200,
|
||
data: {
|
||
readiness: {
|
||
codeAgent: {
|
||
status: "blocked",
|
||
ready: false,
|
||
providerReady: true,
|
||
durableDbReady: true,
|
||
sessionRunnerReady: true,
|
||
codexStdioFeasible: false,
|
||
currentBlocker: "codex_stdio_supervisor_disabled",
|
||
currentBlockers: ["codex_stdio_supervisor_disabled"],
|
||
provider: {
|
||
status: "ready",
|
||
ready: true,
|
||
provider: "openai-responses",
|
||
backend: "hwlab-cloud-api/openai-responses",
|
||
mode: "openai",
|
||
blocker: null
|
||
},
|
||
dbDurable: {
|
||
status: "ready",
|
||
ready: true,
|
||
adapter: "postgres",
|
||
blocker: null,
|
||
queryResult: "durable_readiness_ready"
|
||
},
|
||
sessionRunner: {
|
||
status: "read_only_long_lived_ready",
|
||
ready: true,
|
||
kind: "hwlab-readonly-runner",
|
||
mode: "controlled-readonly-session-registry",
|
||
capabilityLevel: "read-only-session-tools",
|
||
longLivedSession: true,
|
||
durableSession: false,
|
||
codexStdio: false,
|
||
writeCapable: false,
|
||
blocker: null
|
||
},
|
||
codexStdio: {
|
||
status: "blocked",
|
||
ready: false,
|
||
feasible: false,
|
||
blocker: "codex_stdio_supervisor_disabled",
|
||
blockerCodes: ["codex_stdio_supervisor_disabled"]
|
||
}
|
||
}
|
||
},
|
||
codeAgent: {
|
||
status: "partial",
|
||
ready: false,
|
||
provider: "openai-responses",
|
||
backend: "hwlab-cloud-api/openai-responses",
|
||
capabilityLevel: "read-only-session-tools",
|
||
blockerCodes: [
|
||
"provider_unavailable",
|
||
"runtime_durable_adapter_auth_blocked"
|
||
]
|
||
}
|
||
}
|
||
}
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "read-only-session-tools");
|
||
assert.equal(summary.tone, "warn");
|
||
assert.equal(summary.provider, "openai-responses");
|
||
assert.equal(summary.capabilityLevel, "read-only-session-tools");
|
||
assert.deepEqual(summary.readinessBlockers, ["codex_stdio_supervisor_disabled"]);
|
||
assert.equal(summary.readinessBlockers.includes("provider_unavailable"), false);
|
||
assert.equal(summary.readinessBlockers.includes("runtime_durable_adapter_auth_blocked"), false);
|
||
});
|
||
|
||
test("structured readiness without codeAgent payload degrades into blocked status", () => {
|
||
const summary = classifyCodeAgentStatusSummary({
|
||
live: {
|
||
healthLive: {
|
||
ok: true,
|
||
status: 200,
|
||
data: {
|
||
readiness: {
|
||
codeAgent: {
|
||
status: "blocked",
|
||
ready: false,
|
||
providerReady: false,
|
||
durableDbReady: true,
|
||
sessionRunnerReady: false,
|
||
codexStdioFeasible: false,
|
||
currentBlocker: "provider_config_blocked",
|
||
currentBlockers: ["provider_config_blocked"],
|
||
provider: {
|
||
status: "blocked",
|
||
ready: false,
|
||
provider: "openai-responses",
|
||
backend: "hwlab-cloud-api/openai-responses",
|
||
mode: "openai",
|
||
blocker: "provider_config_blocked"
|
||
},
|
||
sessionRunner: {
|
||
status: "blocked",
|
||
ready: false,
|
||
kind: "unknown",
|
||
mode: "unknown",
|
||
capabilityLevel: "blocked",
|
||
blocker: "session_runner_blocked"
|
||
},
|
||
codexStdio: {
|
||
status: "blocked",
|
||
ready: false,
|
||
blocker: "codex_stdio_supervisor_disabled",
|
||
blockerCodes: ["codex_stdio_supervisor_disabled"]
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
});
|
||
|
||
assert.equal(summary.kind, "blocked");
|
||
assert.equal(summary.label, "服务受阻");
|
||
assert.equal(summary.tone, "blocked");
|
||
assert.equal(summary.readinessBlockers.includes("provider_config_blocked"), true);
|
||
assert.equal(summary.provider, "openai-responses");
|
||
});
|