root
271 lines
15 KiB
TypeScript
271 lines
15 KiB
TypeScript
import { mkdtemp, readFile, rm } from "node:fs/promises";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
|
|
import { afterEach, expect, test } from "bun:test";
|
|
|
|
import { createNativeAgentRunWorkbenchApplication } from "./native-agentrun-application.ts";
|
|
|
|
const temporaryDirectories: string[] = [];
|
|
|
|
afterEach(async () => {
|
|
await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { force: true, recursive: true })));
|
|
});
|
|
|
|
test("L1 AgentRun application dispatches gpt.pika without polling or projecting a terminal result", async () => {
|
|
const directory = await mkdtemp(path.join(os.tmpdir(), "hwlab-workbench-agentrun-"));
|
|
temporaryDirectories.push(directory);
|
|
const stateFile = path.join(directory, "state.json");
|
|
const calls: Array<{ method: string; path: string; authorization: string | null; body: any }> = [];
|
|
const app = createNativeAgentRunWorkbenchApplication({
|
|
stateFile,
|
|
env: agentRunEnvironment(),
|
|
fetchImpl: fakeAgentRunManager(calls),
|
|
now: () => "2026-07-20T01:13:12.232Z",
|
|
});
|
|
|
|
const created = await app.createSession({ actor: { id: "usr_native", role: "user" }, params: { providerProfile: "gpt.pika" } });
|
|
const models = await app.providerModelCatalog!("gpt.pika");
|
|
expect(models).toMatchObject({ status: "ok", profile: "gpt.pika", defaultModel: "gpt-5.6", reasoningEfforts: ["low", "medium", "high", "xhigh"] });
|
|
const session = created.session as Record<string, any>;
|
|
const input = {
|
|
actor: { id: "usr_native", role: "user" },
|
|
traceId: "trc_l1_gpt_pika_smoke",
|
|
sessionId: session.sessionId,
|
|
params: { message: "hi", submittedAt: "2026-07-20T01:13:07.699Z", providerProfile: "gpt.pika", model: "gpt-5.6", reasoningEffort: "high" },
|
|
};
|
|
const admitted = await app.admitTurn(input);
|
|
const result = await app.dispatchTurn(admitted);
|
|
const steered = await app.steerTurn({
|
|
actor: input.actor,
|
|
sessionId: input.sessionId,
|
|
targetTraceId: input.traceId,
|
|
steerTraceId: "trc_steer_l1_gpt_pika",
|
|
params: { message: "adjust course", submittedAt: "2026-07-20T01:14:07.699Z", sessionId: input.sessionId, targetTraceId: input.traceId, steerTraceId: "trc_steer_l1_gpt_pika" }
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
status: "running",
|
|
terminal: false,
|
|
terminalAuthority: "hwlab.event.v1",
|
|
resultSynthesized: false,
|
|
agentRun: {
|
|
runId: "run_l1_gpt_pika",
|
|
commandId: "cmd_l1_gpt_pika",
|
|
runnerJobId: "rjob_l1_gpt_pika",
|
|
},
|
|
});
|
|
const state = JSON.parse(await readFile(stateFile, "utf8"));
|
|
expect(state.turns[input.traceId]).toMatchObject({
|
|
status: "running",
|
|
createdAt: "2026-07-20T01:13:07.699Z",
|
|
terminal: false,
|
|
runId: "run_l1_gpt_pika",
|
|
commandId: "cmd_l1_gpt_pika",
|
|
runnerJobId: "rjob_l1_gpt_pika",
|
|
});
|
|
expect(state.turns[input.traceId]).not.toHaveProperty("result");
|
|
expect(state.turns[input.traceId]).not.toHaveProperty("finalResponse");
|
|
expect(state.sessions[session.sessionId]).toMatchObject({ status: "running", providerProfile: "gpt.pika" });
|
|
expect(state.sessions[session.sessionId].messages).toHaveLength(1);
|
|
expect(steered).toMatchObject({ accepted: true, status: "running", traceId: "trc_steer_l1_gpt_pika", targetTraceId: input.traceId, steerTraceId: "trc_steer_l1_gpt_pika", requestedDelivery: "steer", delivery: "steer", agentRun: { steerCommandId: "cmd_l1_gpt_pika_steer", targetCommandId: "cmd_l1_gpt_pika" } });
|
|
expect(`${calls[0]?.method} ${calls[0]?.path}`).toBe("GET /api/v1/provider-profiles/gpt-pika/models");
|
|
expect(`${calls[1]?.method} ${calls[1]?.path}`).toMatch(/^GET \/api\/v1\/sessions\/ses_agentrun_/);
|
|
expect(calls.slice(2, 5).map((call) => `${call.method} ${call.path}`)).toEqual([
|
|
"POST /api/v1/sessions",
|
|
"POST /api/v1/runs",
|
|
"POST /api/v1/runs/run_l1_gpt_pika/commands",
|
|
]);
|
|
expect(`${calls[5]?.method} ${calls[5]?.path}`).toMatch(/^POST \/api\/v1\/sessions\/ses_agentrun_[A-Za-z0-9_]+\/send$/);
|
|
expect(calls.every((call) => call.authorization === "Bearer test-agentrun-key")).toBe(true);
|
|
});
|
|
|
|
test("L0 requested steer resolved to a turn persists the actual control trace", async () => {
|
|
const directory = await mkdtemp(path.join(os.tmpdir(), "hwlab-workbench-agentrun-steer-turn-"));
|
|
temporaryDirectories.push(directory);
|
|
const stateFile = path.join(directory, "state.json");
|
|
const calls: Array<{ method: string; path: string; authorization: string | null; body: any }> = [];
|
|
const app = createNativeAgentRunWorkbenchApplication({
|
|
stateFile,
|
|
env: agentRunEnvironment(),
|
|
fetchImpl: fakeAgentRunManager(calls, "turn"),
|
|
now: () => "2026-07-20T01:15:12.232Z",
|
|
});
|
|
const created = await app.createSession({ actor: { id: "usr_native", role: "user" }, params: { providerProfile: "gpt.pika" } });
|
|
const session = created.session as Record<string, any>;
|
|
const input = await app.admitTurn({
|
|
actor: { id: "usr_native", role: "user" },
|
|
traceId: "trc_l1_gpt_pika_smoke",
|
|
sessionId: session.sessionId,
|
|
params: { message: "first", submittedAt: "2026-07-20T01:13:07.699Z", providerProfile: "gpt.pika" },
|
|
});
|
|
await app.dispatchTurn(input);
|
|
const result = await app.steerTurn({
|
|
actor: input.actor,
|
|
sessionId: input.sessionId,
|
|
targetTraceId: input.traceId,
|
|
steerTraceId: "trc_actual_followup_turn",
|
|
params: { message: "continue after terminal", submittedAt: "2026-07-20T01:15:07.699Z" },
|
|
});
|
|
|
|
expect(result).toMatchObject({ traceId: "trc_actual_followup_turn", targetTraceId: input.traceId, requestedDelivery: "steer", delivery: "turn", agentRun: { runId: "run_actual_followup_turn", commandId: "cmd_actual_followup_turn" } });
|
|
const state = await app.snapshot!();
|
|
expect(state.turns[input.traceId]).toMatchObject({ traceId: input.traceId, commandId: "cmd_l1_gpt_pika" });
|
|
expect(state.turns.trc_actual_followup_turn).toMatchObject({ traceId: "trc_actual_followup_turn", targetTraceId: input.traceId, requestedDelivery: "steer", delivery: "turn", status: "running", runId: "run_actual_followup_turn", commandId: "cmd_actual_followup_turn" });
|
|
expect(state.sessions[input.sessionId]).toMatchObject({ lastTraceId: "trc_actual_followup_turn", status: "running" });
|
|
});
|
|
|
|
test("L1 AgentRun application leaves dispatch failures to Temporal instead of projecting a terminal snapshot", async () => {
|
|
const directory = await mkdtemp(path.join(os.tmpdir(), "hwlab-workbench-agentrun-failure-"));
|
|
temporaryDirectories.push(directory);
|
|
const stateFile = path.join(directory, "state.json");
|
|
const app = createNativeAgentRunWorkbenchApplication({
|
|
stateFile,
|
|
env: agentRunEnvironment(),
|
|
fetchImpl: (async () => Response.json({ ok: false, failureKind: "manager-unavailable", message: "manager unavailable" }, { status: 503 })) as typeof fetch,
|
|
});
|
|
const created = await app.createSession({ actor: { id: "usr_native" }, params: { providerProfile: "gpt.pika" } });
|
|
const session = created.session as Record<string, any>;
|
|
const input = await app.admitTurn({
|
|
actor: { id: "usr_native" },
|
|
traceId: "trc_l1_manager_failure",
|
|
sessionId: session.sessionId,
|
|
params: { message: "hi", providerProfile: "gpt.pika" },
|
|
});
|
|
|
|
await expect(app.dispatchTurn(input)).rejects.toMatchObject({ code: "manager-unavailable" });
|
|
expect((await app.snapshot!()).turns[input.traceId]).toMatchObject({ status: "admitted", terminal: false });
|
|
});
|
|
|
|
test("L0 publishes admission, bounded ConnectionRefused retry, and semantic terminal failure to Kafka authority", async () => {
|
|
const directory = await mkdtemp(path.join(os.tmpdir(), "hwlab-workbench-agentrun-visible-failure-"));
|
|
temporaryDirectories.push(directory);
|
|
const published: Array<Record<string, any>> = [];
|
|
let runCreateAttempts = 0;
|
|
const app = createNativeAgentRunWorkbenchApplication({
|
|
stateFile: path.join(directory, "state.json"),
|
|
env: agentRunEnvironment(),
|
|
eventPublisher: {
|
|
async publish(input) { published.push(input); return { published: true }; },
|
|
},
|
|
fetchImpl: (async (request) => {
|
|
const url = new URL(String(request));
|
|
if (url.pathname === "/api/v1/sessions") {
|
|
return Response.json({ ok: true, data: { session: { id: "ses_agentrun_l0_visible_failure", metadata: {} } } });
|
|
}
|
|
if (url.pathname === "/api/v1/runs") runCreateAttempts += 1;
|
|
throw Object.assign(new Error("Unable to connect. Is the computer able to access the url?"), { code: "ConnectionRefused" });
|
|
}) as typeof fetch,
|
|
now: () => "2026-07-20T11:45:01.000Z",
|
|
});
|
|
const created = await app.createSession({ actor: { id: "usr_native" }, params: { providerProfile: "gpt.pika" } });
|
|
const session = created.session as Record<string, any>;
|
|
const input = await app.admitTurn({
|
|
actor: { id: "usr_native" },
|
|
traceId: "trc_l0_connection_refused",
|
|
sessionId: session.sessionId,
|
|
params: { message: "hi", providerProfile: "gpt.pika" },
|
|
});
|
|
|
|
await expect(app.dispatchTurn(input)).rejects.toMatchObject({
|
|
failureKind: "connection-refused",
|
|
retryable: true,
|
|
retryExhausted: true,
|
|
retryAttempt: 1,
|
|
});
|
|
expect(runCreateAttempts).toBe(2);
|
|
expect(published[0]?.event.type).toBe("backend_status");
|
|
expect(published.filter((item) => item.event.type === "error")).toHaveLength(1);
|
|
expect(published.filter((item) => item.event.type === "terminal_status")).toHaveLength(1);
|
|
expect(published[0]?.event).toMatchObject({ phase: "request-admitted", summary: "请求已接纳，正在启动 AgentRun" });
|
|
expect(published.find((item) => item.event.retryPhase === "retryScheduled" && item.event.component === "agentrun-manager")?.event).toMatchObject({
|
|
retryPhase: "retryScheduled",
|
|
failureDomain: "infrastructure",
|
|
component: "agentrun-manager",
|
|
code: "connection-refused",
|
|
attempt: 1,
|
|
maxAttempts: 1,
|
|
});
|
|
expect(published.find((item) => item.event.type === "error")?.event).toMatchObject({ retryPhase: "retryExhausted", summary: "AgentRun 服务暂时不可达" });
|
|
expect(published.find((item) => item.event.type === "terminal_status")?.event).toMatchObject({ terminalStatus: "failed", failureKind: "connection-refused", terminal: true });
|
|
expect(published.every((item) => item.traceId === input.traceId && item.sessionId === input.sessionId)).toBe(true);
|
|
});
|
|
|
|
function agentRunEnvironment(): Record<string, string> {
|
|
return {
|
|
WORKBENCH_MODE: "agentrun-native",
|
|
AGENTRUN_MGR_URL: "http://127.0.0.1:65535",
|
|
AGENTRUN_API_KEY: "test-agentrun-key",
|
|
HWLAB_CODE_AGENT_AGENTRUN_ALLOW_NON_K3S_URL: "1",
|
|
HWLAB_CODE_AGENT_AGENTRUN_PROVIDER_ID: "NC01",
|
|
HWLAB_CODE_AGENT_AGENTRUN_GPT_PIKA_SECRET_NAME: "provider-gpt-pika",
|
|
HWLAB_CODE_AGENT_AGENTRUN_GITHUB_TOOL_SECRET_NAME: "agentrun-test-tool-github-pr",
|
|
HWLAB_CODE_AGENT_AGENTRUN_UNIDESK_SSH_TOOL_SECRET_NAME: "agentrun-test-tool-unidesk-ssh",
|
|
HWLAB_CODE_AGENT_AGENTRUN_SOURCE_COMMIT: "0123456789abcdef0123456789abcdef01234567",
|
|
HWLAB_CODE_AGENT_AGENTRUN_REPO_URL: "http://git-mirror-http.devops-infra.svc.cluster.local/pikasTech/HWLAB.git",
|
|
HWLAB_CODE_AGENT_DEFAULT_PROVIDER_PROFILE: "gpt.pika",
|
|
HWLAB_CODE_AGENT_AGENTRUN_RUNNER_NAMESPACE: "agentrun-v02",
|
|
HWLAB_CODE_AGENT_AGENTRUN_DISPATCH_RETRY_MAX: "1",
|
|
HWLAB_CODE_AGENT_AGENTRUN_DISPATCH_RETRY_BASE_MS: "1",
|
|
HWLAB_CODE_AGENT_AGENTRUN_DISPATCH_RETRY_MAX_DELAY_MS: "1",
|
|
HWLAB_RUNTIME_API_URL: "http://hwlab-cloud-api.hwlab-v03.svc.cluster.local:6667",
|
|
HWLAB_RUNTIME_WEB_URL: "http://hwlab-cloud-web.hwlab-v03.svc.cluster.local:8080",
|
|
HWLAB_RUNTIME_NAMESPACE: "hwlab-v03",
|
|
HWLAB_RUNTIME_LANE: "v03",
|
|
HWLAB_RUNTIME_ENDPOINT_LOCKED: "1",
|
|
HWLAB_CODE_AGENT_ASSEMBLED_RUNTIME: "1",
|
|
};
|
|
}
|
|
|
|
function fakeAgentRunManager(calls: Array<{ method: string; path: string; authorization: string | null; body: any }>, steerDelivery: "steer" | "turn" = "steer"): typeof fetch {
|
|
return (async (input: string | URL | Request, init: RequestInit = {}) => {
|
|
const url = new URL(String(input));
|
|
const method = init.method ?? "GET";
|
|
const body = init.body ? JSON.parse(String(init.body)) : null;
|
|
calls.push({ method, path: url.pathname, authorization: new Headers(init.headers).get("authorization"), body });
|
|
const send = (data: unknown) => Response.json({ ok: true, data });
|
|
if (method === "GET" && url.pathname === "/api/v1/provider-profiles/gpt-pika/models") {
|
|
return send({ status: "ok", profile: "gpt-pika", source: "upstream", items: [{ id: "gpt-5.6" }, { id: "gpt-5.5" }], defaultModel: "gpt-5.6", reasoningEfforts: ["low", "medium", "high", "xhigh"], defaultReasoningEffort: "medium", warning: null, valuesPrinted: false });
|
|
}
|
|
if (method === "POST" && url.pathname === "/api/v1/sessions") {
|
|
return send({ session: { id: "ses_agentrun_l1_gpt_pika", metadata: {} } });
|
|
}
|
|
if (method === "POST" && url.pathname === "/api/v1/runs") {
|
|
expect(body.backendProfile).toBe("gpt-pika");
|
|
return send({ id: "run_l1_gpt_pika", status: "pending", sessionRef: body.sessionRef, backendProfile: body.backendProfile });
|
|
}
|
|
if (method === "POST" && url.pathname === "/api/v1/runs/run_l1_gpt_pika/commands") {
|
|
expect(["hi", "first"]).toContain(body.payload.prompt);
|
|
expect(body.payload.submittedAt).toBe("2026-07-20T01:13:07.699Z");
|
|
if (body.payload.prompt === "hi") {
|
|
expect(body.payload.model).toBe("gpt-5.6");
|
|
expect(body.payload.reasoningEffort).toBe("high");
|
|
}
|
|
return send({
|
|
id: "cmd_l1_gpt_pika",
|
|
runId: "run_l1_gpt_pika",
|
|
state: "pending",
|
|
type: "turn",
|
|
seq: 1,
|
|
dispatchIntent: { id: "dispatch_l1_gpt_pika", state: "pending", runnerJobId: "rjob_l1_gpt_pika", attemptCount: 0, durable: true },
|
|
});
|
|
}
|
|
if (method === "POST" && /^\/api\/v1\/sessions\/ses_agentrun_[A-Za-z0-9_]+\/send$/u.test(url.pathname)) {
|
|
expect(body.payload.requestedDelivery).toBe("steer");
|
|
expect(body.payload.targetTraceId).toBe("trc_l1_gpt_pika_smoke");
|
|
if (steerDelivery === "steer") {
|
|
expect(body.payload.prompt).toBe("adjust course");
|
|
expect(body.payload.traceId).toBe("trc_steer_l1_gpt_pika");
|
|
return send({ decision: "steer", internalCommandType: "steer", run: { id: "run_l1_gpt_pika", status: "pending", backendProfile: "gpt-pika" }, command: { id: "cmd_l1_gpt_pika_steer", runId: "run_l1_gpt_pika", state: "pending", type: "steer", seq: 2 } });
|
|
}
|
|
return send({
|
|
decision: "turn",
|
|
internalCommandType: "turn",
|
|
run: { id: "run_actual_followup_turn", status: "pending", backendProfile: "gpt-pika", sessionRef: body.run.sessionRef },
|
|
command: { id: "cmd_actual_followup_turn", runId: "run_actual_followup_turn", state: "pending", type: "turn", seq: 1, dispatchIntent: { id: "dispatch_actual_followup_turn", state: "pending", runnerJobId: "rjob_actual_followup_turn", attemptCount: 0, durable: true } },
|
|
});
|
|
}
|
|
throw new Error(`unexpected AgentRun call ${method} ${url.pathname}`);
|
|
}) as typeof fetch;
|
|
}
|