Codex
765 lines
33 KiB
TypeScript
765 lines
33 KiB
TypeScript
import { randomUUID } from "node:crypto";
|
|
|
|
import { defaultCodeAgentTraceStore } from "./code-agent-trace-store.ts";
|
|
import {
|
|
parsePositiveInteger,
|
|
safeConversationId,
|
|
safeOpaqueId,
|
|
safeSessionId,
|
|
safeTraceId,
|
|
truthyFlag
|
|
} from "./server-http-utils.ts";
|
|
|
|
const ADAPTER_ID = "agentrun-v01";
|
|
const DEFAULT_AGENTRUN_MGR_URL = "http://agentrun-mgr.agentrun-v01.svc.cluster.local:8080";
|
|
const DEFAULT_TENANT_ID = "hwlab";
|
|
const DEFAULT_PROJECT_ID = "pikasTech/HWLAB";
|
|
const DEFAULT_PROVIDER_ID = "G14";
|
|
const DEFAULT_REPO_URL = "http://git-mirror-http.devops-infra.svc.cluster.local/pikasTech/HWLAB.git";
|
|
const DEFAULT_RUNNER_NAMESPACE = "agentrun-v01";
|
|
const DEFAULT_TIMEOUT_MS = 1_200_000;
|
|
const AGENTRUN_BACKENDS = Object.freeze(["codex", "deepseek"]);
|
|
|
|
export function codeAgentAgentRunAdapterEnabled(env = process.env) {
|
|
const value = String(env.HWLAB_CODE_AGENT_ADAPTER ?? env.HWLAB_CODE_AGENT_PROVIDER ?? "").trim().toLowerCase();
|
|
return value === ADAPTER_ID || value === "agentrun" || value === "agentrun-v0.1";
|
|
}
|
|
|
|
export function initialAgentRunChatResult({ params = {}, options = {}, traceId }) {
|
|
const env = options.env ?? process.env;
|
|
const timestamp = nowIso(options.now);
|
|
const backendProfile = resolveAgentRunBackendProfile(env, params);
|
|
return {
|
|
accepted: true,
|
|
status: "running",
|
|
shortConnection: true,
|
|
traceId,
|
|
conversationId: safeConversationId(params.conversationId) || null,
|
|
sessionId: agentRunSessionId(params, traceId),
|
|
threadId: safeOpaqueId(params.threadId) || null,
|
|
messageId: `msg_${safeTraceId(traceId)?.slice(4) || randomUUID()}`,
|
|
createdAt: timestamp,
|
|
updatedAt: timestamp,
|
|
provider: ADAPTER_ID,
|
|
model: modelForBackendProfile(backendProfile, env),
|
|
backend: `agentrun-v01/${backendProfile}`,
|
|
capabilityLevel: "agentrun-v01-manual-dispatch",
|
|
sessionMode: "agentrun-v01-session-ref",
|
|
implementationType: "hwlab-cloud-api-agentrun-v01-adapter",
|
|
agentRun: {
|
|
adapter: ADAPTER_ID,
|
|
status: "pending-dispatch",
|
|
backendProfile,
|
|
providerId: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_PROVIDER_ID, env.AGENTRUN_PROVIDER_ID, DEFAULT_PROVIDER_ID),
|
|
managerUrl: resolveAgentRunManagerUrl(env),
|
|
repoUrl: resolveAgentRunRepoUrl(env),
|
|
valuesPrinted: false
|
|
},
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export async function submitAgentRunChatTurn({ params = {}, options = {}, traceId, traceStore = defaultCodeAgentTraceStore, results }) {
|
|
const env = options.env ?? process.env;
|
|
const managerUrl = resolveAgentRunManagerUrl(env);
|
|
const backendProfile = resolveAgentRunBackendProfile(env, params);
|
|
const fetchImpl = options.fetchImpl ?? globalThis.fetch;
|
|
const timeoutMs = parsePositiveInteger(env.HWLAB_CODE_AGENT_AGENTRUN_HTTP_TIMEOUT_MS, 20_000);
|
|
const startedAt = nowIso(options.now);
|
|
|
|
traceStore.ensure(traceId, agentRunTraceMeta(env, params));
|
|
traceStore.append(traceId, {
|
|
type: "request",
|
|
status: "accepted",
|
|
label: "agentrun:request:accepted",
|
|
message: "HWLAB Code Agent request accepted by the AgentRun v0.1 adapter; hwlab-cloud-api will manually create run/command/runner-job over the k3s Service DNS.",
|
|
waitingFor: "agentrun-run-create",
|
|
adapter: ADAPTER_ID,
|
|
managerHost: new URL(managerUrl).hostname,
|
|
valuesPrinted: false
|
|
}, agentRunTraceMeta(env, params));
|
|
|
|
const runInput = buildAgentRunCreateRunInput({ params, env, traceId, backendProfile });
|
|
const run = await agentRunJson(fetchImpl, managerUrl, "/api/v1/runs", {
|
|
method: "POST",
|
|
body: runInput,
|
|
timeoutMs
|
|
});
|
|
const runId = requiredString(run?.id, "run.id");
|
|
traceStore.append(traceId, {
|
|
type: "backend",
|
|
status: "running",
|
|
label: "agentrun:run:created",
|
|
message: `AgentRun run ${runId} created through internal k3s Service DNS.`,
|
|
runId,
|
|
backendProfile,
|
|
waitingFor: "agentrun-command-create",
|
|
valuesPrinted: false
|
|
});
|
|
|
|
const commandInput = buildAgentRunCommandInput({ params, traceId, backendProfile });
|
|
const command = await agentRunJson(fetchImpl, managerUrl, `/api/v1/runs/${encodeURIComponent(runId)}/commands`, {
|
|
method: "POST",
|
|
body: commandInput,
|
|
timeoutMs
|
|
});
|
|
const commandId = requiredString(command?.id, "command.id");
|
|
traceStore.append(traceId, {
|
|
type: "backend",
|
|
status: "running",
|
|
label: "agentrun:command:created",
|
|
message: `AgentRun command ${commandId} created; hwlab-cloud-api will start a runner Job explicitly without relying on scheduler automation.`,
|
|
runId,
|
|
commandId,
|
|
backendProfile,
|
|
waitingFor: "agentrun-runner-job-create",
|
|
valuesPrinted: false
|
|
});
|
|
|
|
const runnerJobInput = buildAgentRunRunnerJobInput({ env, traceId, commandId });
|
|
const runnerJob = await agentRunJson(fetchImpl, managerUrl, `/api/v1/runs/${encodeURIComponent(runId)}/runner-jobs`, {
|
|
method: "POST",
|
|
body: runnerJobInput,
|
|
timeoutMs
|
|
});
|
|
const mapping = agentRunMapping({ env, managerUrl, backendProfile, run, command, runnerJob, traceId, startedAt });
|
|
traceStore.append(traceId, {
|
|
type: "backend",
|
|
status: "running",
|
|
label: "agentrun:runner-job:created",
|
|
message: `AgentRun runner Job ${mapping.jobName ?? "unknown"} created in namespace ${mapping.namespace ?? DEFAULT_RUNNER_NAMESPACE}.`,
|
|
runId: mapping.runId,
|
|
commandId: mapping.commandId,
|
|
attemptId: mapping.attemptId,
|
|
runnerId: mapping.runnerId,
|
|
jobName: mapping.jobName,
|
|
namespace: mapping.namespace,
|
|
waitingFor: "agentrun-result",
|
|
valuesPrinted: false
|
|
});
|
|
return decorateAgentRunRunningResult({ base: initialAgentRunChatResult({ params, options, traceId }), mapping, traceStore, traceId });
|
|
}
|
|
|
|
export async function syncAgentRunChatResult({ traceId, currentResult = null, options = {}, traceStore = defaultCodeAgentTraceStore }) {
|
|
const mapped = currentResult ?? await loadPersistedAgentRunResult(traceId, options);
|
|
if (!mapped?.agentRun?.runId || !mapped?.agentRun?.commandId) return { result: currentResult, runnerTrace: traceStore.snapshot(traceId), found: Boolean(currentResult) };
|
|
const env = options.env ?? process.env;
|
|
const fetchImpl = options.fetchImpl ?? globalThis.fetch;
|
|
const managerUrl = resolveAgentRunManagerUrl(env, mapped.agentRun.managerUrl);
|
|
const timeoutMs = parsePositiveInteger(env.HWLAB_CODE_AGENT_AGENTRUN_HTTP_TIMEOUT_MS, 20_000);
|
|
const eventsResponse = await agentRunJson(fetchImpl, managerUrl, `/api/v1/runs/${encodeURIComponent(mapped.agentRun.runId)}/events?afterSeq=${encodeURIComponent(String(mapped.agentRun.lastSeq ?? 0))}&limit=500`, {
|
|
method: "GET",
|
|
timeoutMs
|
|
});
|
|
const events = Array.isArray(eventsResponse?.items) ? eventsResponse.items : [];
|
|
appendAgentRunEventsToTrace(traceStore, traceId, events, mapped.agentRun);
|
|
const result = await agentRunJson(fetchImpl, managerUrl, `/api/v1/runs/${encodeURIComponent(mapped.agentRun.runId)}/commands/${encodeURIComponent(mapped.agentRun.commandId)}/result`, {
|
|
method: "GET",
|
|
timeoutMs
|
|
});
|
|
const nextMapping = {
|
|
...mapped.agentRun,
|
|
...agentRunResultRefs(result),
|
|
lastSeq: Math.max(Number(mapped.agentRun.lastSeq ?? 0), Number(result?.lastSeq ?? 0), ...events.map((event) => Number(event?.seq ?? 0))),
|
|
status: result?.status ?? mapped.agentRun.status ?? "running",
|
|
runStatus: result?.runStatus ?? mapped.agentRun.runStatus ?? null,
|
|
commandState: result?.commandState ?? mapped.agentRun.commandState ?? null,
|
|
terminalStatus: result?.terminalStatus ?? mapped.agentRun.terminalStatus ?? null,
|
|
updatedAt: nowIso(options.now),
|
|
valuesPrinted: false
|
|
};
|
|
const base = { ...mapped, agentRun: nextMapping, updatedAt: nowIso(options.now) };
|
|
const payload = agentRunResultToCodeAgentPayload({ base, result, traceStore, traceId });
|
|
options.codeAgentChatResults?.set?.(traceId, payload);
|
|
return { result: payload, runnerTrace: payload.runnerTrace ?? traceStore.snapshot(traceId), found: true };
|
|
}
|
|
|
|
export async function refreshAgentRunTrace({ traceId, result = null, options = {}, traceStore = defaultCodeAgentTraceStore }) {
|
|
const mapped = result ?? await loadPersistedAgentRunResult(traceId, options);
|
|
if (!mapped?.agentRun?.runId) return traceStore.snapshot(traceId);
|
|
const env = options.env ?? process.env;
|
|
const fetchImpl = options.fetchImpl ?? globalThis.fetch;
|
|
const managerUrl = resolveAgentRunManagerUrl(env, mapped.agentRun.managerUrl);
|
|
const timeoutMs = parsePositiveInteger(env.HWLAB_CODE_AGENT_AGENTRUN_HTTP_TIMEOUT_MS, 20_000);
|
|
const eventsResponse = await agentRunJson(fetchImpl, managerUrl, `/api/v1/runs/${encodeURIComponent(mapped.agentRun.runId)}/events?afterSeq=${encodeURIComponent(String(mapped.agentRun.lastSeq ?? 0))}&limit=500`, {
|
|
method: "GET",
|
|
timeoutMs
|
|
});
|
|
const events = Array.isArray(eventsResponse?.items) ? eventsResponse.items : [];
|
|
appendAgentRunEventsToTrace(traceStore, traceId, events, mapped.agentRun);
|
|
const lastSeq = Math.max(Number(mapped.agentRun.lastSeq ?? 0), ...events.map((event) => Number(event?.seq ?? 0)));
|
|
if (lastSeq !== Number(mapped.agentRun.lastSeq ?? 0)) {
|
|
options.codeAgentChatResults?.set?.(traceId, { ...mapped, agentRun: { ...mapped.agentRun, lastSeq, updatedAt: nowIso(options.now) } });
|
|
}
|
|
return traceStore.snapshot(traceId);
|
|
}
|
|
|
|
export async function cancelAgentRunChatTurn({ traceId, currentResult = null, options = {}, traceStore = defaultCodeAgentTraceStore }) {
|
|
const mapped = currentResult ?? await loadPersistedAgentRunResult(traceId, options);
|
|
if (!mapped?.agentRun?.commandId) return null;
|
|
const env = options.env ?? process.env;
|
|
const fetchImpl = options.fetchImpl ?? globalThis.fetch;
|
|
const managerUrl = resolveAgentRunManagerUrl(env, mapped.agentRun.managerUrl);
|
|
const timeoutMs = parsePositiveInteger(env.HWLAB_CODE_AGENT_AGENTRUN_HTTP_TIMEOUT_MS, 20_000);
|
|
await agentRunJson(fetchImpl, managerUrl, `/api/v1/commands/${encodeURIComponent(mapped.agentRun.commandId)}/cancel`, {
|
|
method: "POST",
|
|
body: { reason: "hwlab-user-cancel", traceId },
|
|
timeoutMs
|
|
});
|
|
traceStore.append(traceId, {
|
|
type: "cancel",
|
|
status: "canceled",
|
|
label: "agentrun:cancel:canceled",
|
|
message: "HWLAB forwarded cancel to AgentRun command cancel API.",
|
|
runId: mapped.agentRun.runId,
|
|
commandId: mapped.agentRun.commandId,
|
|
terminal: true,
|
|
valuesPrinted: false
|
|
});
|
|
const now = nowIso(options.now);
|
|
const agentRun = { ...mapped.agentRun, status: "cancelled", commandState: "cancelled", terminalStatus: "cancelled", updatedAt: now };
|
|
const payload = {
|
|
...mapped,
|
|
status: "canceled",
|
|
canceled: true,
|
|
updatedAt: now,
|
|
agentRun,
|
|
runnerTrace: traceStore.snapshot(traceId),
|
|
error: {
|
|
code: "agentrun_canceled",
|
|
layer: "agentrun",
|
|
category: "canceled",
|
|
retryable: true,
|
|
message: "AgentRun command was canceled by user request",
|
|
userMessage: "当前 AgentRun 请求已取消；traceId/runId/commandId 已保留，可重试上一条消息。",
|
|
traceId,
|
|
route: "/v1/agent/chat/cancel",
|
|
toolName: "agentrun.command.cancel"
|
|
},
|
|
userMessage: "当前 AgentRun 请求已取消；traceId/runId/commandId 已保留，可重试上一条消息。"
|
|
};
|
|
options.codeAgentChatResults?.set?.(traceId, payload);
|
|
return payload;
|
|
}
|
|
|
|
export async function loadPersistedAgentRunResult(traceId, options = {}) {
|
|
if (!safeTraceId(traceId) || typeof options.accessController?.getAgentSessionByTraceId !== "function") return null;
|
|
const session = await options.accessController.getAgentSessionByTraceId(traceId);
|
|
const agentRun = session?.session?.agentRun;
|
|
if (!agentRun || typeof agentRun !== "object" || !agentRun.runId || !agentRun.commandId) return null;
|
|
return {
|
|
accepted: true,
|
|
status: session.status === "canceled" ? "canceled" : "running",
|
|
shortConnection: true,
|
|
traceId,
|
|
conversationId: safeConversationId(session.conversationId) || agentRun.conversationId || null,
|
|
sessionId: safeSessionId(session.id) || agentRun.sessionId || null,
|
|
threadId: safeOpaqueId(session.threadId) || agentRun.threadId || null,
|
|
messageId: session.session?.messageId ?? `msg_${traceId.slice(4)}`,
|
|
createdAt: session.startedAt ?? session.updatedAt ?? nowIso(options.now),
|
|
updatedAt: session.updatedAt ?? nowIso(options.now),
|
|
ownerUserId: session.ownerUserId,
|
|
provider: ADAPTER_ID,
|
|
model: modelForBackendProfile(agentRun.backendProfile, options.env ?? process.env),
|
|
backend: `agentrun-v01/${agentRun.backendProfile ?? "deepseek"}`,
|
|
capabilityLevel: "agentrun-v01-manual-dispatch",
|
|
sessionMode: "agentrun-v01-session-ref",
|
|
implementationType: "hwlab-cloud-api-agentrun-v01-adapter",
|
|
agentRun: { ...agentRun, adapter: ADAPTER_ID, valuesPrinted: false },
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function agentRunSessionEvidence(payload = {}) {
|
|
if (!payload?.agentRun) return {};
|
|
return {
|
|
agentRun: {
|
|
adapter: ADAPTER_ID,
|
|
runId: payload.agentRun.runId ?? null,
|
|
commandId: payload.agentRun.commandId ?? null,
|
|
attemptId: payload.agentRun.attemptId ?? null,
|
|
runnerId: payload.agentRun.runnerId ?? null,
|
|
jobName: payload.agentRun.jobName ?? null,
|
|
namespace: payload.agentRun.namespace ?? null,
|
|
backendProfile: payload.agentRun.backendProfile ?? null,
|
|
managerUrl: payload.agentRun.managerUrl ?? DEFAULT_AGENTRUN_MGR_URL,
|
|
repoUrl: payload.agentRun.repoUrl ?? DEFAULT_REPO_URL,
|
|
status: payload.agentRun.status ?? null,
|
|
runStatus: payload.agentRun.runStatus ?? null,
|
|
commandState: payload.agentRun.commandState ?? null,
|
|
terminalStatus: payload.agentRun.terminalStatus ?? null,
|
|
lastSeq: payload.agentRun.lastSeq ?? 0,
|
|
providerId: payload.agentRun.providerId ?? DEFAULT_PROVIDER_ID,
|
|
sessionId: payload.sessionId ?? payload.agentRun.sessionId ?? null,
|
|
conversationId: payload.conversationId ?? payload.agentRun.conversationId ?? null,
|
|
threadId: payload.threadId ?? payload.agentRun.threadId ?? null,
|
|
valuesPrinted: false
|
|
}
|
|
};
|
|
}
|
|
|
|
function buildAgentRunCreateRunInput({ params, env, traceId, backendProfile }) {
|
|
const commitId = fullSourceCommit(env);
|
|
const resourceBundleRef = commitId
|
|
? {
|
|
kind: "git",
|
|
repoUrl: resolveAgentRunRepoUrl(env),
|
|
commitId,
|
|
submodules: false,
|
|
lfs: false
|
|
}
|
|
: null;
|
|
return {
|
|
tenantId: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_TENANT_ID, DEFAULT_TENANT_ID),
|
|
projectId: firstNonEmpty(params.projectId, env.HWLAB_CODE_AGENT_AGENTRUN_PROJECT_ID, DEFAULT_PROJECT_ID),
|
|
workspaceRef: {
|
|
kind: "opaque",
|
|
repo: DEFAULT_PROJECT_ID,
|
|
branch: firstNonEmpty(env.HWLAB_BOOT_REF, env.HWLAB_CODE_AGENT_AGENTRUN_BRANCH, "v0.2"),
|
|
runtimeNamespace: firstNonEmpty(env.HWLAB_RUNTIME_NAMESPACE, env.POD_NAMESPACE, env.HWLAB_NAMESPACE, "hwlab-v02"),
|
|
hwlabTraceId: traceId,
|
|
valuesPrinted: false
|
|
},
|
|
sessionRef: {
|
|
sessionId: agentRunSessionId(params, traceId),
|
|
...(safeConversationId(params.conversationId) ? { conversationId: safeConversationId(params.conversationId) } : {}),
|
|
...(safeOpaqueId(params.threadId) ? { threadId: safeOpaqueId(params.threadId) } : {}),
|
|
metadata: {
|
|
adapter: ADAPTER_ID,
|
|
hwlabTraceId: traceId,
|
|
hwlabApi: "/v1/agent/chat",
|
|
valuesPrinted: false
|
|
}
|
|
},
|
|
resourceBundleRef,
|
|
providerId: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_PROVIDER_ID, env.AGENTRUN_PROVIDER_ID, DEFAULT_PROVIDER_ID),
|
|
backendProfile,
|
|
executionPolicy: {
|
|
sandbox: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_SANDBOX, env.HWLAB_CODE_AGENT_CODEX_SANDBOX, "danger-full-access"),
|
|
approval: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_APPROVAL, "never"),
|
|
timeoutMs: parsePositiveInteger(env.HWLAB_CODE_AGENT_AGENTRUN_TIMEOUT_MS, parsePositiveInteger(env.HWLAB_CODE_AGENT_TIMEOUT_MS, DEFAULT_TIMEOUT_MS)),
|
|
network: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_NETWORK, "enabled"),
|
|
secretScope: {
|
|
allowCredentialEcho: false,
|
|
providerCredentials: [providerCredentialSecretRef(backendProfile, env)]
|
|
}
|
|
},
|
|
traceSink: {
|
|
kind: "hwlab-cloud-api",
|
|
traceId,
|
|
resultUrl: `/v1/agent/chat/result/${encodeURIComponent(traceId)}`,
|
|
traceUrl: `/v1/agent/chat/trace/${encodeURIComponent(traceId)}`,
|
|
valuesPrinted: false
|
|
}
|
|
};
|
|
}
|
|
|
|
function buildAgentRunCommandInput({ params, traceId, backendProfile }) {
|
|
const prompt = String(params.message ?? params.prompt ?? "").trim();
|
|
return {
|
|
type: "turn",
|
|
payload: {
|
|
prompt,
|
|
message: prompt,
|
|
traceId,
|
|
conversationId: safeConversationId(params.conversationId) || null,
|
|
sessionId: agentRunSessionId(params, traceId),
|
|
threadId: safeOpaqueId(params.threadId) || null,
|
|
providerProfile: backendProfile,
|
|
source: "hwlab-cloud-api",
|
|
valuesPrinted: false
|
|
},
|
|
idempotencyKey: traceId
|
|
};
|
|
}
|
|
|
|
function buildAgentRunRunnerJobInput({ env, traceId, commandId }) {
|
|
return {
|
|
commandId,
|
|
idempotencyKey: traceId,
|
|
namespace: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_RUNNER_NAMESPACE, env.AGENTRUN_RUNTIME_NAMESPACE, DEFAULT_RUNNER_NAMESPACE),
|
|
...(firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_RUNNER_IMAGE, env.AGENTRUN_RUNNER_IMAGE)
|
|
? { image: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_RUNNER_IMAGE, env.AGENTRUN_RUNNER_IMAGE) }
|
|
: {}),
|
|
...(firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_RUNNER_SERVICE_ACCOUNT, env.AGENTRUN_RUNNER_SERVICE_ACCOUNT)
|
|
? { serviceAccountName: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_RUNNER_SERVICE_ACCOUNT, env.AGENTRUN_RUNNER_SERVICE_ACCOUNT) }
|
|
: {})
|
|
};
|
|
}
|
|
|
|
function providerCredentialSecretRef(profile, env) {
|
|
return {
|
|
profile,
|
|
secretRef: {
|
|
namespace: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_SECRET_NAMESPACE, DEFAULT_RUNNER_NAMESPACE),
|
|
name: firstNonEmpty(env[`HWLAB_CODE_AGENT_AGENTRUN_${profile.toUpperCase()}_SECRET_NAME`], env.HWLAB_CODE_AGENT_AGENTRUN_PROVIDER_SECRET_NAME, `agentrun-v01-provider-${profile}`),
|
|
keys: ["auth.json", "config.toml"],
|
|
mountPath: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_CODEX_HOME_MOUNT, "~/.codex")
|
|
}
|
|
};
|
|
}
|
|
|
|
function agentRunResultToCodeAgentPayload({ base, result, traceStore, traceId }) {
|
|
const terminalStatus = String(result?.terminalStatus ?? "");
|
|
const terminal = terminalStatus === "completed" || terminalStatus === "failed" || terminalStatus === "blocked" || terminalStatus === "cancelled";
|
|
if (!terminal) {
|
|
return decorateAgentRunRunningResult({ base, mapping: base.agentRun, traceStore, traceId });
|
|
}
|
|
const now = nowIso();
|
|
const runnerTrace = traceStore.snapshot(traceId, agentRunTraceMeta({}, {}));
|
|
if (terminalStatus === "completed" && String(result?.reply ?? "").trim()) {
|
|
traceStore.append(traceId, {
|
|
type: "result",
|
|
status: "completed",
|
|
label: "agentrun:result:completed",
|
|
message: "AgentRun result is ready for HWLAB short-connection polling.",
|
|
runId: base.agentRun.runId,
|
|
commandId: base.agentRun.commandId,
|
|
terminal: true,
|
|
valuesPrinted: false
|
|
});
|
|
return {
|
|
...base,
|
|
status: "completed",
|
|
updatedAt: now,
|
|
session: agentRunSessionSummary(base, "idle"),
|
|
runner: agentRunRunnerSummary(base.agentRun),
|
|
runnerTrace: traceStore.snapshot(traceId, agentRunTraceMeta({}, {})),
|
|
toolCalls: [],
|
|
skills: { status: "delegated", provider: ADAPTER_ID, items: [], valuesPrinted: false },
|
|
reply: {
|
|
messageId: base.messageId ?? `msg_${traceId.slice(4)}`,
|
|
role: "assistant",
|
|
content: String(result.reply),
|
|
createdAt: now
|
|
},
|
|
usage: null,
|
|
agentRun: { ...base.agentRun, terminalStatus, completed: true, valuesPrinted: false },
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
const canceled = terminalStatus === "cancelled";
|
|
traceStore.append(traceId, {
|
|
type: "result",
|
|
status: canceled ? "canceled" : "failed",
|
|
label: `agentrun:result:${canceled ? "canceled" : terminalStatus || "failed"}`,
|
|
errorCode: canceled ? "agentrun_canceled" : result?.failureKind ?? "agentrun_failed",
|
|
message: result?.failureMessage ?? result?.blocker?.message ?? (canceled ? "AgentRun command was canceled." : "AgentRun command failed without a completed reply."),
|
|
runId: base.agentRun.runId,
|
|
commandId: base.agentRun.commandId,
|
|
terminal: true,
|
|
valuesPrinted: false
|
|
});
|
|
const code = canceled ? "agentrun_canceled" : result?.failureKind ?? (terminalStatus === "blocked" ? "agentrun_blocked" : "agentrun_failed");
|
|
const message = result?.failureMessage ?? result?.blocker?.message ?? (canceled ? "AgentRun command was canceled" : "AgentRun command failed");
|
|
return {
|
|
...base,
|
|
status: canceled ? "canceled" : "failed",
|
|
canceled,
|
|
updatedAt: now,
|
|
session: agentRunSessionSummary(base, canceled ? "canceled" : "failed"),
|
|
runner: agentRunRunnerSummary(base.agentRun),
|
|
runnerTrace,
|
|
toolCalls: [],
|
|
skills: { status: "delegated", provider: ADAPTER_ID, items: [], valuesPrinted: false },
|
|
error: {
|
|
code,
|
|
layer: "agentrun",
|
|
category: canceled ? "canceled" : "agentrun_failed",
|
|
retryable: true,
|
|
message,
|
|
userMessage: canceled ? "AgentRun 请求已取消。" : "AgentRun 请求失败；请查看 runnerTrace 和 agentRun 字段定位 runId/commandId/jobName。",
|
|
traceId,
|
|
route: "/v1/agent/chat",
|
|
toolName: "agentrun.manual-dispatch"
|
|
},
|
|
blocker: canceled ? null : {
|
|
code,
|
|
layer: "agentrun",
|
|
category: "agentrun_failed",
|
|
retryable: true,
|
|
summary: message,
|
|
traceId,
|
|
route: "/v1/agent/chat",
|
|
toolName: "agentrun.manual-dispatch"
|
|
},
|
|
agentRun: { ...base.agentRun, terminalStatus, completed: false, valuesPrinted: false },
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
function decorateAgentRunRunningResult({ base, mapping, traceStore, traceId }) {
|
|
return {
|
|
...base,
|
|
status: "running",
|
|
accepted: true,
|
|
shortConnection: true,
|
|
updatedAt: nowIso(),
|
|
session: agentRunSessionSummary({ ...base, agentRun: mapping }, "running"),
|
|
runner: agentRunRunnerSummary(mapping),
|
|
runnerTrace: traceStore.snapshot(traceId, agentRunTraceMeta({}, {})),
|
|
agentRun: { ...mapping, adapter: ADAPTER_ID, valuesPrinted: false },
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
function appendAgentRunEventsToTrace(traceStore, traceId, events, mapping = {}) {
|
|
for (const event of events) {
|
|
const normalized = mapAgentRunEvent(event, mapping);
|
|
if (normalized) traceStore.append(traceId, normalized, agentRunTraceMeta({}, {}));
|
|
}
|
|
}
|
|
|
|
function mapAgentRunEvent(event, mapping = {}) {
|
|
if (!event || typeof event !== "object") return null;
|
|
const payload = event.payload && typeof event.payload === "object" ? event.payload : {};
|
|
const base = {
|
|
source: "agentrun",
|
|
sourceSeq: event.seq ?? null,
|
|
runId: event.runId ?? mapping.runId ?? null,
|
|
commandId: payload.commandId ?? mapping.commandId ?? null,
|
|
attemptId: payload.attemptId ?? mapping.attemptId ?? null,
|
|
runnerId: payload.runnerId ?? mapping.runnerId ?? null,
|
|
jobName: payload.jobName ?? mapping.jobName ?? null,
|
|
namespace: payload.namespace ?? mapping.namespace ?? null,
|
|
valuesPrinted: false
|
|
};
|
|
if (event.type === "backend_status") {
|
|
const phase = String(payload.phase ?? "status");
|
|
return { ...base, type: "backend", status: "running", label: `agentrun:backend:${phase}`, message: textPayload(payload, phase), waitingFor: waitingForForPhase(phase) };
|
|
}
|
|
if (event.type === "assistant_message") {
|
|
return { ...base, type: "assistant", status: "running", label: "agentrun:assistant:message", message: textPayload(payload, "assistant message"), text: textPayload(payload, "") };
|
|
}
|
|
if (event.type === "tool_call") {
|
|
return { ...base, type: "tool", status: String(payload.status ?? "running"), label: `agentrun:tool:${String(payload.name ?? payload.method ?? "call")}`, message: textPayload(payload, "tool call") };
|
|
}
|
|
if (event.type === "command_output") {
|
|
const stream = payload.stream === "stderr" ? "stderr" : "stdout";
|
|
return { ...base, type: "output", status: "running", label: `agentrun:output:${stream}`, stream, message: textPayload(payload, ""), outputTruncated: payload.outputTruncated === true };
|
|
}
|
|
if (event.type === "diff") {
|
|
return { ...base, type: "diff", status: "running", label: "agentrun:diff", message: textPayload(payload, "diff") };
|
|
}
|
|
if (event.type === "error") {
|
|
return { ...base, type: "error", status: "failed", label: `agentrun:error:${String(payload.failureKind ?? "backend")}`, errorCode: payload.failureKind ?? "agentrun_error", message: textPayload(payload, "AgentRun error") };
|
|
}
|
|
if (event.type === "terminal_status") {
|
|
const terminalStatus = String(payload.terminalStatus ?? "failed");
|
|
return { ...base, type: "result", status: terminalStatus === "cancelled" ? "canceled" : terminalStatus, label: `agentrun:terminal:${terminalStatus}`, errorCode: payload.failureKind ?? null, message: textPayload(payload, `AgentRun terminal status ${terminalStatus}`), terminal: true };
|
|
}
|
|
return { ...base, type: "backend", status: "running", label: `agentrun:event:${String(event.type ?? "unknown")}`, message: textPayload(payload, "AgentRun event") };
|
|
}
|
|
|
|
async function agentRunJson(fetchImpl, managerUrl, path, { method = "GET", body, timeoutMs = 20_000 } = {}) {
|
|
const controller = new AbortController();
|
|
const timeout = setTimeout(() => controller.abort(), timeoutMs);
|
|
try {
|
|
const response = await fetchImpl(`${managerUrl}${path}`, {
|
|
method,
|
|
headers: body === undefined ? undefined : { "content-type": "application/json" },
|
|
body: body === undefined ? undefined : JSON.stringify(body),
|
|
signal: controller.signal
|
|
});
|
|
const text = await response.text();
|
|
const parsed = text ? JSON.parse(text) : {};
|
|
if (!response.ok || parsed?.ok === false) {
|
|
throw Object.assign(new Error(parsed?.message ?? `AgentRun ${method} ${path} failed with HTTP ${response.status}`), {
|
|
code: parsed?.failureKind ?? "agentrun_request_failed",
|
|
statusCode: response.status,
|
|
agentRunError: parsed
|
|
});
|
|
}
|
|
return parsed?.ok === true && Object.hasOwn(parsed, "data") ? parsed.data : parsed;
|
|
} catch (error) {
|
|
if (error?.name === "AbortError") {
|
|
throw Object.assign(new Error(`AgentRun ${method} ${path} timed out after ${timeoutMs}ms`), { code: "agentrun_timeout", statusCode: 504 });
|
|
}
|
|
throw error;
|
|
} finally {
|
|
clearTimeout(timeout);
|
|
}
|
|
}
|
|
|
|
function resolveAgentRunManagerUrl(env = process.env, override = null) {
|
|
const raw = firstNonEmpty(override, env.AGENTRUN_MGR_URL, env.HWLAB_CODE_AGENT_AGENTRUN_MGR_URL, DEFAULT_AGENTRUN_MGR_URL);
|
|
const url = new URL(raw);
|
|
const host = url.hostname.toLowerCase();
|
|
const allowedHost = "agentrun-mgr.agentrun-v01.svc.cluster.local";
|
|
const allowedByTest = truthyFlag(env.HWLAB_CODE_AGENT_AGENTRUN_ALLOW_NON_K3S_URL) && ["127.0.0.1", "localhost"].includes(host);
|
|
if (url.protocol !== "http:" || (host !== allowedHost && !allowedByTest)) {
|
|
throw Object.assign(new Error(`AGENTRUN_MGR_URL must use internal k3s Service DNS ${DEFAULT_AGENTRUN_MGR_URL}; got ${redactUrl(raw)}`), {
|
|
code: "agentrun_internal_url_required",
|
|
statusCode: 500
|
|
});
|
|
}
|
|
url.pathname = url.pathname.replace(/\/+$/u, "");
|
|
url.search = "";
|
|
url.hash = "";
|
|
return url.toString().replace(/\/+$/u, "");
|
|
}
|
|
|
|
function resolveAgentRunBackendProfile(env = process.env, params = {}) {
|
|
const value = String(params.providerProfile ?? params.codeAgentProviderProfile ?? env.HWLAB_CODE_AGENT_AGENTRUN_BACKEND_PROFILE ?? env.HWLAB_CODE_AGENT_DEFAULT_PROVIDER_PROFILE ?? "deepseek").trim().toLowerCase();
|
|
const mapped = value === "codex-api" || value === "codex" ? "codex" : value === "runtime-default" ? String(env.HWLAB_CODE_AGENT_AGENTRUN_DEFAULT_BACKEND_PROFILE ?? "deepseek").trim().toLowerCase() : value;
|
|
return AGENTRUN_BACKENDS.includes(mapped) ? mapped : "deepseek";
|
|
}
|
|
|
|
function agentRunMapping({ env, managerUrl, backendProfile, run, command, runnerJob, traceId, startedAt }) {
|
|
return {
|
|
adapter: ADAPTER_ID,
|
|
managerUrl,
|
|
backendProfile,
|
|
providerId: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_PROVIDER_ID, env.AGENTRUN_PROVIDER_ID, DEFAULT_PROVIDER_ID),
|
|
runId: run.id,
|
|
commandId: command.id,
|
|
attemptId: runnerJob?.attemptId ?? runnerJob?.runner?.attemptId ?? null,
|
|
runnerId: runnerJob?.runnerId ?? runnerJob?.runner?.runnerId ?? null,
|
|
runnerJobId: runnerJob?.id ?? null,
|
|
jobName: runnerJob?.jobName ?? runnerJob?.jobIdentity?.name ?? null,
|
|
namespace: runnerJob?.namespace ?? runnerJob?.jobIdentity?.namespace ?? DEFAULT_RUNNER_NAMESPACE,
|
|
status: "runner-job-created",
|
|
runStatus: run.status ?? null,
|
|
commandState: command.state ?? null,
|
|
terminalStatus: null,
|
|
lastSeq: 0,
|
|
traceId,
|
|
createdAt: startedAt,
|
|
updatedAt: nowIso(),
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
function agentRunResultRefs(result = {}) {
|
|
const refs = {};
|
|
for (const key of ["attemptId", "runnerId", "jobName", "namespace", "runnerJobCount"]) {
|
|
if (result?.[key] !== undefined && result?.[key] !== null) refs[key] = result[key];
|
|
}
|
|
return refs;
|
|
}
|
|
|
|
function agentRunSessionId(params, traceId) {
|
|
return safeSessionId(params.sessionId) || `ses_agentrun_${String(safeTraceId(traceId) || `trc_${randomUUID()}`).slice(4)}`;
|
|
}
|
|
|
|
function agentRunSessionSummary(base, status) {
|
|
return {
|
|
sessionId: base.sessionId ?? base.agentRun?.sessionId ?? null,
|
|
conversationId: base.conversationId ?? base.agentRun?.conversationId ?? null,
|
|
threadId: base.threadId ?? base.agentRun?.threadId ?? null,
|
|
status,
|
|
sessionMode: "agentrun-v01-session-ref",
|
|
runnerKind: "agentrun-v01-runner-job",
|
|
secretMaterialStored: false,
|
|
valuesRedacted: true
|
|
};
|
|
}
|
|
|
|
function agentRunRunnerSummary(mapping = {}) {
|
|
return {
|
|
kind: "agentrun-v01-runner-job",
|
|
adapter: ADAPTER_ID,
|
|
runId: mapping.runId ?? null,
|
|
commandId: mapping.commandId ?? null,
|
|
attemptId: mapping.attemptId ?? null,
|
|
runnerId: mapping.runnerId ?? null,
|
|
jobName: mapping.jobName ?? null,
|
|
namespace: mapping.namespace ?? null,
|
|
backendProfile: mapping.backendProfile ?? null,
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
function agentRunTraceMeta(env = process.env) {
|
|
return {
|
|
runnerKind: "agentrun-v01-runner-job",
|
|
workspace: resolveAgentRunRepoUrl(env),
|
|
sandbox: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_SANDBOX, env.HWLAB_CODE_AGENT_CODEX_SANDBOX, "danger-full-access"),
|
|
sessionMode: "agentrun-v01-session-ref",
|
|
implementationType: "hwlab-cloud-api-agentrun-v01-adapter"
|
|
};
|
|
}
|
|
|
|
function resolveAgentRunRepoUrl(env = process.env) {
|
|
const raw = firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_REPO_URL, env.HWLAB_BOOT_READ_URL, DEFAULT_REPO_URL);
|
|
const url = new URL(raw);
|
|
const host = url.hostname.toLowerCase();
|
|
const allowedHost = "git-mirror-http.devops-infra.svc.cluster.local";
|
|
const allowedByTest = truthyFlag(env.HWLAB_CODE_AGENT_AGENTRUN_ALLOW_NON_K3S_URL) && ["127.0.0.1", "localhost"].includes(host);
|
|
if (url.protocol !== "http:" || (host !== allowedHost && !allowedByTest)) {
|
|
throw Object.assign(new Error(`HWLAB_CODE_AGENT_AGENTRUN_REPO_URL must use internal k3s git mirror ${DEFAULT_REPO_URL}; got ${redactUrl(raw)}`), {
|
|
code: "agentrun_internal_repo_url_required",
|
|
statusCode: 500
|
|
});
|
|
}
|
|
url.pathname = url.pathname.replace(/\/+$/u, "");
|
|
url.search = "";
|
|
url.hash = "";
|
|
return url.toString().replace(/\/+$/u, "");
|
|
}
|
|
|
|
function fullSourceCommit(env) {
|
|
for (const value of [
|
|
env.HWLAB_CODE_AGENT_AGENTRUN_SOURCE_COMMIT,
|
|
env.HWLAB_BOOT_COMMIT,
|
|
env.HWLAB_GITOPS_SOURCE_COMMIT,
|
|
env.HWLAB_COMMIT_ID,
|
|
env.HWLAB_GIT_SHA,
|
|
env.GIT_COMMIT,
|
|
env.HWLAB_REVISION
|
|
]) {
|
|
const text = String(value ?? "").trim().toLowerCase();
|
|
if (/^[0-9a-f]{40}$/u.test(text)) return text;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function modelForBackendProfile(profile, env = process.env) {
|
|
if (profile === "codex") return firstNonEmpty(env.HWLAB_CODE_AGENT_CODEX_API_MODEL, env.HWLAB_CODE_AGENT_MODEL, "gpt-5.5");
|
|
return firstNonEmpty(env.HWLAB_CODE_AGENT_DEEPSEEK_MODEL, "deepseek-chat");
|
|
}
|
|
|
|
function waitingForForPhase(phase) {
|
|
if (phase.includes("runner-job")) return "agentrun-runner";
|
|
if (phase.includes("resource-bundle")) return "agentrun-resource-bundle";
|
|
if (phase.includes("backend")) return "agentrun-backend";
|
|
return "agentrun-result";
|
|
}
|
|
|
|
function textPayload(payload, fallback) {
|
|
for (const key of ["message", "text", "content", "delta", "summary", "phase"]) {
|
|
if (typeof payload?.[key] === "string" && payload[key].length > 0) return payload[key];
|
|
}
|
|
return fallback;
|
|
}
|
|
|
|
function requiredString(value, fieldName) {
|
|
if (typeof value === "string" && value.trim()) return value.trim();
|
|
throw Object.assign(new Error(`AgentRun response missing ${fieldName}`), { code: "agentrun_response_invalid", statusCode: 502 });
|
|
}
|
|
|
|
function firstNonEmpty(...values) {
|
|
for (const value of values) {
|
|
const text = String(value ?? "").trim();
|
|
if (text) return text;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function nowIso(now) {
|
|
return typeof now === "function" ? now() : new Date().toISOString();
|
|
}
|
|
|
|
function redactUrl(value) {
|
|
try {
|
|
const url = new URL(value);
|
|
if (url.username || url.password) {
|
|
url.username = "***";
|
|
url.password = "";
|
|
}
|
|
return url.toString();
|
|
} catch {
|
|
return "<invalid-url>";
|
|
}
|
|
}
|