root
1140 lines
50 KiB
TypeScript
1140 lines
50 KiB
TypeScript
// SPEC: PJ2026-0104010803 Workbench唯一投影 draft-2026-06-19-p1-agentrun-incremental-cursor; draft-2026-06-20-p2-terminal-outbox-recovery; PJ2026-010205 HWLAB接入 draft-2026-06-17-r0; draft-2026-06-25-p0-session-warm-runner-contract; PJ2026-01060505 Workbench Performance draft-2026-06-17-p0.
|
|
// Responsibility: AgentRun command-result/event mapping and trace observability helpers; Kafka owns persistence.
|
|
|
|
import { randomUUID } from "node:crypto";
|
|
|
|
import { defaultCodeAgentTraceStore } from "./code-agent-trace-store.ts";
|
|
import { decorateCodeAgentSession } from "./code-agent-session-lifecycle.ts";
|
|
import {
|
|
parsePositiveInteger,
|
|
safeConversationId,
|
|
safeOpaqueId,
|
|
safeSessionId,
|
|
safeTraceId,
|
|
text
|
|
} from "./server-http-utils.ts";
|
|
import { currentBackendPerformanceContext } from "./backend-performance.ts";
|
|
import {
|
|
DEFAULT_AGENTRUN_MGR_URL,
|
|
agentRunJson,
|
|
isAgentRunManagerInternalServiceHost,
|
|
resolveAgentRunManagerUrl
|
|
} from "./code-agent-agentrun-runtime.ts";
|
|
import {
|
|
agentRunAlreadyTerminalCancelPayload,
|
|
agentRunCancelBlockedPayload,
|
|
agentRunCancelTerminalStatus
|
|
} from "./code-agent-agentrun-cancel.ts";
|
|
import {
|
|
DEFAULT_AGENTRUN_REPO_URL,
|
|
agentRunAvailabilityBlocker,
|
|
agentRunProviderIdOrNull,
|
|
agentRunTraceMeta,
|
|
backendForBackendProfile,
|
|
modelForBackendProfile,
|
|
providerForBackendProfile,
|
|
requireAgentRunSourceCommit,
|
|
resolveAgentRunBackendProfile,
|
|
resolveAgentRunProviderId,
|
|
resolveAgentRunRepoUrl
|
|
} from "./code-agent-agentrun-profile.ts";
|
|
import {
|
|
agentRunPromptEventFields,
|
|
agentRunPromptFields,
|
|
agentRunPromptMetadataFromParams,
|
|
agentRunPromptMetadataFromSession,
|
|
agentRunPromptMetadataFromText,
|
|
messageAuthorityTextValue
|
|
} from "./code-agent-agentrun-prompt.ts";
|
|
import { codeAgentOtelTraceFields, codeAgentOtelTraceContext, emitCodeAgentOtelSpan } from "./otel-trace.ts";
|
|
|
|
const ADAPTER_ID = "agentrun-v01";
|
|
const ADAPTER_IDS = new Set([ADAPTER_ID, "agentrun-v02"]);
|
|
const ADAPTER_ALIASES = new Set(["agentrun", "agentrun-v0.1", "agentrun-v0.2"]);
|
|
const DEFAULT_TENANT_ID = "hwlab";
|
|
const DEFAULT_PROJECT_ID = "pikasTech/HWLAB";
|
|
const DEFAULT_RUNNER_NAMESPACE = "agentrun-v01";
|
|
const DEFAULT_TIMEOUT_MS = 1_200_000;
|
|
const AGENTRUN_RUNNER_KIND = "agentrun-v01-shared-runner";
|
|
const AGENTRUN_SESSION_MODE = "agentrun-v01-durable-session";
|
|
const AGENTRUN_IMPLEMENTATION_TYPE = "agentrun-v01-shared-execution-infra";
|
|
const AGENTRUN_CAPABILITY_LEVEL = "agentrun-v01-shared-code-agent-session";
|
|
const AGENTRUN_PROVIDER_TRACE_PROTOCOL = "agentrun-v01-jsonrpc";
|
|
const AGENTRUN_PROVIDER_TRACE_WIRE_API = "agentrun-v01-command-result";
|
|
const THREAD_CONTINUITY_POLICY = "hwlab-agentrun-v01-reuse-runner-thread";
|
|
const SESSION_POLICY_RUN_LOCAL = "hwlab-agentrun-v01-session-runner-reuse";
|
|
const TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "blocked", "cancelled", "canceled"]);
|
|
const HWLAB_RESOURCE_GIT_BUNDLES = Object.freeze([
|
|
Object.freeze({ name: "hwlab-tools", subpath: "tools", target_path: "tools" }),
|
|
Object.freeze({ name: "hwlab-agent-skills", subpath: "skills", target_path: ".agents/skills" })
|
|
]);
|
|
const HWLAB_RESOURCE_PROMPT_REFS = Object.freeze([
|
|
Object.freeze({ name: "hwlab-v02-runtime", path: "internal/agent/prompts/hwlab-v02-runtime.md", inject: "thread-start", required: true })
|
|
]);
|
|
|
|
const RETRYABLE_AGENTRUN_TRANSPORT_FAILURE_KINDS = new Set([
|
|
"agentrun-connect-failed",
|
|
"agentrun-proxy-exec-failed",
|
|
"agentrun-manager-fetch-failed",
|
|
"agentrun-timeout",
|
|
"timeout",
|
|
"fetch-failed",
|
|
"network-error"
|
|
]);
|
|
|
|
export function isRetryableAgentRunTransportFailureKind(failureKind) {
|
|
return RETRYABLE_AGENTRUN_TRANSPORT_FAILURE_KINDS.has(normalizedFailureKind(failureKind));
|
|
}
|
|
|
|
|
|
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_AGENTRUN_REPO_URL,
|
|
status: payload.agentRun.status ?? null,
|
|
runStatus: payload.agentRun.runStatus ?? null,
|
|
commandState: payload.agentRun.commandState ?? null,
|
|
terminalStatus: payload.agentRun.terminalStatus ?? null,
|
|
traceId: payload.agentRun.traceId ?? payload.traceId ?? payload.providerTrace?.traceId ?? null,
|
|
lastSeq: payload.agentRun.lastSeq ?? 0,
|
|
providerId: payload.agentRun.providerId ?? agentRunProviderIdOrNull(),
|
|
reuseEligible: payload.agentRun.reuseEligible ?? false,
|
|
sessionId: payload.agentRun.sessionId ?? payload.sessionId ?? null,
|
|
conversationId: payload.conversationId ?? payload.agentRun.conversationId ?? null,
|
|
threadId: payload.threadId ?? payload.agentRun.threadId ?? null,
|
|
providerTrace: payload.providerTrace ?? payload.agentRun.providerTrace ?? null,
|
|
valuesPrinted: false
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
export function agentRunFailureRequiresFreshSession(failureKind, failureMessage) {
|
|
const kind = String(failureKind ?? "").trim().toLowerCase().replace(/_/gu, "-");
|
|
const message = String(failureMessage ?? "");
|
|
return kind === "session-store-evicted" || kind === "thread-resume-failed" || /session stor(?:e|age).*evicted|pvc-backed session|no rollout found for thread id|thread\/resume failed/iu.test(message);
|
|
}
|
|
|
|
|
|
export function agentRunFreshSessionFailure(result = {}) {
|
|
const code = result?.failureKind ?? result?.errorCode ?? result?.code ?? (result?.terminalStatus === "failed" ? "agentrun_failed" : null);
|
|
const message = result?.failureMessage ?? result?.blocker?.message ?? result?.error?.message ?? result?.message ?? "";
|
|
return {
|
|
code: normalizedFailureKind(code) ?? "agentrun_failed",
|
|
message,
|
|
requiresFreshSession: agentRunFailureRequiresFreshSession(code, message),
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function providerCredentialSecretRef(profile, env) {
|
|
const profileEnvKey = String(profile ?? "").toUpperCase().replace(/[^A-Z0-9]+/gu, "_");
|
|
return {
|
|
profile,
|
|
secretRef: {
|
|
namespace: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_SECRET_NAMESPACE, DEFAULT_RUNNER_NAMESPACE),
|
|
name: firstNonEmpty(env[`HWLAB_CODE_AGENT_AGENTRUN_${profileEnvKey}_SECRET_NAME`], env[`HWLAB_CODE_AGENT_AGENTRUN_${String(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")
|
|
}
|
|
};
|
|
}
|
|
|
|
export function agentRunProviderTrace({ base = {}, result = {}, terminalStatus = null } = {}) {
|
|
return {
|
|
transport: "agentrun-v01",
|
|
protocol: AGENTRUN_PROVIDER_TRACE_PROTOCOL,
|
|
wireApi: AGENTRUN_PROVIDER_TRACE_WIRE_API,
|
|
runnerKind: AGENTRUN_RUNNER_KIND,
|
|
implementationType: AGENTRUN_IMPLEMENTATION_TYPE,
|
|
command: "agentrun.v01.command.turn",
|
|
toolName: "agentrun.v01.command.turn",
|
|
source: ADAPTER_ID,
|
|
backendProfile: base.agentRun?.backendProfile ?? null,
|
|
runId: base.agentRun?.runId ?? result?.runId ?? null,
|
|
commandId: base.agentRun?.commandId ?? result?.commandId ?? null,
|
|
runnerId: base.agentRun?.runnerId ?? result?.runnerId ?? null,
|
|
jobName: base.agentRun?.jobName ?? result?.jobName ?? null,
|
|
namespace: base.agentRun?.namespace ?? result?.namespace ?? null,
|
|
traceId: base.traceId ?? base.agentRun?.traceId ?? null,
|
|
threadId: result?.sessionRef?.threadId ?? agentRunEffectiveThreadId(base),
|
|
turnId: result?.turnId ?? null,
|
|
terminalStatus: terminalStatus ?? result?.terminalStatus ?? null,
|
|
failureKind: result?.failureKind ?? null,
|
|
failureMessage: result?.failureMessage ?? result?.blocker?.message ?? null,
|
|
willRetry: result?.willRetry === true ? true : undefined,
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function agentRunFailureAttribution({ code, message, canceled = false } = {}) {
|
|
if (canceled) {
|
|
return {
|
|
category: "canceled",
|
|
retryable: true,
|
|
userMessage: "AgentRun 请求已取消。",
|
|
summary: message || "AgentRun command was canceled."
|
|
};
|
|
}
|
|
if (code === "provider-invalid-tool-call" || /invalid function arguments json string|invalid_prompt|tool_call_id/iu.test(String(message ?? ""))) {
|
|
return {
|
|
category: "provider_invalid_tool_call",
|
|
retryable: true,
|
|
userMessage: "AgentRun/provider 返回了无效 tool-call arguments JSON；这不是 HWPOD 或 Cloud API 端点失败，请查看 providerTrace.failureKind 和 runnerTrace 定位上游 tool_call_id。",
|
|
summary: message || "AgentRun/provider returned invalid tool-call arguments JSON."
|
|
};
|
|
}
|
|
if (code === "thread-resume-failed") {
|
|
return {
|
|
category: "thread_resume_failed",
|
|
retryable: true,
|
|
userMessage: "AgentRun 复用的 thread 已失效；当前 turn 会按失败终止，Workbench 会清理 stale continuation 指针，下一轮自动从新 session/thread 启动。",
|
|
summary: message || "AgentRun thread/resume failed for an existing thread."
|
|
};
|
|
}
|
|
return {
|
|
category: "agentrun_failed",
|
|
retryable: true,
|
|
userMessage: "AgentRun 请求失败；请查看 runnerTrace、providerTrace 和 agentRun 字段定位 runId/commandId/jobName。",
|
|
summary: message || "AgentRun command failed."
|
|
};
|
|
}
|
|
|
|
export function agentRunLongLivedSessionGate(base = {}) {
|
|
const session = agentRunSessionSummary(base, "idle");
|
|
return {
|
|
status: "pass",
|
|
pass: true,
|
|
requiredCapability: AGENTRUN_CAPABILITY_LEVEL,
|
|
currentCapability: AGENTRUN_IMPLEMENTATION_TYPE,
|
|
sessionId: session.sessionId ?? null,
|
|
sessionStatus: session.status ?? null,
|
|
runnerKind: AGENTRUN_RUNNER_KIND,
|
|
provider: providerForBackendProfile(base.agentRun?.backendProfile ?? "deepseek"),
|
|
sessionMode: AGENTRUN_SESSION_MODE,
|
|
implementationType: AGENTRUN_IMPLEMENTATION_TYPE,
|
|
adapter: ADAPTER_ID,
|
|
delegatedToAgentRun: true,
|
|
codexStdio: false,
|
|
blockers: [],
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function agentRunToolCalls(result = {}, status = "completed", replyTextOverride = null) {
|
|
const replyText = messageAuthorityTextValue(replyTextOverride) || agentRunReplyText(result);
|
|
return [{
|
|
name: "agentrun.v01.command.turn",
|
|
status,
|
|
runId: result?.runId ?? null,
|
|
commandId: result?.commandId ?? null,
|
|
outputSummary: replyText ? `assistantChars=${replyText.length}` : null,
|
|
valuesPrinted: false
|
|
}];
|
|
}
|
|
|
|
export function agentRunReplyText(result = {}) {
|
|
for (const value of [result?.reply, result?.assistantMessage, result?.finalResponse, result?.content, result?.text, result?.message]) {
|
|
const text = messageAuthorityTextValue(value);
|
|
if (text) return text;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
export function agentRunResultToCodeAgentPayload({ base, result, traceStore, traceId, appendResultEvent = true }) {
|
|
const terminalStatus = String(result?.terminalStatus ?? "");
|
|
const normalizedTerminalStatus = terminalStatus.trim().toLowerCase().replace(/_/gu, "-");
|
|
const retryableInterruption = normalizedTerminalStatus !== "completed" && isRetryableProviderInterruptionPayload(result);
|
|
const terminal = !retryableInterruption && ["completed", "failed", "blocked", "cancelled", "canceled"].includes(normalizedTerminalStatus);
|
|
if (!terminal) {
|
|
if (retryableInterruption && appendResultEvent) {
|
|
traceStore.append(traceId, agentRunProviderRetryEvent({ base, payload: result, status: "retrying", label: "agentrun:provider-retry:provider-stream-disconnected" }), base.agentRun);
|
|
}
|
|
const runningMapping = retryableInterruption ? {
|
|
...base.agentRun,
|
|
status: "retrying",
|
|
commandState: "retrying",
|
|
failureKind: normalizedFailureKind(result?.failureKind),
|
|
willRetry: true
|
|
} : base.agentRun;
|
|
const running = decorateAgentRunRunningResult({ base, mapping: runningMapping, traceStore, traceId });
|
|
if (!retryableInterruption) return running;
|
|
return {
|
|
...running,
|
|
status: "retrying",
|
|
providerTrace: agentRunProviderTrace({ base, result, terminalStatus }),
|
|
transient: { failureKind: normalizedFailureKind(result?.failureKind), willRetry: true, valuesRedacted: true },
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
const now = nowIso();
|
|
const runnerTrace = traceStore.snapshot(traceId, agentRunTraceMeta({}, {}));
|
|
const terminalEventCreatedAt = agentRunResultTraceCreatedAt(runnerTrace, now);
|
|
const providerTrace = agentRunProviderTrace({ base, result, terminalStatus });
|
|
const replyText = agentRunReplyText(result);
|
|
if (normalizedTerminalStatus === "completed") {
|
|
const traceReplyText = agentRunTraceTerminalAssistantText(runnerTrace);
|
|
const completedReplyText = replyText || traceReplyText;
|
|
const finalResponse = completedReplyText ? agentRunCompletedFinalResponse({ base, result, traceId, now, replyText: completedReplyText }) : null;
|
|
const traceSummary = agentRunCompletedTraceSummary({ base, runnerTrace, finalResponse, traceId });
|
|
if (appendResultEvent) {
|
|
traceStore.append(traceId, agentRunTraceEvent({
|
|
type: "result",
|
|
status: "completed",
|
|
label: "agentrun:result:completed",
|
|
createdAt: terminalEventCreatedAt,
|
|
message: "AgentRun result is committed to the Workbench projection event stream.",
|
|
runId: base.agentRun.runId,
|
|
commandId: base.agentRun.commandId,
|
|
terminal: true,
|
|
valuesPrinted: false
|
|
}, base.agentRun));
|
|
}
|
|
return {
|
|
...base,
|
|
status: "completed",
|
|
messageId: finalResponse?.messageId ?? base.messageId ?? `msg_${traceId.slice(4)}`,
|
|
threadId: agentRunEffectiveThreadId(base),
|
|
updatedAt: now,
|
|
workspace: base.workspace ?? "/home/agentrun/workspace",
|
|
sandbox: base.sandbox ?? "danger-full-access",
|
|
session: agentRunSessionSummary(base, "idle"),
|
|
sessionReuse: agentRunSessionReuseSummary(base, base.agentRun.reused === true),
|
|
runner: agentRunRunnerSummary(base.agentRun),
|
|
runnerTrace: traceStore.snapshot(traceId, agentRunTraceMeta({}, {})),
|
|
toolCalls: agentRunToolCalls(result, "completed", completedReplyText),
|
|
skills: { status: "delegated", provider: ADAPTER_ID, count: 0, items: [], valuesPrinted: false },
|
|
longLivedSessionGate: agentRunLongLivedSessionGate(base),
|
|
providerTrace,
|
|
finalResponse: finalResponse ?? null,
|
|
traceSummary,
|
|
reply: finalResponse ? {
|
|
messageId: finalResponse.messageId,
|
|
role: "assistant",
|
|
content: finalResponse.text,
|
|
createdAt: finalResponse.createdAt
|
|
} : null,
|
|
usage: null,
|
|
agentRun: { ...base.agentRun, terminalStatus, completed: true, reuseEligible: true, providerTrace, valuesPrinted: false },
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
const canceled = terminalStatus === "cancelled";
|
|
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");
|
|
const attribution = agentRunFailureAttribution({ code, message, canceled });
|
|
const finalResponse = agentRunTerminalFailureFinalResponse({
|
|
base,
|
|
traceId,
|
|
now,
|
|
status: canceled ? "canceled" : "failed",
|
|
text: firstNonEmpty(message, attribution.summary, attribution.userMessage)
|
|
});
|
|
const traceSummary = agentRunTerminalFailureTraceSummary({ base, runnerTrace, finalResponse, traceId, terminalStatus: canceled ? "canceled" : terminalStatus || "failed" });
|
|
if (appendResultEvent) {
|
|
traceStore.append(traceId, agentRunTraceEvent({
|
|
type: "result",
|
|
status: canceled ? "canceled" : "failed",
|
|
label: `agentrun:result:${canceled ? "canceled" : terminalStatus || "failed"}`,
|
|
createdAt: terminalEventCreatedAt,
|
|
errorCode: code,
|
|
message: attribution.summary,
|
|
runId: base.agentRun.runId,
|
|
commandId: base.agentRun.commandId,
|
|
terminal: true,
|
|
valuesPrinted: false
|
|
}, base.agentRun));
|
|
}
|
|
const partialContext = partialAgentRunContext(runnerTrace);
|
|
const freshSessionRequired = !canceled && agentRunFailureRequiresFreshSession(code, message);
|
|
const failedSessionStatus = freshSessionRequired ? "thread-resume-failed" : "failed";
|
|
const resumableAfterFailure = !canceled && !freshSessionRequired && Boolean(agentRunEffectiveThreadId(base));
|
|
return {
|
|
...base,
|
|
status: canceled ? "canceled" : "failed",
|
|
messageId: finalResponse.messageId,
|
|
threadId: agentRunEffectiveThreadId(base),
|
|
canceled,
|
|
updatedAt: now,
|
|
session: agentRunSessionSummary(base, canceled ? "canceled" : failedSessionStatus),
|
|
sessionReuse: agentRunSessionReuseSummary(base, base.agentRun.reused === true, { status: canceled ? undefined : freshSessionRequired ? "thread-resume-failed" : resumableAfterFailure ? "failed-resumable" : "failed-requires-new-session" }),
|
|
runner: agentRunRunnerSummary(base.agentRun),
|
|
runnerTrace: partialContext ? { ...runnerTrace, partialContext } : runnerTrace,
|
|
toolCalls: agentRunToolCalls(result, canceled ? "canceled" : "failed"),
|
|
skills: { status: "delegated", provider: ADAPTER_ID, count: 0, items: [], valuesPrinted: false },
|
|
providerTrace,
|
|
finalResponse,
|
|
traceSummary,
|
|
error: {
|
|
code,
|
|
layer: "agentrun",
|
|
category: attribution.category,
|
|
retryable: attribution.retryable,
|
|
message,
|
|
userMessage: attribution.userMessage,
|
|
traceId,
|
|
route: "/v1/agent/chat",
|
|
toolName: "agentrun.manual-dispatch"
|
|
},
|
|
blocker: canceled ? null : {
|
|
code,
|
|
layer: "agentrun",
|
|
category: attribution.category,
|
|
retryable: attribution.retryable,
|
|
summary: attribution.summary,
|
|
traceId,
|
|
route: "/v1/agent/chat",
|
|
toolName: "agentrun.manual-dispatch"
|
|
},
|
|
agentRun: { ...base.agentRun, terminalStatus, completed: false, reuseEligible: resumableAfterFailure, providerTrace, valuesPrinted: false },
|
|
reuseEligible: resumableAfterFailure,
|
|
...(partialContext ? { partialContext } : {}),
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function agentRunCompletedFinalResponse({ base, result, traceId, now, replyText = null }) {
|
|
const textValue = messageAuthorityTextValue(replyText) || agentRunReplyText(result);
|
|
return {
|
|
text: textValue,
|
|
textChars: textValue.length,
|
|
role: "assistant",
|
|
status: "completed",
|
|
traceId,
|
|
messageId: base.messageId ?? base.reply?.messageId ?? `msg_${traceId.slice(4)}`,
|
|
createdAt: base.reply?.createdAt ?? base.createdAt ?? now,
|
|
updatedAt: now,
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function agentRunTraceTerminalAssistantText(runnerTrace = {}) {
|
|
const events = Array.isArray(runnerTrace?.events) ? runnerTrace.events : [];
|
|
for (let index = events.length - 1; index >= 0; index -= 1) {
|
|
const event = events[index];
|
|
if (!event || typeof event !== "object") continue;
|
|
if (!isAgentRunAssistantTraceEvent(event)) continue;
|
|
if (!(event.terminal === true || event.final === true || event.replyAuthority === true)) continue;
|
|
const textValue = messageAuthorityTextValue(event.finalResponse ?? event.text ?? event.content ?? event.message ?? event.summary ?? event.payload?.text ?? event.payload?.content ?? event.payload?.message);
|
|
if (textValue) return textValue;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
export function isAgentRunAssistantTraceEvent(event = {}) {
|
|
const type = String(event.type ?? event.eventType ?? "").trim().toLowerCase();
|
|
if (type === "assistant" || type === "assistant_message") return true;
|
|
return /assistant:message|assistant_message/u.test(String(event.label ?? "").toLowerCase());
|
|
}
|
|
|
|
export function agentRunTerminalFailureFinalResponse({ base, traceId, now, status, text }) {
|
|
const textValue = String(text ?? "").trim();
|
|
return {
|
|
text: textValue || "AgentRun command failed.",
|
|
textChars: (textValue || "AgentRun command failed.").length,
|
|
role: "assistant",
|
|
status,
|
|
traceId,
|
|
messageId: base.messageId ?? base.reply?.messageId ?? `msg_${traceId.slice(4)}`,
|
|
createdAt: base.reply?.createdAt ?? base.createdAt ?? now,
|
|
updatedAt: now,
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function agentRunTerminalFailureTraceSummary({ base, runnerTrace, finalResponse, traceId, terminalStatus }) {
|
|
const events = Array.isArray(runnerTrace?.events) ? runnerTrace.events : [];
|
|
const lastSeq = Math.max(0, ...events.map((event) => Number(event?.seq ?? 0)).filter(Number.isFinite));
|
|
return {
|
|
traceId,
|
|
source: "agentrun-command-result",
|
|
sourceEventCount: Number(runnerTrace?.eventCount ?? events.length ?? 0),
|
|
terminalStatus,
|
|
finalAssistantRow: {
|
|
role: finalResponse.role,
|
|
status: finalResponse.status,
|
|
textChars: finalResponse.textChars,
|
|
textPreview: finalResponse.text.slice(0, 240),
|
|
messageId: finalResponse.messageId,
|
|
valuesPrinted: false
|
|
},
|
|
agentRun: {
|
|
runId: base.agentRun?.runId ?? null,
|
|
commandId: base.agentRun?.commandId ?? null,
|
|
lastSeq,
|
|
valuesPrinted: false
|
|
},
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function agentRunCompletedTraceSummary({ base, runnerTrace, finalResponse, traceId }) {
|
|
const events = Array.isArray(runnerTrace?.events) ? runnerTrace.events : [];
|
|
const lastSeq = Math.max(0, ...events.map((event) => Number(event?.seq ?? 0)).filter(Number.isFinite));
|
|
return {
|
|
traceId,
|
|
source: "agentrun-command-result",
|
|
sourceEventCount: Number(runnerTrace?.eventCount ?? events.length ?? 0),
|
|
terminalStatus: "completed",
|
|
finalAssistantRow: finalResponse ? {
|
|
role: finalResponse.role,
|
|
status: finalResponse.status,
|
|
textChars: finalResponse.textChars,
|
|
textPreview: finalResponse.text.slice(0, 240),
|
|
messageId: finalResponse.messageId,
|
|
valuesPrinted: false
|
|
} : null,
|
|
agentRun: {
|
|
runId: base.agentRun?.runId ?? null,
|
|
commandId: base.agentRun?.commandId ?? null,
|
|
lastSeq,
|
|
valuesPrinted: false
|
|
},
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function partialAgentRunContext(runnerTrace = {}) {
|
|
const events = Array.isArray(runnerTrace.events) ? runnerTrace.events : [];
|
|
const assistantMessages = events
|
|
.filter((event) => event?.type === "assistant" && String(event.text ?? event.message ?? "").trim())
|
|
.map((event) => String(event.text ?? event.message).trim())
|
|
.slice(-4);
|
|
const toolEvidence = events
|
|
.filter((event) => event?.type === "tool_call" && String(event.status ?? "") === "completed")
|
|
.map((event) => [event.toolName ?? event.label ?? "tool", event.command ?? event.outputSummary ?? event.stdoutSummary ?? event.message ?? ""].filter(Boolean).join(": "))
|
|
.filter(Boolean)
|
|
.slice(-6);
|
|
if (assistantMessages.length === 0 && toolEvidence.length === 0) return null;
|
|
return {
|
|
status: "partial-before-terminal",
|
|
summary: "AgentRun terminal 前已有可延续的 assistant/tool 上下文；后续同 conversation/session/thread 轮次必须能继续使用。",
|
|
assistantMessages,
|
|
toolEvidence,
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function agentRunResultTraceCreatedAt(runnerTrace = {}, fallback) {
|
|
const last = String(runnerTrace?.lastEvent?.createdAt ?? runnerTrace?.updatedAt ?? "");
|
|
return Number.isFinite(Date.parse(last)) ? last : fallback;
|
|
}
|
|
|
|
export function decorateAgentRunRunningResult({ base, mapping, traceStore, traceId }) {
|
|
return {
|
|
...base,
|
|
status: "running",
|
|
threadId: agentRunEffectiveThreadId({ agentRun: mapping }),
|
|
accepted: true,
|
|
shortConnection: true,
|
|
updatedAt: nowIso(),
|
|
session: agentRunSessionSummary({ ...base, agentRun: mapping }, "running"),
|
|
sessionReuse: agentRunSessionReuseSummary({ ...base, agentRun: mapping }, mapping.reused === true),
|
|
runner: agentRunRunnerSummary(mapping),
|
|
runnerTrace: traceStore.snapshot(traceId, agentRunTraceMeta({}, {})),
|
|
agentRun: { ...mapping, adapter: ADAPTER_ID, valuesPrinted: false },
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function appendAgentRunEventsToTrace(traceStore, traceId, events, mapping = {}) {
|
|
for (const event of events) {
|
|
if (isForeignAgentRunCommandEvent(event, mapping)) continue;
|
|
const normalized = mapAgentRunEvent(event, mapping);
|
|
if (normalized) traceStore.append(traceId, normalized, agentRunTraceMeta({}, {}));
|
|
}
|
|
}
|
|
function agentRunEventCommandId(event) {
|
|
const payload = event?.payload && typeof event.payload === "object" ? event.payload : {};
|
|
if (typeof event?.commandId === "string") return event.commandId;
|
|
return typeof payload.commandId === "string" ? payload.commandId : "";
|
|
}
|
|
|
|
export function isForeignAgentRunCommandEvent(event, mapping = {}) {
|
|
const currentCommandId = typeof mapping.commandId === "string" ? mapping.commandId : "";
|
|
if (!currentCommandId) return false;
|
|
const eventCommandId = agentRunEventCommandId(event);
|
|
return Boolean(eventCommandId && eventCommandId !== currentCommandId);
|
|
}
|
|
|
|
export function mapAgentRunEvent(event, mapping = {}) {
|
|
if (!event || typeof event !== "object") return null;
|
|
const payload = event.payload && typeof event.payload === "object" ? event.payload : {};
|
|
const base = {
|
|
createdAt: event.createdAt ?? null,
|
|
source: "agentrun",
|
|
sourceSeq: event.seq ?? null,
|
|
backend: backendForBackendProfile(mapping.backendProfile ?? payload.backendProfile ?? payload.providerProfile ?? "deepseek"),
|
|
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",
|
|
eventType: "backend",
|
|
status: "running",
|
|
label: `agentrun:backend:${phase}`,
|
|
message: textPayload(payload, phase),
|
|
waitingFor: waitingForForPhase(phase),
|
|
details: agentRunBackendStatusDetails(phase, payload)
|
|
};
|
|
}
|
|
if (event.type === "assistant_message") {
|
|
const terminal = payload.replyAuthority === true || payload.final === true;
|
|
return {
|
|
...base,
|
|
type: "assistant",
|
|
eventType: "assistant",
|
|
status: terminal ? "completed" : "running",
|
|
label: "agentrun:assistant:message",
|
|
message: textPayload(payload, "assistant message"),
|
|
text: textPayload(payload, ""),
|
|
itemId: payload.itemId ?? null,
|
|
messageIndex: payload.messageIndex ?? null,
|
|
messageCount: payload.messageCount ?? null,
|
|
replyAuthority: payload.replyAuthority === true,
|
|
final: payload.final === true,
|
|
terminal
|
|
};
|
|
}
|
|
if (event.type === "tool_call") {
|
|
const commandExecution = agentRunCommandExecutionEvent(base, payload);
|
|
if (commandExecution) return commandExecution;
|
|
const preview = agentRunToolCallPreviewSummary(payload);
|
|
const toolName = firstNonEmpty(
|
|
payload.toolName,
|
|
payload.name,
|
|
payload.item?.type,
|
|
payload.type,
|
|
preview.toolName,
|
|
preview.name,
|
|
preview.type,
|
|
isProtocolToolLifecycleMethod(payload.method) ? null : payload.method,
|
|
"tool call"
|
|
);
|
|
const command = firstNonEmpty(payload.command, payload.commandLine, payload.item?.command, payload.item?.commandLine, preview.command, preview.commandLine);
|
|
const output = firstNonEmpty(payload.outputSummary, payload.stdoutSummary, preview.outputSummary, preview.stdoutSummary, payload.summary?.text, payload.itemPreview);
|
|
return {
|
|
...base,
|
|
type: "tool_call",
|
|
eventType: "tool_call",
|
|
status: String(payload.status ?? preview.status ?? (payload.method === "item/completed" ? "completed" : "running")),
|
|
label: `agentrun:tool:${String(toolName)}`,
|
|
itemId: payload.item?.id ?? payload.itemId ?? preview.itemId ?? null,
|
|
toolName,
|
|
command,
|
|
exitCode: Number.isInteger(payload.item?.exitCode) ? payload.item.exitCode : Number.isInteger(payload.exitCode) ? payload.exitCode : undefined,
|
|
durationMs: typeof payload.item?.durationMs === "number" ? payload.item.durationMs : typeof payload.durationMs === "number" ? payload.durationMs : undefined,
|
|
stdoutSummary: output,
|
|
outputSummary: output,
|
|
message: output || command || textPayload(payload, "tool call"),
|
|
outputBytes: typeof payload.outputBytes === "number" ? payload.outputBytes : payload.summary?.outputBytes,
|
|
outputTruncated: payload.outputTruncated === true || payload.summary?.outputTruncated === true
|
|
};
|
|
}
|
|
if (event.type === "command_output") {
|
|
const stream = payload.stream === "stderr" ? "stderr" : "stdout";
|
|
return { ...base, type: "output", eventType: "status", status: "running", label: `agentrun:output:${stream}`, stream, message: textPayload(payload, ""), outputTruncated: payload.outputTruncated === true };
|
|
}
|
|
if (event.type === "diff") {
|
|
return { ...base, type: "diff", eventType: "status", status: "running", label: "agentrun:diff", message: textPayload(payload, "diff") };
|
|
}
|
|
if (event.type === "error") {
|
|
const failureKind = normalizedFailureKind(payload.failureKind ?? payload.errorCode ?? "backend") ?? "backend";
|
|
const normalizedPayload = { ...payload, failureKind, errorCode: failureKind };
|
|
if (isRetryableProviderInterruptionPayload(normalizedPayload, { activeError: true })) return agentRunProviderRetryEvent({ base, payload: { ...normalizedPayload, willRetry: true }, status: "retrying", label: `agentrun:provider-retry:${failureKind}` });
|
|
return { ...base, type: "error", eventType: "error", status: "failed", label: `agentrun:error:${failureKind}`, errorCode: failureKind, failureKind, willRetry: payload.willRetry === true ? true : undefined, message: textPayload(payload, "AgentRun error") };
|
|
}
|
|
if (event.type === "terminal_status") {
|
|
const terminalStatus = String(payload.terminalStatus ?? event.terminalStatus ?? payload.status ?? event.status ?? "failed");
|
|
const failureKind = normalizedFailureKind(payload.failureKind ?? payload.errorCode ?? event.failureKind ?? event.errorCode) ?? null;
|
|
const normalizedPayload = failureKind ? { ...payload, failureKind, errorCode: failureKind } : payload;
|
|
if (isRetryableProviderInterruptionPayload(normalizedPayload)) return agentRunProviderRetryEvent({ base, payload: normalizedPayload, status: "retrying", label: `agentrun:provider-retry:${terminalStatus}` });
|
|
return { ...base, type: "result", eventType: "terminal", status: terminalStatus === "cancelled" ? "canceled" : terminalStatus, label: `agentrun:terminal:${terminalStatus}`, errorCode: failureKind, failureKind, willRetry: payload.willRetry === true || event.willRetry === true ? true : undefined, message: textPayload({ ...event, ...payload }, `AgentRun terminal status ${terminalStatus}`), terminal: true };
|
|
}
|
|
return { ...base, type: "backend", eventType: "backend", status: "running", label: `agentrun:event:${String(event.type ?? "unknown")}`, message: textPayload(payload, "AgentRun event") };
|
|
}
|
|
|
|
export function agentRunProviderRetryEvent({ base = {}, payload = {}, status = "retrying", label = "agentrun:provider-retry" } = {}) {
|
|
const failureKind = normalizedFailureKind(payload.failureKind ?? payload.errorCode ?? "provider-stream-disconnected");
|
|
const retryMessage = providerRetryMessage(textPayload(payload, "Provider stream disconnected; AgentRun will retry."), payload);
|
|
return {
|
|
...base,
|
|
type: "provider_retry",
|
|
eventType: "backend",
|
|
status,
|
|
label,
|
|
errorCode: failureKind,
|
|
failureKind,
|
|
willRetry: payload.willRetry === true,
|
|
retryable: true,
|
|
transient: true,
|
|
terminal: false,
|
|
retryAttempt: numberOrNull(payload.retryAttempt),
|
|
retryMax: numberOrNull(payload.retryMax),
|
|
retryDelayMs: numberOrNull(payload.retryDelayMs),
|
|
nextRetryAt: firstNonEmpty(payload.nextRetryAt) || null,
|
|
retryOf: payload.retryOf ?? null,
|
|
terminalStatus: payload.terminalStatus ?? null,
|
|
message: retryMessage,
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function providerRetryMessage(message, payload = {}) {
|
|
const attempt = numberOrNull(payload.retryAttempt);
|
|
const max = numberOrNull(payload.retryMax);
|
|
const delayMs = numberOrNull(payload.retryDelayMs);
|
|
const nextRetryAt = firstNonEmpty(payload.nextRetryAt) || null;
|
|
const parts = [];
|
|
if (attempt !== null && max !== null) parts.push(`retry ${attempt}/${max}`);
|
|
else if (attempt !== null) parts.push(`retry attempt ${attempt}`);
|
|
else if (max !== null) parts.push(`retry max ${max}`);
|
|
if (delayMs !== null) parts.push(`after ${delayMs}ms`);
|
|
if (nextRetryAt) parts.push(`next=${nextRetryAt}`);
|
|
if (parts.length === 0) return message;
|
|
const text = String(message || "Provider stream disconnected; AgentRun will retry.").trim();
|
|
if (attempt !== null && max !== null && text.includes(`${attempt}/${max}`)) return text;
|
|
return text.replace(/[.。]\s*$/u, "") + `; ${parts.join(" ")}.`;
|
|
}
|
|
|
|
export function isRetryableProviderInterruptionPayload(payload = {}, options = {}) {
|
|
const kind = normalizedFailureKind(payload?.failureKind ?? payload?.errorCode ?? payload?.code);
|
|
if (kind === "provider-stream-disconnected") return payload?.willRetry === true;
|
|
if (kind === "provider-unavailable") return payload?.willRetry === true || (options.activeError === true && payload?.terminal !== true && payload?.final !== true);
|
|
if (isRetryableAgentRunTransportFailureKind(kind)) return payload?.willRetry === true;
|
|
return false;
|
|
}
|
|
|
|
export function normalizedFailureKind(value) {
|
|
const normalized = String(value ?? "").trim().toLowerCase().replace(/_/gu, "-") || null;
|
|
if (normalized === "agentrun-unreachable") return "agentrun-connect-failed";
|
|
return normalized;
|
|
}
|
|
|
|
export function numberOrNull(value) {
|
|
const number = Number(value);
|
|
return Number.isFinite(number) ? number : null;
|
|
}
|
|
|
|
export function agentRunTraceEvent(event = {}, backendSource = {}) {
|
|
const source = backendSource && typeof backendSource === "object" ? backendSource : { backendProfile: backendSource };
|
|
const backendProfile = firstNonEmpty(event.backendProfile, source.backendProfile, source.providerProfile, source.agentRun?.backendProfile);
|
|
return {
|
|
...event,
|
|
eventType: event.eventType ?? agentRunManualEventType(event),
|
|
backend: event.backend ?? (backendProfile ? backendForBackendProfile(backendProfile) : null),
|
|
backendProfile: event.backendProfile ?? backendProfile ?? null,
|
|
valuesPrinted: event.valuesPrinted ?? false
|
|
};
|
|
}
|
|
|
|
export function agentRunManualEventType(event = {}) {
|
|
const type = String(event.type ?? "").trim().toLowerCase();
|
|
if (type === "request") return "request";
|
|
if (type === "cancel" || type === "result") return "terminal";
|
|
if (type === "assistant") return "assistant";
|
|
if (type === "tool" || type === "tool_call") return "tool_call";
|
|
if (type === "error") return "error";
|
|
if (type === "backend") return "backend";
|
|
const raw = String(`${event.label ?? ""} ${event.status ?? ""}`).toLowerCase();
|
|
if (/request|accepted/u.test(raw)) return "request";
|
|
if (/cancel|terminal|complete|final/u.test(raw)) return "terminal";
|
|
if (/assistant|message|reply/u.test(raw)) return "assistant";
|
|
if (/error|fail|timeout/u.test(raw)) return "error";
|
|
if (/backend|runner|agentrun/u.test(raw)) return "backend";
|
|
return "status";
|
|
}
|
|
|
|
export function isProtocolToolLifecycleMethod(value) {
|
|
return /^item\/(started|completed)$/u.test(String(value ?? ""));
|
|
}
|
|
|
|
export function agentRunToolCallPreviewSummary(payload = {}) {
|
|
const text = firstNonEmpty(payload.itemPreview, payload.summary?.text);
|
|
return {
|
|
itemId: jsonPreviewStringField(text, "itemId"),
|
|
type: jsonPreviewStringField(text, "type"),
|
|
toolName: jsonPreviewStringField(text, "toolName"),
|
|
name: jsonPreviewStringField(text, "name"),
|
|
status: jsonPreviewStringField(text, "status"),
|
|
command: jsonPreviewStringField(text, "command"),
|
|
commandLine: jsonPreviewStringField(text, "commandLine"),
|
|
outputSummary: jsonPreviewStringField(text, "outputSummary"),
|
|
stdoutSummary: jsonPreviewStringField(text, "stdoutSummary")
|
|
};
|
|
}
|
|
|
|
export function jsonPreviewStringField(text, key) {
|
|
const body = String(text ?? "");
|
|
if (!body || !/^[A-Za-z][A-Za-z0-9_]*$/u.test(key)) return null;
|
|
const match = body.match(new RegExp(`"${key}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)"`, "u"));
|
|
if (!match) return null;
|
|
try {
|
|
const parsed = JSON.parse(`"${match[1]}"`);
|
|
return typeof parsed === "string" && parsed.trim() ? parsed.trim() : null;
|
|
} catch {
|
|
return match[1]?.trim() || null;
|
|
}
|
|
}
|
|
|
|
export function agentRunBackendStatusDetails(phase, payload = {}) {
|
|
if (phase === "initial-prompt-assembly") {
|
|
return compactObject({
|
|
initialPromptInjected: payload.initialPromptInjected === true,
|
|
reason: firstNonEmpty(payload.reason),
|
|
initialPrompt: agentRunResourceSummary(payload.initialPrompt),
|
|
valuesPrinted: false
|
|
});
|
|
}
|
|
if (phase === "resource-bundle-materialized") {
|
|
return compactObject({
|
|
kind: firstNonEmpty(payload.kind),
|
|
commitId: firstNonEmpty(payload.commitId),
|
|
bundles: agentRunResourceSummary(payload.bundles),
|
|
tools: agentRunResourceSummary(payload.tools),
|
|
promptRefs: agentRunResourceSummary(payload.promptRefs),
|
|
skillDirs: agentRunResourceSummary(payload.skillDirs),
|
|
initialPrompt: agentRunResourceSummary(payload.initialPrompt),
|
|
valuesPrinted: false
|
|
});
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
export function agentRunResourceSummary(value) {
|
|
if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
|
|
return compactObject({
|
|
available: typeof value.available === "boolean" ? value.available : undefined,
|
|
count: Number.isInteger(value.count) ? value.count : undefined,
|
|
bytes: Number.isInteger(value.bytes) ? value.bytes : undefined,
|
|
sha256: firstNonEmpty(value.sha256),
|
|
promptRefCount: Number.isInteger(value.promptRefCount) ? value.promptRefCount : undefined,
|
|
skillCount: Number.isInteger(value.skillCount) ? value.skillCount : undefined,
|
|
toolCount: Number.isInteger(value.toolCount) ? value.toolCount : undefined,
|
|
names: Array.isArray(value.names) ? value.names.map((item) => firstNonEmpty(item)).filter(Boolean).slice(0, 20) : undefined,
|
|
targetPaths: Array.isArray(value.targetPaths) ? value.targetPaths.map((item) => firstNonEmpty(item)).filter(Boolean).slice(0, 20) : undefined,
|
|
skillNames: Array.isArray(value.skillNames) ? value.skillNames.map((item) => firstNonEmpty(item)).filter(Boolean).slice(0, 20) : undefined,
|
|
requiredMissing: Array.isArray(value.requiredMissing) ? value.requiredMissing.map((item) => firstNonEmpty(item)).filter(Boolean).slice(0, 20) : undefined,
|
|
valuesPrinted: false
|
|
});
|
|
}
|
|
|
|
export function compactObject(value) {
|
|
if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
|
|
const result = {};
|
|
for (const [key, item] of Object.entries(value)) {
|
|
if (item === undefined || item === null) continue;
|
|
if (Array.isArray(item) && item.length === 0) continue;
|
|
if (typeof item === "object" && !Array.isArray(item) && Object.keys(item).length === 0) continue;
|
|
result[key] = item;
|
|
}
|
|
return Object.keys(result).length > 0 ? result : undefined;
|
|
}
|
|
|
|
export function agentRunCommandExecutionEvent(base, payload = {}) {
|
|
const item = payload.item && typeof payload.item === "object" ? payload.item : null;
|
|
const payloadToolType = firstNonEmpty(payload.toolName, payload.type, payload.name);
|
|
if (item?.type !== "commandExecution" && payloadToolType !== "commandExecution") return null;
|
|
const method = String(payload.method ?? "");
|
|
const completed = method === "item/completed" || payload.status === "completed" || item?.status === "completed";
|
|
const output = firstNonEmpty(item?.aggregatedOutput, item?.stdout, item?.output, payload.outputSummary, payload.stdoutSummary, payload.summary?.text, payload.itemPreview);
|
|
return {
|
|
...base,
|
|
type: "tool_call",
|
|
status: completed ? "completed" : "started",
|
|
label: completed ? "item/commandExecution:completed" : "item/commandExecution:started",
|
|
toolName: "commandExecution",
|
|
itemId: item?.id ?? payload.itemId ?? null,
|
|
command: firstNonEmpty(item?.command, item?.commandLine, payload.command, payload.commandLine),
|
|
exitCode: Number.isInteger(item?.exitCode) ? item.exitCode : Number.isInteger(payload.exitCode) ? payload.exitCode : undefined,
|
|
durationMs: typeof item?.durationMs === "number" ? item.durationMs : typeof payload.durationMs === "number" ? payload.durationMs : undefined,
|
|
outputBytes: typeof payload.outputBytes === "number" ? payload.outputBytes : payload.summary?.outputBytes,
|
|
stdoutSummary: output,
|
|
outputSummary: output,
|
|
outputTruncated: payload.outputTruncated === true || payload.summary?.outputTruncated === true,
|
|
message: output || textPayload(payload, "commandExecution")
|
|
};
|
|
}
|
|
|
|
export function nowMs() {
|
|
if (typeof performance !== "undefined" && typeof performance.now === "function") return performance.now();
|
|
return Date.now();
|
|
}
|
|
|
|
export function agentRunMapping({ env, managerUrl, backendProfile, run, command, dispatchIntent, traceId, startedAt, params = {} }) {
|
|
if (dispatchIntent?.durable !== true) {
|
|
throw new Error("AgentRun mapping requires a confirmed durable dispatch intent.");
|
|
}
|
|
const threadReused = Boolean(safeOpaqueId(params.threadId));
|
|
return {
|
|
adapter: ADAPTER_ID,
|
|
managerUrl,
|
|
backendProfile,
|
|
providerId: resolveAgentRunProviderId(env),
|
|
runId: run.id,
|
|
commandId: command.id,
|
|
attemptId: null,
|
|
runnerId: null,
|
|
runnerJobId: dispatchIntent.runnerJobId,
|
|
jobName: null,
|
|
namespace: firstNonEmpty(env.HWLAB_CODE_AGENT_AGENTRUN_RUNNER_NAMESPACE, env.AGENTRUN_RUNTIME_NAMESPACE, DEFAULT_RUNNER_NAMESPACE),
|
|
status: `dispatch-intent-${dispatchIntent.state}`,
|
|
dispatchIntentId: dispatchIntent.id,
|
|
dispatchIntentState: dispatchIntent.state,
|
|
durableDispatch: true,
|
|
runStatus: run.status ?? null,
|
|
commandState: command.state ?? null,
|
|
terminalStatus: null,
|
|
lastSeq: 0,
|
|
traceId,
|
|
...codeAgentOtelTraceFields(traceId, env),
|
|
sessionId: run?.sessionRef?.sessionId ?? null,
|
|
conversationId: run?.sessionRef?.conversationId ?? null,
|
|
threadId: run?.sessionRef?.threadId ?? null,
|
|
runnerReused: false,
|
|
runnerJobCount: dispatchIntent.state === "dispatched" ? 1 : 0,
|
|
threadReused,
|
|
persistentResume: threadReused,
|
|
reused: false,
|
|
reuseEligible: true,
|
|
createdAt: startedAt,
|
|
updatedAt: nowIso(),
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function agentRunReusedMapping({ previous = {}, run = {}, command = {}, traceId, startedAt, backendProfile, managerUrl, env }) {
|
|
const threadReused = Boolean(safeOpaqueId(run?.sessionRef?.threadId ?? previous.threadId));
|
|
return {
|
|
...previous,
|
|
adapter: ADAPTER_ID,
|
|
managerUrl,
|
|
backendProfile,
|
|
providerId: previous.providerId ?? resolveAgentRunProviderId(env),
|
|
runId: previous.runId ?? run?.id,
|
|
commandId: command.id,
|
|
attemptId: previous.attemptId ?? null,
|
|
runnerId: previous.runnerId ?? null,
|
|
runnerJobId: previous.runnerJobId ?? null,
|
|
jobName: previous.jobName ?? null,
|
|
namespace: previous.namespace ?? DEFAULT_RUNNER_NAMESPACE,
|
|
status: "runner-job-reused",
|
|
runStatus: run?.status ?? previous.runStatus ?? null,
|
|
commandState: command.state ?? null,
|
|
terminalStatus: null,
|
|
lastSeq: previous.lastSeq ?? 0,
|
|
runnerJobCount: Number(previous.runnerJobCount ?? 0),
|
|
traceId,
|
|
sessionId: run?.sessionRef?.sessionId ?? previous.sessionId ?? null,
|
|
conversationId: run?.sessionRef?.conversationId ?? previous.conversationId ?? null,
|
|
threadId: run?.sessionRef?.threadId ?? previous.threadId ?? null,
|
|
runnerReused: true,
|
|
threadReused,
|
|
persistentResume: threadReused,
|
|
reused: true,
|
|
reuseEligible: true,
|
|
createdAt: previous.createdAt ?? startedAt,
|
|
updatedAt: nowIso(),
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export 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];
|
|
}
|
|
if (result?.sessionRef && typeof result.sessionRef === "object") {
|
|
if (result.sessionRef.sessionId) refs.sessionId = result.sessionRef.sessionId;
|
|
if (result.sessionRef.conversationId) refs.conversationId = result.sessionRef.conversationId;
|
|
if (result.sessionRef.threadId) refs.threadId = result.sessionRef.threadId;
|
|
}
|
|
return refs;
|
|
}
|
|
|
|
export function withAgentRunRunnerJobCount(mapping = {}) {
|
|
if (!mapping || typeof mapping !== "object") return mapping;
|
|
const count = Number(mapping.runnerJobCount);
|
|
if (Number.isFinite(count) && count >= 0) return mapping;
|
|
const runnerJobEnsured = mapping.reused === true || mapping.status === "runner-job-ensured";
|
|
if (runnerJobEnsured && (mapping.runnerJobId || mapping.jobName || mapping.attemptId || mapping.runnerId)) {
|
|
return { ...mapping, runnerJobCount: 1 };
|
|
}
|
|
return mapping;
|
|
}
|
|
|
|
export function hwlabSessionIdForParams(params = {}) {
|
|
return safeSessionId(params.sessionId) || null;
|
|
}
|
|
|
|
export function scopedAgentRunSessionIdForParams(params = {}, traceId) {
|
|
const baseSessionId = hwlabSessionIdForParams(params, traceId);
|
|
if (!safeSessionId(baseSessionId)) {
|
|
throw adapterError(
|
|
"agentrun_session_id_required",
|
|
"AgentRun persistent session/PVC requires params.sessionId; refusing to derive sessionRef.sessionId from traceId because that would create a new PVC per turn."
|
|
);
|
|
}
|
|
const base = String(baseSessionId).replace(/^ses_/u, "").replace(/[^A-Za-z0-9_]+/gu, "_").replace(/^_+|_+$/gu, "") || "session";
|
|
return `ses_agentrun_${base}`;
|
|
}
|
|
|
|
export function agentRunSessionId(traceId) {
|
|
return `ses_agentrun_${String(safeTraceId(traceId) || `trc_${randomUUID()}`).slice(4)}`;
|
|
}
|
|
|
|
export function agentRunEffectiveThreadId(base = {}) {
|
|
const agentRun = base?.agentRun && typeof base.agentRun === "object" ? base.agentRun : null;
|
|
if (agentRun && Object.hasOwn(agentRun, "threadId")) return safeOpaqueId(agentRun.threadId) || null;
|
|
return safeOpaqueId(base?.threadId) || null;
|
|
}
|
|
|
|
export function agentRunSessionSummary(base, status) {
|
|
return decorateCodeAgentSession({
|
|
sessionId: base.sessionId ?? base.agentRun?.sessionId ?? null,
|
|
conversationId: base.conversationId ?? base.agentRun?.conversationId ?? null,
|
|
threadId: agentRunEffectiveThreadId(base),
|
|
status,
|
|
sessionMode: AGENTRUN_SESSION_MODE,
|
|
runnerKind: AGENTRUN_RUNNER_KIND,
|
|
lastTraceId: base.traceId ?? base.agentRun?.traceId ?? null,
|
|
longLivedSession: true,
|
|
codexStdio: false,
|
|
delegatedToAgentRun: true,
|
|
writeCapable: true,
|
|
durable: true,
|
|
durableSession: true,
|
|
idleTimeoutMs: parsePositiveInteger(base.agentRun?.idleTimeoutMs, 600000),
|
|
secretMaterialStored: false,
|
|
valuesRedacted: true
|
|
});
|
|
}
|
|
|
|
export function agentRunThreadReused(base = {}, options = {}) {
|
|
if (options.status === "failed-requires-new-session") return false;
|
|
if (base.agentRun?.threadReused === true || base.agentRun?.persistentResume === true) return true;
|
|
return Boolean(agentRunEffectiveThreadId(base));
|
|
}
|
|
|
|
export function agentRunSessionReuseSummary(base, reused, options = {}) {
|
|
const runnerReused = Boolean(reused);
|
|
const threadReused = agentRunThreadReused(base, options);
|
|
const persistentResume = threadReused;
|
|
const sessionReused = runnerReused || persistentResume;
|
|
return {
|
|
sessionId: base.sessionId ?? base.agentRun?.sessionId ?? null,
|
|
conversationId: base.conversationId ?? base.agentRun?.conversationId ?? null,
|
|
threadId: agentRunEffectiveThreadId(base),
|
|
reused: sessionReused,
|
|
status: options.status ?? (runnerReused ? "reused" : persistentResume ? "thread-resumed" : "new"),
|
|
runnerReused,
|
|
threadReused,
|
|
persistentResume,
|
|
valuesRedacted: true
|
|
};
|
|
}
|
|
|
|
export function agentRunRunnerSummary(mapping = {}) {
|
|
return {
|
|
kind: AGENTRUN_RUNNER_KIND,
|
|
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,
|
|
dispatchIntentId: mapping.dispatchIntentId ?? null,
|
|
dispatchIntentState: mapping.dispatchIntentState ?? null,
|
|
durableDispatch: mapping.durableDispatch === true,
|
|
backendProfile: mapping.backendProfile ?? null,
|
|
provider: providerForBackendProfile(mapping.backendProfile ?? "deepseek"),
|
|
sessionMode: AGENTRUN_SESSION_MODE,
|
|
implementationType: AGENTRUN_IMPLEMENTATION_TYPE,
|
|
capabilityLevel: AGENTRUN_CAPABILITY_LEVEL,
|
|
codexStdio: false,
|
|
delegatedToAgentRun: true,
|
|
writeCapable: true,
|
|
durableSession: true,
|
|
longLivedSession: true,
|
|
sandbox: "danger-full-access",
|
|
valuesPrinted: false
|
|
};
|
|
}
|
|
|
|
export function hostForUrl(value) {
|
|
if (!value) return null;
|
|
try {
|
|
return new URL(value).hostname.toLowerCase();
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
export 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";
|
|
}
|
|
|
|
export 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;
|
|
}
|
|
|
|
export 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 });
|
|
}
|
|
|
|
export function firstNonEmpty(...values) {
|
|
for (const value of values) {
|
|
const text = String(value ?? "").trim();
|
|
if (text) return text;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
export function nowIso(now) {
|
|
return typeof now === "function" ? now() : new Date().toISOString();
|
|
}
|
|
|
|
export function timestampIsoOrNow(value = null) {
|
|
const parsed = Date.parse(String(value ?? ""));
|
|
return Number.isFinite(parsed) ? new Date(parsed).toISOString() : new Date().toISOString();
|
|
}
|
|
|
|
export 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>";
|
|
}
|
|
}
|