nolo-cli 0.1.31 → 0.1.32

package/server/handlers/agentRun/index.ts

@@ -1,2090 +0,0 @@
-// packages/server/handlers/agentRun/index.ts
-//
-// POST /api/agent/run
-//
-// 鉴权模式：
-//   1. Authorization: Bearer <jwt>   ← 登录用户（计费 + 审计）
-//
-// 持久化说明：
-//   ✅ 持久化  — Agent 配置（LevelDB）、Dialog 记录 + 全量消息轨迹（LevelDB）、Token 记录（LevelDB）
-//
-// Request:
-//   { agentKey, userInput, messages?, stream?, maxRounds?, background? }
-//   说明：maxRounds 仅为兼容旧客户端保留，服务端已不再按工具轮次截断。
-//
-// Response (非流式):
-//   { content, model, usage, dialogId }
-//
-// Response (background=true, 202):
-//   { dialogId, status: "pending" }
-//
-// Response (流式 SSE):
-//   data: {"type":"dialog","dialogId":"...","dialogKey":"...","status":"running"}
-//   data: {"type":"text","content":"..."}
-//   data: {"type":"tool_start","calls":["fetchWebpage"]}
-//   data: {"type":"tool_end"}
-//   data: {"type":"done","usage":{...},"dialogId":"..."}
-//   data: {"type":"error","message":"..."}
-
-import { createHash } from "node:crypto";
-import { ulid } from "ulid";
-import { userActor } from "../../../auth/actor";
-import { authenticateRequest } from "../../../auth/utils";
-import { WEB_AUTH_TOKEN_COOKIE } from "../../../auth/tokenCookie";
-import { getUser } from "../../../auth/server/getUser";
-import { checkBasicBalance } from "../../../auth/billing";
-import {
-    GPT_PRO_REQUIRED_BALANCE,
-    hasGptProTierAccess,
-    isGptProModel,
-} from "../../../auth/server/gptProAccess";
-import { chargeTokenUsageWithLedger } from "../../../auth/server/tokenUsageBilling";
-import { writeServerTokenRecord } from "../../../ai/token/serverTokenWriter";
-import {
-    createProviderCallCompletedEvent,
-    createProviderCallPendingEvent,
-    type ProviderCallEvent,
-} from "../../../ai/token/providerCall";
-import { writeProviderCallEvent } from "../../../ai/token/providerCallWriter";
-import {
-    createProviderBillableEvent,
-    type ProviderBillableEvent,
-} from "../../../ai/token/providerBillableEvent";
-import { writeProviderBillableEvent } from "../../../ai/token/providerBillableEventWriter";
-import { createRatingResult, type RatingResult } from "../../../ai/token/ratingResult";
-import { writeRatingResult } from "../../../ai/token/ratingResultWriter";
-import type { Usage } from "../../../ai/token/calculatePrice";
-import {
-    createBillingAnomaly,
-    type BillingAnomaly,
-    type BillingAnomalyKind,
-    type BillingAnomalySeverity,
-    type BillingAnomalyStage,
-} from "../../../ai/token/billingAnomaly";
-import { writeBillingAnomaly } from "../../../ai/token/billingAnomalyWriter";
-import { ensureServerDbOpen, getServerAuthorityStore } from "../../../database/server/db";
-import { runAgentLoop, buildSseStream } from "./loop";
-import { incActiveStream, decActiveStream } from "../../serverDrain";
-import { saveRunAsDialog, createPendingDialog, finalizeDialog, appendToExistingDialog } from "./saveDialog";
-import { fetchConvMsgs } from "../../api/methods";
-import { pushEvent } from "../eventBus";
-import { createUserKey } from "../../../database/keys";
-import { emitDialogStatusNotification } from "../notificationEmitter";
-import { summarizeMessagesForDebug } from "../../../chat/messages/messageContract";
-import {
-    buildUserPolicyContext,
-    resolveRuntimePolicy,
-} from "../../../ai/policy/runtimePolicy";
-import { resolveMemoryRuntime } from "../../../ai/memory/runtime";
-import type { AgentRunRequest, ChatMessage, LoopResult } from "./types";
-import { resolveExistingDialogRef } from "./dialogLookup";
-import { resolveContinueDialogContext } from "./continueDialogContext";
-import { prepareAgentRunExecutionContext } from "./runtimeExecutionContext";
-import { resolveEffectiveRuntimeToolPolicy } from "../../../agent-runtime";
-import { prepareForegroundStreamDialog } from "./foregroundStreamDialog";
-import { isBackgroundRunDialogError, prepareBackgroundRunDialog } from "./backgroundRunDialog";
-import { canonicalizeToolNames, prioritizeToolNames } from "../../../ai/tools/toolNameAliases";
-import { resolveServerReferenceRuntime } from "./referenceRuntime";
-import { buildDialogFallbackTitleFromUserInput } from "../../../chat/dialog/dialogTitle";
-import { buildRuntimeSystemMessageContext } from "./runtimeSystemMessages";
-import { resolveAutonomousRuntimeContext } from "./autonomousRuntime";
-import {
-    ensureLocalModelRuntimeIfNeeded,
-    isLocalRuntimeUnavailableError,
-} from "./localRuntimeBootstrap";
-import { isLocalEndpoint } from "./localRuntimeBootstrap";
-import {
-    BUILTIN_ECOMMERCE_AGENT_KEY,
-    BUILTIN_NOLO_AGENT_KEY,
-} from "./builtinAgents";
-import { resolveAgentRunAgentConfig } from "./agentLookup";
-import {
-    resolveMachineBindingPreflight,
-} from "./runtimeRouting";
-import {
-    prepareAgentRunRuntimeConfig,
-    resolveTaskRunPreflightContext,
-} from "./runtimePreparation";
-import {
-    parseAgentRunRequestBody,
-} from "./requestContext";
-import { buildAgentRunDebugContext } from "./debugContext";
-import { resolveAgentRunBilledUsage } from "./runBilling";
-import { buildConversationReferenceBlock } from "./conversationReference";
-import { completeSyncAgentRunDialog } from "./syncRunDialog";
-import {
-    AGENT_RUN_CORS_HEADERS as CORS,
-    agentRunError,
-    agentRunJson,
-    agentRunSse,
-} from "./response";
-import { machineRegistry } from "../machines/machineRegistry";
-import {
-    ConnectorOfflineError,
-    InvalidBoundMachineConfigError,
-    type MachineConnectorRunProgress,
-    resolveAgentRuntimeMachineId,
-    runViaMachineConnector,
-    shouldUseMachineConnector,
-} from "./machineConnector";
-import type { ConnectorAgentRunResult } from "../connector/connectorConnectionRegistry";
-import { projectDialogActivityToSubjectRows } from "./tableActivityProjection";
-import { buildWorkspaceLeaseFromConnectorResult } from "./workspaceLease";
-import { resolveCoreDataProxyTarget } from "../../../database/server/coreDataProxy";
-
-type AgentRunTokenWrite = Awaited<ReturnType<typeof writeServerTokenRecord>>;
-type AgentRunBillingInput = Parameters<typeof resolveAgentRunBilledUsage>[0] & {
-    agentKey: string;
-};
-
-const DEFAULT_BACKGROUND_RUN_TIMEOUT_MS = 10 * 60_000;
-const DEFAULT_RUNTIME_PROMPT_PAGE_THRESHOLD_BYTES = 32_000;
-
-const getAgentRunStore = () => getServerAuthorityStore();
-const serverDb = getAgentRunStore();
-
-function byteLength(value: string) {
-    return Buffer.byteLength(value, "utf8");
-}
-
-function shortHash(value: string) {
-    return createHash("sha256").update(value).digest("hex").slice(0, 12);
-}
-
-function resolveRuntimePromptPageThresholdBytes() {
-    const raw = Number(process.env.NOLO_RUNTIME_PROMPT_PAGE_THRESHOLD_BYTES);
-    return Number.isFinite(raw) && raw >= 1024
-        ? raw
-        : DEFAULT_RUNTIME_PROMPT_PAGE_THRESHOLD_BYTES;
-}
-
-function textToSlate(text: string) {
-    return text.split("\n").map((line) => ({
-        type: "paragraph",
-        children: [{ text: line }],
-    }));
-}
-
-async function createRuntimePromptPageIfLarge(args: {
-    agentConfig: any;
-    agentKey: string;
-    dialogId: string;
-    runtimeContext: unknown;
-    spaceId?: string;
-    userId: string;
-    userInputText: string;
-}) {
-    const content = [
-        "# Nolo Runtime Prompt Context",
-        "",
-        "This page is generated for a single agent run. It is shared cloud context for audit, handoff, and recovery.",
-        "Local repository changes, diffs, tests, and commits remain authoritative for local execution facts.",
-        "",
-        `dialogId: ${args.dialogId}`,
-        `agentKey: ${args.agentKey}`,
-        "",
-        "## Agent Prompt",
-        typeof args.agentConfig?.prompt === "string" ? args.agentConfig.prompt.trim() : "",
-        "",
-        "## Runtime Context",
-        JSON.stringify(args.runtimeContext ?? null, null, 2),
-        "",
-        "## User Task",
-        args.userInputText,
-    ].join("\n");
-    const contentBytes = byteLength(content);
-    if (contentBytes <= resolveRuntimePromptPageThresholdBytes()) return null;
-
-    const pageId = ulid();
-    const dbKey = `page-${args.userId}-${pageId}`;
-    const now = Date.now();
-    const promptHash = shortHash(content);
-    const title = `Runtime Prompt ${args.dialogId}`;
-    await serverDb.put(dbKey, {
-        id: pageId,
-        dbKey,
-        type: "page",
-        title,
-        spaceId: args.spaceId ?? null,
-        content,
-        slateData: textToSlate(content),
-        createdAt: now,
-        updatedAt: now,
-        created: new Date(now).toISOString(),
-        meta: {
-            kind: "nolo_runtime_prompt",
-            ephemeral: true,
-            dialogId: args.dialogId,
-            agentKey: args.agentKey,
-            promptHash,
-            contentBytes,
-        },
-    });
-    return { dbKey, title, promptHash, contentBytes };
-}
-
-async function withBackgroundRunTimeout<T>(
-    run: Promise<T>,
-    timeoutMs: number,
-): Promise<T> {
-    let timeout: ReturnType<typeof setTimeout> | undefined;
-    const timeoutPromise = new Promise<never>((_, reject) => {
-        timeout = setTimeout(() => {
-            reject(new Error(`background agent run timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-    });
-    try {
-        return await Promise.race([run, timeoutPromise]);
-    } finally {
-        if (timeout) clearTimeout(timeout);
-    }
-}
-
-async function chargeAgentRunTokenCost(
-    userId: string,
-    tokenWrite: AgentRunTokenWrite,
-    ledgerIdempotencyKey: string,
-) {
-    return chargeTokenUsageWithLedger({
-        store: serverDb,
-        userId,
-        tokenKey: tokenWrite.recordKey,
-        tokenRecord: tokenWrite.tokenRecord,
-        reason: "agent_run",
-        txId: `token-${tokenWrite.recordKey}`,
-        ledgerIdempotencyKey,
-        allowBuyerNegative: true,
-    });
-}
-
-function buildAggregateProviderCallLedgerIdempotencyKey(providerCallIds: string[]) {
-    const stableSource = [...new Set(providerCallIds)].sort().join("|");
-    const sourceHash = createHash("sha256").update(stableSource).digest("hex").slice(0, 16);
-    return `provider-call-group:sha256-${sourceHash}:charge:v1`;
-}
-
-async function writeProviderCallEventSafely(event: ProviderCallEvent) {
-    try {
-        await writeProviderCallEvent({ store: serverDb, event });
-    } catch (error) {
-        console.warn("[billing] Provider-call evidence write failed", {
-            providerCallId: event.providerCallId,
-            eventId: event.eventId,
-            status: event.status,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        await writeBillingAnomalySafely(createAgentRunBillingAnomaly({
-            kind: "provider_call_write_failed",
-            severity: "high",
-            stage: "provider_call",
-            userId: event.userId,
-            dialogId: event.dialogId,
-            agentId: event.agentId,
-            provider: event.provider,
-            model: event.model,
-            providerCallId: event.providerCallId,
-            message: "Provider-call evidence write failed",
-            evidence: {
-                eventId: event.eventId,
-                eventStatus: event.status,
-                error: error instanceof Error ? error.message : String(error),
-            },
-        }));
-    }
-}
-
-async function writeBillingAnomalySafely(anomaly: BillingAnomaly) {
-    try {
-        await writeBillingAnomaly({ store: serverDb, anomaly });
-    } catch (error) {
-        console.warn("[billing] Billing anomaly write failed", {
-            anomalyId: anomaly.id,
-            kind: anomaly.kind,
-            providerCallId: anomaly.providerCallId,
-            error: error instanceof Error ? error.message : String(error),
-        });
-    }
-}
-
-function createAgentRunBillingAnomaly(args: {
-    kind: BillingAnomalyKind;
-    severity: BillingAnomalySeverity;
-    stage: BillingAnomalyStage;
-    userId: string;
-    dialogId?: string;
-    agentId?: string;
-    provider: string;
-    model: string;
-    providerCallId?: string;
-    billableEventId?: string;
-    ratingResultId?: string;
-    riskPlatformCredits?: number;
-    message: string;
-    evidence: Record<string, unknown>;
-}) {
-    return createBillingAnomaly({
-        anomalyId: `anom_${ulid()}`,
-        kind: args.kind,
-        severity: args.severity,
-        stage: args.stage,
-        userId: args.userId,
-        dialogId: args.dialogId,
-        agentId: args.agentId,
-        provider: args.provider,
-        model: args.model,
-        providerCallId: args.providerCallId,
-        billableEventId: args.billableEventId,
-        ratingResultId: args.ratingResultId,
-        riskPlatformCredits: args.riskPlatformCredits,
-        message: args.message,
-        evidence: args.evidence,
-        createdAt: new Date().toISOString(),
-    });
-}
-
-async function writeProviderBillableEventSafely(event: ProviderBillableEvent) {
-    try {
-        await writeProviderBillableEvent({ store: serverDb, event });
-    } catch (error) {
-        console.warn("[billing] Provider billable event write failed", {
-            billableEventId: event.id,
-            sourceProviderCallIds: event.sourceProviderCallIds,
-            provider: event.provider,
-            model: event.model,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        await writeBillingAnomalySafely(createAgentRunBillingAnomaly({
-            kind: "billable_event_write_failed",
-            severity: "high",
-            stage: "billable_event",
-            userId: event.userId,
-            dialogId: event.dialogId,
-            agentId: event.agentId,
-            provider: event.provider,
-            model: event.model,
-            providerCallId: event.sourceProviderCallIds[0],
-            billableEventId: event.id,
-            message: "Provider billable event write failed",
-            evidence: {
-                sourceProviderCallIds: event.sourceProviderCallIds,
-                error: error instanceof Error ? error.message : String(error),
-            },
-        }));
-    }
-}
-
-async function writeRatingResultSafely(
-    rating: RatingResult,
-    context: {
-        userId: string;
-        dialogId?: string;
-        agentId?: string;
-        providerCallId?: string;
-    },
-) {
-    try {
-        await writeRatingResult({ store: serverDb, rating });
-    } catch (error) {
-        console.warn("[billing] Rating result write failed", {
-            ratingId: rating.id,
-            billableEventId: rating.billableEventId,
-            provider: rating.provider,
-            model: rating.model,
-            error: error instanceof Error ? error.message : String(error),
-        });
-        await writeBillingAnomalySafely(createAgentRunBillingAnomaly({
-            kind: "rating_failed",
-            severity: "high",
-            stage: "rating",
-            userId: context.userId,
-            dialogId: context.dialogId,
-            agentId: context.agentId,
-            provider: rating.provider,
-            model: rating.model,
-            providerCallId: context.providerCallId,
-            billableEventId: rating.billableEventId,
-            ratingResultId: rating.id,
-            riskPlatformCredits: rating.platformCredits,
-            message: "Rating result write failed",
-            evidence: {
-                error: error instanceof Error ? error.message : String(error),
-                snapshot: rating.snapshot,
-            },
-        }));
-    }
-}
-
-function numberOrZero(value: unknown) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-
-function normalizeAgentRunBillingUsage(rawUsage: Record<string, any>): Usage {
-    return {
-        input_tokens: numberOrZero(rawUsage.input_tokens ?? rawUsage.prompt_tokens),
-        output_tokens: numberOrZero(rawUsage.output_tokens ?? rawUsage.completion_tokens),
-        cache_creation_input_tokens: numberOrZero(rawUsage.cache_creation_input_tokens),
-        cache_read_input_tokens: numberOrZero(rawUsage.cache_read_input_tokens),
-        ...(typeof rawUsage.cost === "number" ? { cost: rawUsage.cost } : {}),
-        ...(typeof rawUsage.billing_service_tier === "string"
-            ? { billing_service_tier: rawUsage.billing_service_tier }
-            : {}),
-        ...(typeof rawUsage.image_generation_count === "number"
-            ? { image_generation_count: rawUsage.image_generation_count }
-            : {}),
-    };
-}
-
-function resolveEstimateReason(rawUsage: Record<string, any>) {
-    const reason = rawUsage.billing_estimate_reason ?? rawUsage.estimateReason ?? rawUsage.estimate_reason;
-    return typeof reason === "string" && reason.trim() ? reason.trim() : undefined;
-}
-
-async function projectBackgroundDialogActivity(args: {
-    dialogId: string;
-    dialogKey: string;
-    agentKey: string;
-    parentDialogId?: string | null;
-    runtimeContext?: AgentRunRequest["runtimeContext"];
-    status: "done" | "failed" | string;
-}) {
-    const subjectRefs = Array.isArray(args.runtimeContext?.subjectRefs)
-        ? args.runtimeContext.subjectRefs
-        : [];
-    if (subjectRefs.length === 0) return;
-
-    try {
-        await projectDialogActivityToSubjectRows({
-            db: serverDb,
-            subjectRefs,
-            activityRef: {
-                type: "dialog",
-                dialogId: args.dialogId,
-                dialogKey: args.dialogKey,
-                role:
-                    args.runtimeContext?.entrypoint === "agent-tool:startAgentDialog"
-                        ? "child-dialog"
-                        : "background-dialog",
-                agentKey: args.agentKey,
-                ...(args.parentDialogId ? { parentDialogId: args.parentDialogId } : {}),
-                status: args.status,
-                updatedAt: new Date().toISOString(),
-            },
-        });
-    } catch (error) {
-        console.error(`[background] dialog=${args.dialogId} activity projection failed:`, error);
-    }
-}
-
-function buildRunningRuntimeCheckpoint(args: {
-    dialogId: string;
-    userInputText: string;
-    updatedAt: number;
-    runtimeBinding?: unknown;
-}) {
-    return {
-        version: 1,
-        status: "running",
-        dialogId: args.dialogId,
-        updatedAt: args.updatedAt,
-        lastUserInput: args.userInputText,
-        lastAssistantText: null,
-        toolCallCount: 0,
-        traceSummary: { assistantCount: 0, toolCount: 0 },
-        lastToolNames: [],
-        ...(args.runtimeBinding ? { runtimeBinding: args.runtimeBinding } : {}),
-    };
-}
-
-function asRecord(value: unknown): Record<string, any> {
-    return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, any> : {};
-}
-
-function mergeUniqueStrings(...values: unknown[]) {
-    const merged: string[] = [];
-    for (const value of values) {
-        if (!Array.isArray(value)) continue;
-        for (const item of value) {
-            if (typeof item !== "string" || !item.trim()) continue;
-            const name = item.trim();
-            if (!merged.includes(name)) merged.push(name);
-        }
-    }
-    return merged.slice(-12);
-}
-
-function buildProgressRuntimeCheckpoint(args: {
-    existingDialog: any;
-    dialogId: string;
-    userInputText: string;
-    progress: MachineConnectorRunProgress;
-    updatedAt: number;
-}) {
-    const previous = asRecord(args.existingDialog?.runtimeCheckpoint);
-    const previousTrace = asRecord(previous.traceSummary);
-    const toolCallCount =
-        typeof args.progress.toolCallCount === "number"
-            ? args.progress.toolCallCount
-            : typeof previous.toolCallCount === "number"
-                ? previous.toolCallCount
-                : 0;
-    const toolResultCount =
-        typeof args.progress.toolResultCount === "number"
-            ? args.progress.toolResultCount
-            : typeof previousTrace.toolCount === "number"
-                ? previousTrace.toolCount
-                : 0;
-    const workspaceProgress = {
-        ...asRecord(previous.workspaceProgress),
-        ...(args.progress.workspaceRoot ? { workspaceRoot: args.progress.workspaceRoot } : {}),
-        ...(args.progress.workspaceKind ? { workspaceKind: args.progress.workspaceKind } : {}),
-    };
-    return {
-        ...previous,
-        version: 1,
-        status: "running",
-        dialogId: args.dialogId,
-        updatedAt: args.updatedAt,
-        lastUserInput: previous.lastUserInput ?? args.userInputText,
-        lastAssistantText: previous.lastAssistantText ?? null,
-        toolCallCount,
-        traceSummary: {
-            assistantCount: typeof previousTrace.assistantCount === "number" ? previousTrace.assistantCount : 0,
-            toolCount: toolResultCount,
-        },
-        lastToolNames: mergeUniqueStrings(previous.lastToolNames, args.progress.lastToolNames),
-        ...(Object.keys(workspaceProgress).length > 0 ? { workspaceProgress } : {}),
-        ...(args.existingDialog?.runtimeBinding ? { runtimeBinding: args.existingDialog.runtimeBinding } : {}),
-        lastProgressEventType: args.progress.eventType ?? previous.lastProgressEventType,
-        ...(args.progress.message ? { lastProgressMessage: args.progress.message } : {}),
-    };
-}
-
-function buildFailedRuntimeCheckpoint(args: {
-    existingDialog: any;
-    dialogId: string;
-    userInputText: string;
-    updatedAt: number;
-    errorMessage: string;
-}) {
-    const previous = asRecord(args.existingDialog?.runtimeCheckpoint);
-    const previousTrace = asRecord(previous.traceSummary);
-    return {
-        ...previous,
-        version: 1,
-        status: "failed",
-        dialogId: args.dialogId,
-        updatedAt: args.updatedAt,
-        lastUserInput: previous.lastUserInput ?? args.userInputText,
-        lastAssistantText: previous.lastAssistantText ?? null,
-        toolCallCount:
-            typeof previous.toolCallCount === "number"
-                ? previous.toolCallCount
-                : typeof args.existingDialog?.toolCallCount === "number"
-                    ? args.existingDialog.toolCallCount
-                    : 0,
-        traceSummary: {
-            assistantCount: typeof previousTrace.assistantCount === "number" ? previousTrace.assistantCount : 0,
-            toolCount: typeof previousTrace.toolCount === "number" ? previousTrace.toolCount : 0,
-        },
-        lastToolNames: mergeUniqueStrings(previous.lastToolNames),
-        ...(args.existingDialog?.runtimeBinding ? { runtimeBinding: args.existingDialog.runtimeBinding } : {}),
-        errorMessage: args.errorMessage,
-    };
-}
-
-async function writeAgentRunBillingIfNeeded(args: AgentRunBillingInput) {
-    try {
-        const { billingAgentConfig, billedUsage } = resolveAgentRunBilledUsage({
-            agentConfig: args.agentConfig,
-            result: args.result,
-            dialogId: args.dialogId,
-            mode: args.mode,
-            userId: args.userId,
-        });
-        if (!args.userId || !billedUsage) return;
-
-        const rawUsage = billedUsage as any;
-        const physicalProviderCallIds = Array.isArray(args.result.providerCallIds)
-            ? args.result.providerCallIds.filter((id): id is string => typeof id === "string" && id.trim().startsWith("call_"))
-            : [];
-        const hasAggregatePhysicalUsage = physicalProviderCallIds.length > 1;
-        const providerCallId = physicalProviderCallIds[physicalProviderCallIds.length - 1] ?? `call_${ulid()}`;
-        const providerCallStartedAt = new Date().toISOString();
-        const billingProvider =
-            rawUsage.billing_provider ??
-            billingAgentConfig.provider ??
-            args.result.provider ??
-            "unknown";
-        const billingModel =
-            rawUsage.billing_model ??
-            billingAgentConfig.model ??
-            args.result.model ??
-            "unknown";
-        const billingServiceTier =
-            rawUsage.billing_service_tier ??
-            billingAgentConfig.billingServiceTier ??
-            billingAgentConfig.serviceTier;
-
-        if (physicalProviderCallIds.length === 0) {
-            await writeProviderCallEventSafely(createProviderCallPendingEvent({
-                providerCallId,
-                eventId: `evt_${ulid()}`,
-                userId: args.userId,
-                dialogId: args.dialogId,
-                agentId: args.agentKey,
-                provider: billingProvider,
-                model: billingModel,
-                endpoint: "agentRun",
-                ...(billingServiceTier ? { serviceTier: String(billingServiceTier) } : {}),
-                startedAt: providerCallStartedAt,
-            }));
-        }
-
-        const tokenWrite = await writeServerTokenRecord({
-            userId: args.userId,
-            agentKey: args.agentKey,
-            agentConfig: billingAgentConfig,
-            runId: args.dialogId,
-            rawUsage: billedUsage as any,
-        });
-        const normalizedBillingUsage = normalizeAgentRunBillingUsage(rawUsage);
-        if (!hasAggregatePhysicalUsage) {
-            await writeProviderCallEventSafely(createProviderCallCompletedEvent({
-                providerCallId,
-                eventId: `evt_${ulid()}`,
-                userId: args.userId,
-                dialogId: args.dialogId,
-                agentId: args.agentKey,
-                provider: billingProvider,
-                model: billingModel,
-                endpoint: "agentRun",
-                ...(billingServiceTier ? { serviceTier: String(billingServiceTier) } : {}),
-                startedAt: providerCallStartedAt,
-                completedAt: new Date().toISOString(),
-                inputTokens: normalizedBillingUsage.input_tokens,
-                outputTokens: normalizedBillingUsage.output_tokens,
-                cacheCreationInputTokens: normalizedBillingUsage.cache_creation_input_tokens,
-                cacheReadInputTokens: normalizedBillingUsage.cache_read_input_tokens,
-                platformCredits: tokenWrite.cost,
-                pricingVersion: "model-registry-current",
-                billingStatus: tokenWrite.cost > 0 ? "pending_ledger" : "zero_policy",
-            }));
-        }
-        const billableEventId = `billable_${ulid()}`;
-        const ledgerIdempotencyKey = hasAggregatePhysicalUsage
-            ? buildAggregateProviderCallLedgerIdempotencyKey(physicalProviderCallIds)
-            : `provider-call:${providerCallId}:charge:v1`;
-        const billableEvent = createProviderBillableEvent({
-            eventId: billableEventId,
-            operationId: args.dialogId,
-            sourceProviderCallIds: physicalProviderCallIds.length > 0
-                ? [...physicalProviderCallIds]
-                : [providerCallId],
-            userId: args.userId,
-            dialogId: args.dialogId,
-            agentId: args.agentKey,
-            provider: billingProvider,
-            model: billingModel,
-            endpoint: "agentRun",
-            kind: "llm_tokens",
-            usage: {
-                inputTokens: normalizedBillingUsage.input_tokens,
-                outputTokens: normalizedBillingUsage.output_tokens,
-                cacheCreationInputTokens: normalizedBillingUsage.cache_creation_input_tokens,
-                cacheReadInputTokens: normalizedBillingUsage.cache_read_input_tokens,
-            },
-            estimated: rawUsage.billing_estimated === true,
-            estimateReason: resolveEstimateReason(rawUsage),
-            needsReconciliation: hasAggregatePhysicalUsage,
-            createdAt: new Date().toISOString(),
-        });
-        await writeProviderBillableEventSafely(billableEvent);
-        if (hasAggregatePhysicalUsage) {
-            await writeBillingAnomalySafely(createAgentRunBillingAnomaly({
-                kind: "aggregate_usage_unallocated",
-                severity: "medium",
-                stage: "usage",
-                userId: args.userId,
-                dialogId: args.dialogId,
-                agentId: args.agentKey,
-                provider: billingProvider,
-                model: billingModel,
-                providerCallId,
-                billableEventId,
-                riskPlatformCredits: tokenWrite.cost,
-                message: "Aggregate agent-run usage spans multiple physical provider calls and needs per-call allocation",
-                evidence: {
-                    sourceProviderCallIds: physicalProviderCallIds,
-                    ledgerIdempotencyKey,
-                    usage: normalizedBillingUsage,
-                    tokenKey: tokenWrite.recordKey,
-                },
-            }));
-        }
-        await writeRatingResultSafely(createRatingResult({
-            ratingId: `rating_${ulid()}`,
-            billableEventId,
-            provider: billingProvider,
-            model: billingModel,
-            ...(billingServiceTier ? { serviceTier: String(billingServiceTier) } : {}),
-            usage: normalizedBillingUsage,
-            createdAt: new Date().toISOString(),
-        }), {
-            userId: args.userId,
-            dialogId: args.dialogId,
-            agentId: args.agentKey,
-            providerCallId,
-        });
-        if (tokenWrite.cost > 0) {
-            const ledgerResult = await chargeAgentRunTokenCost(args.userId, tokenWrite, ledgerIdempotencyKey);
-            if (!ledgerResult.success) {
-                await writeBillingAnomalySafely(createAgentRunBillingAnomaly({
-                    kind: "ledger_failed",
-                    severity: "critical",
-                    stage: "ledger",
-                    userId: args.userId,
-                    dialogId: args.dialogId,
-                    agentId: args.agentKey,
-                    provider: billingProvider,
-                    model: billingModel,
-                    providerCallId,
-                    billableEventId,
-                    riskPlatformCredits: tokenWrite.cost,
-                    message: "Provider-call ledger charge failed",
-                    evidence: {
-                        ledgerStatus: ledgerResult.status,
-                        error: ledgerResult.error,
-                        tokenKey: tokenWrite.recordKey,
-                        txId: ledgerResult.txId,
-                        ledgerIdempotencyKey,
-                    },
-                }));
-            }
-        }
-    } catch (error) {
-        console.warn("[billing] Agent run billing write failed; preserving dialog result", {
-            dialogId: args.dialogId,
-            mode: args.mode,
-            userId: args.userId,
-            agentKey: args.agentKey,
-            error: error instanceof Error ? error.message : String(error),
-        });
-    }
-}
-
-let runAgentLoopImpl = runAgentLoop;
-let buildSseStreamImpl = buildSseStream;
-
-type StreamBillingContext = {
-    agentConfig: any;
-    agentKey: string;
-    dialogAgentKey?: string;
-    traceAgentKey?: string;
-    userId: string | null;
-    dialogId: string;
-    dialogKey: string;
-    userInputText: string;
-    startedAt: number;
-    isContinue: boolean;
-    spaceId?: string;
-    runtimeProfile?: any;
-    runtimeToolPolicySnapshot?: Record<string, unknown>;
-    workspaceLease?: Record<string, unknown>;
-    persistDialog?: boolean;
-};
-
-const normalizeAgentRunUserParts = (
-    userInput: AgentRunRequest["userInput"],
-): Array<Exclude<ChatMessage["content"], string | null>[number]> => {
-    if (!Array.isArray(userInput)) return [];
-    return userInput.filter((part): part is Exclude<ChatMessage["content"], string | null>[number] => {
-        if (!part || typeof part !== "object") return false;
-        if (part.type === "text") {
-            return typeof part.text === "string" && !!part.text.trim();
-        }
-        return (
-            part.type === "image_url" &&
-            typeof part.image_url?.url === "string" &&
-            !!part.image_url.url.trim()
-        );
-    });
-};
-
-const extractAgentRunUserText = (userInput: AgentRunRequest["userInput"]): string => {
-    if (typeof userInput === "string") {
-        return userInput.trim();
-    }
-    return normalizeAgentRunUserParts(userInput)
-        .filter((part): part is { type: "text"; text: string } => part.type === "text")
-        .map((part) => part.text)
-        .join("\n")
-        .trim();
-};
-
-const buildAgentRunUserMessageContent = (
-    userInput: AgentRunRequest["userInput"],
-    turnInstruction?: string | null,
-): ChatMessage["content"] => {
-    const normalizedTurnInstruction =
-        typeof turnInstruction === "string" && turnInstruction.trim()
-            ? turnInstruction.trim()
-            : "";
-    const normalizedParts = normalizeAgentRunUserParts(userInput);
-    if (normalizedParts.length > 0) {
-        // Inject URL hints so the model uses original HTTPS URLs in tool calls
-        // rather than reconstructing/hallucinating base64 from its vision input.
-        const imageUrlParts = normalizedParts.filter(
-            (p): p is { type: "image_url"; image_url: { url: string } } =>
-                p.type === "image_url"
-        );
-        const urlHintText =
-            imageUrlParts.length > 0
-                ? imageUrlParts
-                      .map(
-                          (p, i) =>
-                              `[附件图片${i + 1} URL（工具调用时请直接将此 URL 填入 images[${i}].data，不要重编码）: ${p.image_url.url}]`
-                      )
-                      .join("\n")
-                : null;
-
-        return [
-            ...(normalizedTurnInstruction
-                ? [{ type: "text" as const, text: `${normalizedTurnInstruction}\n\n--- User task ---` }]
-                : []),
-            ...(urlHintText
-                ? [{ type: "text" as const, text: urlHintText }]
-                : []),
-            // Only include text parts in the coordinator LLM message.
-            // image_url parts are intentionally excluded: high-capability models like
-            // gpt-5.4 charge ~857k tokens per image even at detail:low, exceeding the
-            // 400k TPM limit. The URL hint text above already provides the URL for tool
-            // calls; the actual image analysis is done by gpt-image-2, not the coordinator.
-            ...normalizedParts.filter((p) => p.type === "text"),
-        ];
-    }
-
-    const userText = extractAgentRunUserText(userInput);
-    if (!normalizedTurnInstruction) {
-        return userText;
-    }
-    if (!userText) {
-        return normalizedTurnInstruction;
-    }
-    return [normalizedTurnInstruction, "--- User task ---", userText].join("\n\n");
-};
-
-function resolveDirectSpecialistAgentKey(args: {
-    agentKey: string;
-    userInputText: string;
-    stream: boolean;
-    background: boolean;
-    continueDialogId?: string;
-}): string | null {
-    if (args.agentKey !== BUILTIN_NOLO_AGENT_KEY) return null;
-    if (!args.stream || args.background || args.continueDialogId) return null;
-
-    const text = args.userInputText.trim();
-    if (!text) return null;
-    const ecommerceUrlMatches =
-        text.match(/https?:\/\/\S*(?:item\.jd\.com|item\.m\.jd\.com|jd\.com|taobao\.com|tmall\.com)\S*/gi) ?? [];
-    if (ecommerceUrlMatches.length > 1) return null;
-
-    const hasEcommerceTarget =
-        /(?:item\.jd\.com|item\.m\.jd\.com|jd\.com|taobao\.com|tmall\.com)/i.test(text) ||
-        /(?:京东|淘宝|天猫|SKU|商品链接|商品ID|itemId)/i.test(text);
-    const asksForProductData =
-        /(?:参数|型号|价格|规格|尺寸|重量|质保|库存|店铺|sku|商品详情|真实)/i.test(text);
-    if (!hasEcommerceTarget || !asksForProductData) return null;
-
-    const asksForParentFollowup =
-        /(?:对比表|表格|建表|记录|写入|保存|分析|总结|推荐|方案|继续|然后|再帮我|顺便|做成|生成|整理成)/i.test(text);
-    if (asksForParentFollowup) return null;
-    return BUILTIN_ECOMMERCE_AGENT_KEY;
-}
-
-export function __setAgentRunLoopForTest(overrides: {
-    runAgentLoop?: typeof runAgentLoop;
-    buildSseStream?: typeof buildSseStream;
-}) {
-    if (overrides.runAgentLoop) {
-        runAgentLoopImpl = overrides.runAgentLoop;
-    }
-    if (overrides.buildSseStream) {
-        buildSseStreamImpl = overrides.buildSseStream;
-    }
-}
-
-function buildMachineConnectorSseStream(result: ConnectorAgentRunResult): ReadableStream<Uint8Array> {
-    return new ReadableStream({
-        start(controller) {
-            const encoder = new TextEncoder();
-            const send = (payload: unknown) => {
-                controller.enqueue(encoder.encode(`data: ${JSON.stringify(payload)}\n\n`));
-            };
-            if (result.content) {
-                send({ type: "text", content: result.content });
-            }
-            send({ type: "done", usage: result.usage, artifacts: result.artifacts });
-            controller.close();
-        },
-    });
-}
-
-const serializeSseEvent = (payload: unknown) =>
-    `data: ${JSON.stringify(payload)}\n\n`;
-
-const parseSseEventPayload = (eventText: string): any | null => {
-    const data = eventText
-        .split(/\r?\n/)
-        .filter((line) => line.startsWith("data:"))
-        .map((line) => line.slice(5).trim())
-        .join("\n")
-        .trim();
-    if (!data || data === "[DONE]") return null;
-    try {
-        return JSON.parse(data);
-    } catch {
-        return null;
-    }
-};
-
-async function persistAndBillForegroundStreamRun(
-    context: StreamBillingContext,
-    result: LoopResult
-) {
-    const durationMs = Math.max(0, Date.now() - context.startedAt);
-    if (context.persistDialog !== false) {
-        if (context.isContinue) {
-            await appendToExistingDialog({
-                dialogId: context.dialogId,
-                dialogKey: context.dialogKey,
-                agentKey: context.dialogAgentKey ?? context.agentKey,
-                traceAgentKey: context.traceAgentKey,
-                userId: context.userId,
-                userInput: context.userInputText,
-                result,
-                durationMs,
-                spaceId: context.spaceId,
-                runtimeProfile: context.runtimeProfile,
-                runtimeToolPolicySnapshot: context.runtimeToolPolicySnapshot,
-                workspaceLease: context.workspaceLease,
-            });
-        } else {
-            await finalizeDialog({
-                dialogId: context.dialogId,
-                dialogKey: context.dialogKey,
-                agentKey: context.dialogAgentKey ?? context.agentKey,
-                traceAgentKey: context.traceAgentKey,
-                result,
-                startedAt: context.startedAt,
-                status: "done",
-                userInput: context.userInputText,
-                userId: context.userId,
-                spaceId: context.spaceId,
-                runtimeToolPolicySnapshot: context.runtimeToolPolicySnapshot,
-                workspaceLease: context.workspaceLease,
-            });
-        }
-    }
-
-    await writeAgentRunBillingIfNeeded({
-        agentConfig: context.agentConfig,
-        agentKey: context.agentKey,
-        result,
-        dialogId: context.dialogId,
-        mode: "sync",
-        userId: context.userId,
-    });
-}
-
-function buildBillableForegroundSseStream(
-    source: ReadableStream,
-    context: StreamBillingContext
-): ReadableStream<Uint8Array> {
-    const encoder = new TextEncoder();
-    const decoder = new TextDecoder();
-
-    return new ReadableStream({
-        async start(controller) {
-            const reader = source.getReader();
-            let buffer = "";
-            let assistantText = "";
-            let lastUsage: Record<string, any> | undefined;
-            let lastProvider = context.agentConfig.provider ?? undefined;
-            let lastModel = context.agentConfig.model ?? "unknown";
-            let lastInputPrice = context.agentConfig.inputPrice;
-            let lastOutputPrice = context.agentConfig.outputPrice;
-            let lastArtifacts: unknown;
-            let lastProviderCallIds: string[] | undefined;
-            let toolCallCount = 0;
-            let sawDone = false;
-            const trace: ChatMessage[] = [];
-
-            controller.enqueue(
-                encoder.encode(serializeSseEvent({
-                    type: "dialog",
-                    dialogId: context.dialogId,
-                    dialogKey: context.dialogKey,
-                    status: "running",
-                }))
-            );
-
-            const enqueueEvent = (eventText: string) => {
-                const payload = parseSseEventPayload(eventText);
-                if (!payload || typeof payload !== "object") {
-                    controller.enqueue(encoder.encode(eventText));
-                    return;
-                }
-
-                if (payload.type === "text" && typeof payload.content === "string") {
-                    assistantText += payload.content;
-                }
-                if (payload.type === "assistant_tool_calls") {
-                    const toolCalls = Array.isArray(payload.tool_calls)
-                        ? payload.tool_calls
-                        : [];
-                    toolCallCount += toolCalls.length;
-                    assistantText = "";
-                    trace.push({
-                        role: "assistant",
-                        content: payload.content ?? null,
-                        ...(toolCalls.length ? { tool_calls: toolCalls } : {}),
-                    } as ChatMessage);
-                }
-                if (payload.type === "tool_result") {
-                    trace.push({
-                        role: "tool",
-                        content: payload.content ?? null,
-                        ...(payload.toolCallId ? { tool_call_id: payload.toolCallId } : {}),
-                    } as ChatMessage);
-                }
-                if (payload.type === "done") {
-                    sawDone = true;
-                    lastUsage = payload.usage ?? lastUsage;
-                    lastProvider = payload.provider ?? lastProvider;
-                    lastModel = payload.model ?? lastModel;
-                    lastInputPrice =
-                        typeof payload.inputPrice === "number"
-                            ? payload.inputPrice
-                            : lastInputPrice;
-                    lastOutputPrice =
-                        typeof payload.outputPrice === "number"
-                            ? payload.outputPrice
-                            : lastOutputPrice;
-                    lastArtifacts = payload.artifacts ?? lastArtifacts;
-                    if (Array.isArray(payload.providerCallIds)) {
-                        lastProviderCallIds = payload.providerCallIds.filter(
-                            (id: unknown): id is string => typeof id === "string" && id.trim()
-                        );
-                    }
-                    if (assistantText) {
-                        trace.push({ role: "assistant", content: assistantText });
-                    }
-                    controller.enqueue(
-                        encoder.encode(serializeSseEvent({
-                            ...payload,
-                            dialogId: context.dialogId,
-                        }))
-                    );
-                    return;
-                }
-
-                controller.enqueue(encoder.encode(eventText));
-            };
-
-            try {
-                for (;;) {
-                    const { done, value } = await reader.read();
-                    if (done) break;
-                    buffer += decoder.decode(value, { stream: true });
-                    const events = buffer.split(/\n\n/);
-                    buffer = events.pop() ?? "";
-                    for (const eventText of events) {
-                        if (!eventText) continue;
-                        enqueueEvent(`${eventText}\n\n`);
-                    }
-                }
-                if (buffer.trim()) {
-                    enqueueEvent(buffer.endsWith("\n\n") ? buffer : `${buffer}\n\n`);
-                }
-
-                if (sawDone) {
-                    await persistAndBillForegroundStreamRun(context, {
-                        content: assistantText,
-                        model: lastModel,
-                        provider: lastProvider,
-                        inputPrice: lastInputPrice,
-                        outputPrice: lastOutputPrice,
-                        usage: lastUsage,
-                        ...(lastProviderCallIds?.length ? { providerCallIds: lastProviderCallIds } : {}),
-                        ...(lastArtifacts ? { artifacts: lastArtifacts } : {}),
-                        trace,
-                        runtimeToolNames: [],
-                        toolCallCount,
-                    });
-                }
-            } catch (error) {
-                console.error("[agentRun] foreground stream billing failed", {
-                    dialogId: context.dialogId,
-                    error,
-                });
-            } finally {
-                controller.close();
-            }
-        },
-    });
-}
-
-async function proxyAgentRunToRemote(options: {
-    targetBase: string;
-    body: AgentRunRequest;
-    authToken: string;
-    stream: boolean;
-}): Promise<Response> {
-    const { targetBase, body, authToken, stream } = options;
-
-    let remoteResponse: Response;
-    try {
-        remoteResponse = await fetch(`${targetBase}/api/agent/run`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
-            },
-            body: JSON.stringify(body),
-        });
-    } catch (error: any) {
-        return agentRunError(
-            `Runtime server unavailable: ${targetBase} (${error?.message ?? "request failed"})`,
-            502,
-        );
-    }
-
-    if (stream) {
-        return new Response(remoteResponse.body, {
-            status: remoteResponse.status,
-            headers: {
-                ...CORS,
-                "Content-Type":
-                    remoteResponse.headers.get("Content-Type") ?? "text/event-stream",
-                "Cache-Control":
-                    remoteResponse.headers.get("Cache-Control") ?? "no-cache",
-                Connection: remoteResponse.headers.get("Connection") ?? "keep-alive",
-            },
-        });
-    }
-
-    const responseText = await remoteResponse.text();
-    let responseBodyText = responseText;
-    const contentType =
-        remoteResponse.headers.get("Content-Type") ?? "application/json";
-    if (options.body.background && contentType.includes("application/json")) {
-        try {
-            const parsed = JSON.parse(responseText);
-            if (parsed && typeof parsed === "object" && !("serverBase" in parsed)) {
-                responseBodyText = JSON.stringify({
-                    ...parsed,
-                    serverBase: targetBase,
-                });
-            }
-        } catch {
-            // fall back to original body
-        }
-    }
-    return new Response(responseBodyText, {
-        status: remoteResponse.status,
-        headers: {
-            ...CORS,
-            "Content-Type": contentType,
-        },
-    });
-}
-
-const LOCAL_SMOKE_AGENT_KEYS = new Set([
-    "agent-0e95801d90-01KJZ79FDW84G5VG2050KBJM70",
-]);
-function shouldBypassBalanceForLocalSmokeAgent(
-    agentKey: string,
-    agentConfig: any,
-    serverBase: string,
-): boolean {
-    const isCustomSource =
-        agentConfig?.apiSource === "custom" || !!agentConfig?.customProviderUrl;
-    if (LOCAL_SMOKE_AGENT_KEYS.has(agentKey)) return isCustomSource;
-    return isCustomSource &&
-        isLocalEndpoint(serverBase) &&
-        isLocalEndpoint(agentConfig?.customProviderUrl ?? "");
-}
-
-function resolveConnectorFailureResponse(error: any, agentConfig: any): Response | null {
-    if (error instanceof InvalidBoundMachineConfigError) {
-        return agentRunJson({
-            error: "Invalid runtime binding",
-            reason: error.reason,
-            message: error.message,
-        }, error.status);
-    }
-    if (error instanceof ConnectorOfflineError) {
-        return agentRunJson({
-            error: "Connector offline",
-            reason: "connector_offline",
-            message: error.message,
-        }, 409);
-    }
-    if (shouldUseMachineConnector(agentConfig)) {
-        return agentRunJson({
-            error: "Connector execution failed",
-            reason: "connector_execution_failed",
-            message: error.message ?? "Connector execution failed",
-        }, 502);
-    }
-    return null;
-}
-
-// ── 鉴权：JWT Bearer Token ────────────────────────────────────────────────────
-
-interface AuthInfo { authToken: string; userId: string; callerType: "jwt"; }
-
-function extractAuthToken(req: Request): string {
-    const authHeaderToken = req.headers.get("authorization")?.split(" ")[1]?.trim();
-    if (authHeaderToken) return authHeaderToken;
-
-    const cookieHeader = req.headers.get("cookie") ?? req.headers.get("Cookie") ?? "";
-    const cookieToken = cookieHeader
-        .split(";")
-        .map((part) => part.trim())
-        .find((part) => part.startsWith(`${WEB_AUTH_TOKEN_COOKIE}=`))
-        ?.slice(`${WEB_AUTH_TOKEN_COOKIE}=`.length);
-    return cookieToken ? decodeURIComponent(cookieToken) : "";
-}
-
-async function authorize(req: Request): Promise<AuthInfo | Response> {
-    // 标准 JWT Bearer Token（登录用户，计费 + 审计）
-    const result = await authenticateRequest(req);
-    if (result instanceof Response) return result; // 401
-    return {
-        authToken: result.authToken ?? extractAuthToken(req),
-        userId: result.userId,
-        callerType: "jwt",
-    };
-}
-
-// ── Handler ────────────────────────────────────────────────────────────────────
-
-export async function handleAgentRun(req: Request): Promise<Response> {
-    if (req.method === "OPTIONS") {
-        return new Response(null, { status: 204, headers: CORS });
-    }
-
-    const authResult = await authorize(req);
-    if (authResult instanceof Response) return authResult;
-    const { authToken, userId, callerType } = authResult;
-
-    const serverBase = (() => {
-        const u = new URL(req.url);
-        return `${u.protocol}//${u.host}`;
-    })();
-
-    let body: AgentRunRequest;
-    try {
-        body = await req.json() as AgentRunRequest;
-    } catch {
-        return agentRunError("Invalid JSON body", 400);
-    }
-
-    const parsedRequest = parseAgentRunRequestBody(body);
-    if (!parsedRequest.ok) {
-        return agentRunError(parsedRequest.error.message, parsedRequest.error.status);
-    }
-    const {
-        requestedAgentKey,
-        userInput,
-        requestHistory,
-        stream,
-        runtimeContext,
-        effectiveMaxRounds,
-        background,
-        spaceId,
-        category,
-        inheritedFromDialogKey,
-        parentDialogId,
-        runtimeProfile,
-        runtimeOptions,
-        debugContextLayers,
-        continueDialogId,
-        effectiveAgentRunTimeoutMs,
-    } = parsedRequest.value;
-    const { persistDialog = true, clientDialogId } = body;
-    const shouldPersistDialog = persistDialog !== false;
-    const normalizedClientDialogId =
-        typeof clientDialogId === "string" && clientDialogId.trim()
-            ? clientDialogId.trim()
-            : null;
-    if (!shouldPersistDialog && (!stream || !normalizedClientDialogId)) {
-        return agentRunError("persistDialog=false requires stream=true and clientDialogId", 400);
-    }
-    const userInputText = extractAgentRunUserText(userInput);
-    const directSpecialistAgentKey = resolveDirectSpecialistAgentKey({
-        agentKey: requestedAgentKey,
-        userInputText,
-        stream,
-        background,
-        continueDialogId,
-    });
-    const agentKey = directSpecialistAgentKey ?? requestedAgentKey;
-    const dialogAgentKey = requestedAgentKey;
-    const traceAgentKey = directSpecialistAgentKey ?? undefined;
-    const coreProxyTarget = resolveCoreDataProxyTarget({
-        dbKey: agentKey,
-        requestUrl: req.url,
-        coreBaseUrl: process.env.NOLO_SERVER_CORE_BASE_URL,
-    });
-    if (coreProxyTarget) {
-        return proxyAgentRunToRemote({
-            targetBase: coreProxyTarget,
-            body,
-            authToken,
-            stream,
-        });
-    }
-
-    // 读取 Agent 配置（已持久化在 LevelDB）
-    try { await ensureServerDbOpen(); } catch (e: any) { return agentRunError(e.message, 500); }
-    const agentLookup = await resolveAgentRunAgentConfig({
-        agentKey,
-        getAgentRecord: (key) => getAgentRunStore().get(key),
-    });
-    if (!agentLookup.ok) {
-        return agentRunError(agentLookup.message, agentLookup.status);
-    }
-    const storedAgentConfig = {
-        ...agentLookup.agentConfig,
-        dbKey: agentLookup.agentConfig.dbKey ?? agentKey,
-    };
-
-    const machineBinding = resolveMachineBindingPreflight({
-        agentConfig: storedAgentConfig,
-        userId,
-        listMachines: (ownerUserId) => machineRegistry.listMachines(ownerUserId),
-    });
-    if (!machineBinding.ok) {
-        return agentRunJson(machineBinding.body, machineBinding.status);
-    }
-
-    const taskRunPreflight = await resolveTaskRunPreflightContext({
-        runtimeContext,
-        authToken,
-    });
-    const taskRunPreflightPrompt = taskRunPreflight.prompt;
-    const currentUserActor = userActor(userId);
-    const fetchAuthorizedDialogMessages = (args: { dialogId: string; limit: number }) =>
-        fetchConvMsgs(args, {
-            userId,
-            actor: currentUserActor,
-        });
-    if (continueDialogId && (body.inheritedFromDialogKey || body.parentDialogId)) {
-        console.info("[agentRun] continue-history-overrides-inherited-reference", {
-            continueDialogId,
-            inheritedFromDialogKey: body.inheritedFromDialogKey ?? null,
-            parentDialogId: body.parentDialogId ?? null,
-        });
-    }
-    const preparedRuntimeConfig = await prepareAgentRunRuntimeConfig({
-        agentConfig: storedAgentConfig,
-        runtimeContext,
-        taskRunPreflightPrompt,
-        runtimeOptions,
-        parentDialogId,
-        inheritedFromDialogKey,
-        includeConversationReference: !continueDialogId,
-        resolveReferenceRuntime: (references) =>
-            resolveServerReferenceRuntime({
-                references,
-                loadPage: async (identifier: string) => {
-                    try {
-                        return await getAgentRunStore().get(identifier);
-                    } catch {
-                        return null;
-                    }
-                },
-            }),
-        buildConversationReferenceBlock: (args) =>
-            buildConversationReferenceBlock({
-                ...args,
-                getDialogRecord: async (dialogKey) => {
-                    try {
-                        return await getAgentRunStore().get(dialogKey);
-                    } catch {
-                        return null;
-                    }
-                },
-                fetchConversationMessages: fetchAuthorizedDialogMessages,
-            }),
-    });
-    const {
-        runtimeEntrypointBlock,
-        taskRunPreflightBlock,
-        referenceRuntimeBlock,
-        conversationReferenceBlock,
-        editingContextBlock,
-        ...preparedAgentConfig
-    } = preparedRuntimeConfig;
-    const runtimePreparedAgentConfig = preparedAgentConfig;
-    const runtimeToolPolicySnapshot = resolveEffectiveRuntimeToolPolicy({
-        agentConfig: runtimePreparedAgentConfig,
-    });
-
-    // 余额检查（仅 JWT 登录用户）
-    const bypassBalanceCheck = shouldBypassBalanceForLocalSmokeAgent(
-        agentKey,
-        runtimePreparedAgentConfig,
-        serverBase,
-    );
-    if (userId && !bypassBalanceCheck) {
-        const user = await getUser(userId);
-        if (isGptProModel(runtimePreparedAgentConfig.provider, runtimePreparedAgentConfig.model)) {
-            const gptProAccess = hasGptProTierAccess({ userData: user });
-            if (!gptProAccess.allowed) {
-                return agentRunJson({
-                    error: "GPT Pro requires 199 current balance",
-                    reason: "gpt_pro_tier_required",
-                    requiredBalance: GPT_PRO_REQUIRED_BALANCE,
-                    message: `GPT Pro 系列需要当前余额大于等于 ${GPT_PRO_REQUIRED_BALANCE}。`,
-                }, 402);
-            }
-        }
-        const balanceCheck = checkBasicBalance(user?.balance ?? 0);
-        if (!balanceCheck.allowed) {
-            return agentRunJson({ error: balanceCheck.error }, 402);
-        }
-    }
-
-    const {
-        contextHistory,
-        existingDialogRecord,
-        existingDialogKey,
-        continueDialogUserId,
-    } = await resolveContinueDialogContext({
-        continueDialogId,
-        requestHistoryFallback: requestHistory,
-        userId,
-        resolveExistingDialogRef,
-        fetchConvMsgs: fetchAuthorizedDialogMessages,
-        summarizeMessagesForDebug,
-    });
-
-    const executionContext = await prepareAgentRunExecutionContext({
-        agentConfig: runtimePreparedAgentConfig,
-        agentKey,
-        userId,
-        userInput,
-        userInputText,
-        contextHistory,
-        spaceId,
-        runtimeProfile,
-        existingDialogRecord,
-        runtimeEntrypointBlock,
-        taskRunPreflightBlock,
-        referenceRuntimeBlock,
-        conversationReferenceBlock,
-        editingContextBlock,
-        loadUserSettings: (settingsUserId) =>
-            getAgentRunStore().get(createUserKey.settings(settingsUserId)),
-        resolveRuntimePolicy,
-        buildUserPolicyContext,
-        resolveMemoryRuntime,
-        resolveAutonomousRuntimeContext,
-        buildRuntimeSystemMessageContext,
-        buildAgentRunUserMessageContent,
-        canonicalizeToolNames,
-        prioritizeToolNames,
-    });
-    const executionAgentConfig = executionContext.agentConfig;
-    const executionRuntimePolicy = executionContext.runtimePolicy;
-    const effectiveRuntimeProfile = executionContext.effectiveRuntimeProfile;
-    const executionMemoryRuntime = executionContext.memoryRuntime;
-    const runtimeSystemMessageContext = executionContext.runtimeSystemMessageContext;
-    const executionMessages = executionContext.messages;
-    const executionMachineId = resolveAgentRuntimeMachineId(executionAgentConfig);
-    const buildExecutionWorkspaceLease = (
-        connectorResult: ConnectorAgentRunResult | null | undefined,
-    ) =>
-        buildWorkspaceLeaseFromConnectorResult({
-            result: connectorResult,
-            agentKey,
-            machineId: executionMachineId,
-            runtimeToolPolicySnapshot,
-        });
-    const runExecutionConnector = async (args: {
-        userId: string;
-        requestTimeoutMs?: number;
-        runtimePromptPage?: Record<string, unknown> | null;
-        onProgress?: (progress: MachineConnectorRunProgress) => Promise<void>;
-    }) =>
-        runViaMachineConnector({
-            agentConfig: executionAgentConfig,
-            agentKey,
-            authToken,
-            category,
-            continueDialogId: continueDialogId ?? undefined,
-            messages: executionMessages,
-            runtimeContext,
-            spaceId,
-            userId: args.userId,
-            userInput: userInputText,
-            requestTimeoutMs: args.requestTimeoutMs,
-            runtimeToolPolicySnapshot,
-            ...(args.runtimePromptPage ? { runtimePromptPage: args.runtimePromptPage } : {}),
-            ...(args.onProgress ? { onProgress: args.onProgress } : {}),
-        });
-    const runExecutionLoop = (args: {
-        userId: string;
-        dialogId?: string;
-        spaceId?: string | null;
-    }) =>
-        runAgentLoopImpl(
-            executionAgentConfig,
-            executionMessages,
-            effectiveMaxRounds,
-            serverBase,
-            authToken,
-            executionRuntimePolicy,
-            args.userId,
-            args.dialogId,
-            args.spaceId,
-            userInputText,
-            runtimeContext,
-            serverDb,
-        );
-    const runExecutionResult = async (args: {
-        userId: string;
-        dialogId?: string;
-        spaceId?: string | null;
-        requestTimeoutMs?: number;
-        runtimePromptPage?: Record<string, unknown> | null;
-        onProgress?: (progress: MachineConnectorRunProgress) => Promise<void>;
-    }) => {
-        const connectorResult = await runExecutionConnector({
-            userId: args.userId,
-            requestTimeoutMs: args.requestTimeoutMs,
-            runtimePromptPage: args.runtimePromptPage,
-            onProgress: args.onProgress,
-        });
-        return {
-            connectorResult,
-            workspaceLease: buildExecutionWorkspaceLease(connectorResult),
-            result: (connectorResult ?? await runExecutionLoop({
-                userId: args.userId,
-                dialogId: args.dialogId,
-                spaceId: args.spaceId,
-            })) as LoopResult,
-        };
-    };
-    const buildExecutionSourceStream = (args: {
-        userId: string;
-        dialogId: string;
-        spaceId?: string | null;
-    }) =>
-        buildSseStreamImpl(
-            executionAgentConfig,
-            executionMessages,
-            effectiveMaxRounds,
-            serverBase,
-            authToken,
-            executionRuntimePolicy,
-            args.userId,
-            args.dialogId,
-            args.spaceId,
-            userInputText,
-            runtimeContext,
-            serverDb,
-        );
-    const dialogLifecyclePersistenceContext = {
-        userId,
-        callerType,
-        userInput: userInputText,
-        spaceId,
-        category,
-        inheritedFromDialogKey,
-        parentDialogId,
-        runtimeProfile: effectiveRuntimeProfile,
-        runtimeContext,
-        runtimeToolPolicySnapshot,
-    };
-    const buildPendingDialogInput = (pendingAgentKey: string) => ({
-        agentKey: pendingAgentKey,
-        ...dialogLifecyclePersistenceContext,
-    });
-
-    try {
-        await ensureLocalModelRuntimeIfNeeded(executionAgentConfig);
-    } catch (e: any) {
-        if (isLocalRuntimeUnavailableError(e)) {
-            return agentRunJson({
-                error: "Local provider unavailable",
-                reason: e.reason,
-                message: e.message,
-            }, e.status);
-        }
-        return agentRunError(e.message ?? "Local provider runtime check failed", 500);
-    }
-
-    const prepareCurrentForegroundStreamDialog = async (): Promise<
-        Awaited<ReturnType<typeof prepareForegroundStreamDialog>> & { persistDialog: boolean }
-    > => {
-        if (!shouldPersistDialog) {
-            return {
-                dialogId: normalizedClientDialogId!,
-                dialogKey: "",
-                effectiveUserId: userId,
-                effectiveSpaceId: spaceId,
-                persistDialog: false,
-            };
-        }
-        const prepared = await prepareForegroundStreamDialog({
-            continueDialogId,
-            existingDialogKey,
-            existingDialogRecord,
-            continueDialogUserId,
-            fallbackSpaceId: spaceId,
-            createPendingDialog,
-            pendingDialogInput: buildPendingDialogInput(dialogAgentKey),
-        });
-        return {
-            ...prepared,
-            persistDialog: true,
-        };
-    };
-    const buildForegroundStreamLifecycleContext = (args: {
-        streamDialog: Awaited<ReturnType<typeof prepareCurrentForegroundStreamDialog>>;
-        startedAt: number;
-        workspaceLease?: Record<string, unknown>;
-    }) => ({
-        agentConfig: executionAgentConfig,
-        agentKey,
-        dialogAgentKey,
-        traceAgentKey,
-        userId: args.streamDialog.effectiveUserId,
-        dialogId: args.streamDialog.dialogId,
-        dialogKey: args.streamDialog.dialogKey,
-        userInputText,
-        startedAt: args.startedAt,
-        isContinue: Boolean(continueDialogId),
-        spaceId: args.streamDialog.effectiveSpaceId,
-        runtimeProfile: effectiveRuntimeProfile,
-        runtimeToolPolicySnapshot,
-        persistDialog: args.streamDialog.persistDialog,
-        ...(args.workspaceLease ? { workspaceLease: args.workspaceLease } : {}),
-    });
-
-    if (stream) {
-        const dispatchForegroundStreamExecution = async () => {
-            try {
-                const connectorResult = await runExecutionConnector({
-                    userId,
-                    requestTimeoutMs: effectiveAgentRunTimeoutMs,
-                });
-                if (connectorResult) {
-                    const workspaceLease = buildExecutionWorkspaceLease(connectorResult);
-                    const streamDialog = await prepareCurrentForegroundStreamDialog();
-                    const startedAt = Date.now();
-                    return agentRunSse(buildBillableForegroundSseStream(
-                        buildMachineConnectorSseStream(connectorResult),
-                        buildForegroundStreamLifecycleContext({
-                            streamDialog,
-                            startedAt,
-                            workspaceLease,
-                        })
-                    ));
-                }
-            } catch (e: any) {
-                const connectorFailureResponse = resolveConnectorFailureResponse(e, executionAgentConfig);
-                if (connectorFailureResponse) return connectorFailureResponse;
-                throw e;
-            }
-            let streamDialog: Awaited<ReturnType<typeof prepareForegroundStreamDialog>>;
-            try {
-                streamDialog = await prepareCurrentForegroundStreamDialog();
-            } catch (e: any) {
-                return agentRunError(e.message ?? "Failed to create dialog", e.status ?? 500);
-            }
-            const startedAt = Date.now();
-            const sourceStream = buildExecutionSourceStream({
-                userId: streamDialog.effectiveUserId,
-                dialogId: streamDialog.dialogId,
-                spaceId: streamDialog.effectiveSpaceId,
-            });
-            return agentRunSse(buildBillableForegroundSseStream(
-                sourceStream,
-                buildForegroundStreamLifecycleContext({
-                    streamDialog,
-                    startedAt,
-                }),
-            ));
-        };
-        return await dispatchForegroundStreamExecution();
-    }
-
-    // ── background 模式：立即返回 dialogId，后台执行 ───────────────────────────
-    if (background) {
-        const backgroundDialog = await prepareBackgroundRunDialog({
-            continueDialogId,
-            existingDialogKey,
-            existingDialogRecord,
-            continueDialogUserId,
-            fallbackSpaceId: spaceId,
-            createPendingDialog,
-            pendingDialogInput: buildPendingDialogInput(agentKey),
-        });
-        if (isBackgroundRunDialogError(backgroundDialog)) {
-            return agentRunError(backgroundDialog.error, backgroundDialog.status);
-        }
-        const {
-            dialogId,
-            dialogKey,
-            effectiveUserId: effectiveBackgroundUserId,
-            effectiveSpaceId: effectiveBackgroundSpaceId,
-        } = backgroundDialog;
-        const backgroundDialogPersistenceContext = {
-            dialogId,
-            dialogKey,
-            agentKey,
-            parentDialogId,
-            runtimeContext,
-            spaceId: effectiveBackgroundSpaceId,
-        };
-        const startedAt = Date.now();
-        const persistBackgroundDialogRecord = async (args: {
-            status: "running" | "failed";
-            updatedAt: number;
-            extraFields?: Record<string, unknown>;
-            buildRuntimeCheckpoint: (existingDialog: any) => unknown;
-            failureLogLabel: string;
-        }) => {
-            try {
-                const store = getAgentRunStore();
-                const existingDialog = await store.get(dialogKey);
-                await store.put(dialogKey, {
-                    ...existingDialog,
-                    status: args.status,
-                    updatedAt: new Date(args.updatedAt).toISOString(),
-                    ...(args.extraFields ?? {}),
-                    runtimeCheckpoint: args.buildRuntimeCheckpoint(existingDialog),
-                });
-                return true;
-            } catch (persistError) {
-                console.error(
-                    `[background] dialog=${dialogId} ${args.failureLogLabel} persist failed:`,
-                    persistError,
-                );
-                return false;
-            }
-        };
-        const publishBackgroundDialogTransition = async (args: {
-            status: "running" | "done" | "failed";
-            projectActivity?: boolean;
-            progress?: MachineConnectorRunProgress;
-            content?: string;
-            usage?: LoopResult["usage"];
-            error?: string;
-        }) => {
-            if (args.projectActivity !== false) {
-                await projectBackgroundDialogActivity({
-                    ...backgroundDialogPersistenceContext,
-                    status: args.status,
-                });
-            }
-            if (args.progress) {
-                pushEvent(`dialog-${dialogId}`, {
-                    type: "runtime.progress",
-                    progress: args.progress,
-                });
-                return;
-            }
-            if (args.status === "running") {
-                pushEvent(`dialog-${dialogId}`, { type: "status", status: "running" });
-                return;
-            }
-            if (args.status === "done") {
-                pushEvent(`dialog-${dialogId}`, {
-                    type: "done",
-                    content: args.content,
-                    usage: args.usage,
-                });
-                if (effectiveBackgroundSpaceId) {
-                    pushEvent(`space-${effectiveBackgroundSpaceId}`, { type: "dialog.done", dialogId });
-                }
-                return;
-            }
-            pushEvent(`dialog-${dialogId}`, {
-                type: "failed",
-                error: args.error,
-            });
-            if (effectiveBackgroundSpaceId) {
-                pushEvent(`space-${effectiveBackgroundSpaceId}`, { type: "dialog.failed", dialogId });
-            }
-        };
-
-        // 更新 status=running
-        const runningAt = Date.now();
-        const persistedRunning = await persistBackgroundDialogRecord({
-            status: "running",
-            updatedAt: runningAt,
-            extraFields: { startedAt },
-            buildRuntimeCheckpoint: (existingDialog: any) => buildRunningRuntimeCheckpoint({
-                dialogId,
-                userInputText,
-                updatedAt: runningAt,
-                runtimeBinding: existingDialog?.runtimeBinding,
-            }),
-            failureLogLabel: "status update",
-        });
-        await publishBackgroundDialogTransition({
-            status: "running",
-            projectActivity: persistedRunning,
-        });
-
-        // 后台执行（不阻塞响应）
-        incActiveStream();
-        const dispatchBackgroundExecution = async () => {
-            const settleBackgroundExecutionSuccess = async (args: {
-                result: LoopResult;
-                workspaceLease?: Record<string, unknown>;
-            }) => {
-                if (continueDialogId) {
-                    await appendToExistingDialog({
-                        dialogId,
-                        dialogKey,
-                        agentKey,
-                        userId: effectiveBackgroundUserId,
-                        userInput: userInputText,
-                        result: args.result,
-                        durationMs: Date.now() - startedAt,
-                        spaceId: effectiveBackgroundSpaceId,
-                        runtimeProfile: effectiveRuntimeProfile,
-                        runtimeContext,
-                        runtimeToolPolicySnapshot,
-                        workspaceLease: args.workspaceLease,
-                    });
-                } else {
-                    await finalizeDialog({
-                        dialogId,
-                        dialogKey,
-                        agentKey,
-                        result: args.result,
-                        startedAt,
-                        status: "done",
-                        userInput: userInputText,
-                        userId,
-                        spaceId,
-                        runtimeContext,
-                        runtimeToolPolicySnapshot,
-                        workspaceLease: args.workspaceLease,
-                    });
-                }
-                await publishBackgroundDialogTransition({
-                    status: "done",
-                    content: args.result.content,
-                    usage: args.result.usage,
-                });
-                await writeAgentRunBillingIfNeeded({
-                    agentConfig: executionAgentConfig,
-                    agentKey,
-                    result: args.result,
-                    dialogId,
-                    mode: "background",
-                    userId: effectiveBackgroundUserId,
-                });
-            };
-            const settleBackgroundExecutionFailure = async (args: {
-                error: unknown;
-            }) => {
-                const failedAt = Date.now();
-                const errorMessage =
-                    args.error instanceof Error ? args.error.message : String(args.error);
-                await persistBackgroundDialogRecord({
-                    status: "failed",
-                    updatedAt: failedAt,
-                    extraFields: {
-                        finishedAt: failedAt,
-                        durationMs: Math.max(0, failedAt - startedAt),
-                        errorMessage,
-                    },
-                    buildRuntimeCheckpoint: (existingDialog: any) => buildFailedRuntimeCheckpoint({
-                        existingDialog,
-                        dialogId,
-                        userInputText,
-                        updatedAt: failedAt,
-                        errorMessage,
-                    }),
-                    failureLogLabel: "status",
-                });
-                await publishBackgroundDialogTransition({
-                    status: "failed",
-                    error: errorMessage,
-                });
-                const dialogTitle =
-                    existingDialogRecord?.title ??
-                    buildDialogFallbackTitleFromUserInput(userInputText);
-                await emitDialogStatusNotification({
-                    userId: effectiveBackgroundUserId,
-                    ...backgroundDialogPersistenceContext,
-                    dialogTitle,
-                    status: "failed",
-                    createdAt: failedAt,
-                    errorMessage,
-                });
-            };
-            try {
-                const backgroundTimeoutMs =
-                    effectiveAgentRunTimeoutMs ?? DEFAULT_BACKGROUND_RUN_TIMEOUT_MS;
-                let workspaceLease: Record<string, unknown> | undefined;
-                const prepareBackgroundProgressPhase = async () => {
-                    const persistConnectorProgress = async (progress: MachineConnectorRunProgress) => {
-                        const progressAt = Date.now();
-                        const persistedProgress = await persistBackgroundDialogRecord({
-                            status: "running",
-                            updatedAt: progressAt,
-                            buildRuntimeCheckpoint: (existingDialog: any) => buildProgressRuntimeCheckpoint({
-                                existingDialog,
-                                dialogId,
-                                userInputText,
-                                progress,
-                                updatedAt: progressAt,
-                            }),
-                            failureLogLabel: "progress",
-                        });
-                        if (persistedProgress) {
-                            await publishBackgroundDialogTransition({
-                                status: "running",
-                                progress,
-                            });
-                        }
-                    };
-                    const maybeRuntimePromptPage = await createRuntimePromptPageIfLarge({
-                        agentConfig: executionAgentConfig,
-                        agentKey,
-                        dialogId,
-                        runtimeContext,
-                        spaceId: effectiveBackgroundSpaceId,
-                        userId: effectiveBackgroundUserId,
-                        userInputText,
-                    }).catch((error) => {
-                        console.warn("[agentRun.background] runtime prompt page create failed", {
-                            dialogId,
-                            agentKey,
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                        return null;
-                    });
-                    if (maybeRuntimePromptPage) {
-                        await persistConnectorProgress({
-                            message: "runtime-prompt-page-created",
-                            promptPageKey: maybeRuntimePromptPage.dbKey,
-                            promptPageHash: maybeRuntimePromptPage.promptHash,
-                            promptBytes: maybeRuntimePromptPage.contentBytes,
-                            updatedAt: Date.now(),
-                        });
-                    }
-                    return {
-                        persistConnectorProgress,
-                        runtimePromptPage: maybeRuntimePromptPage,
-                    };
-                };
-                const { persistConnectorProgress, runtimePromptPage } = await prepareBackgroundProgressPhase();
-                const { result, workspaceLease: resolvedWorkspaceLease } = await withBackgroundRunTimeout((async () => {
-                    console.log("[agentRun.background] dispatch", {
-                        dialogId,
-                        agentKey,
-                        backgroundTimeoutMs,
-                        userInputBytes: byteLength(userInputText),
-                        runtimePromptPageKey: runtimePromptPage?.dbKey,
-                    });
-                    const executionRun = await runExecutionResult({
-                        userId: effectiveBackgroundUserId,
-                        dialogId,
-                        spaceId: effectiveBackgroundSpaceId,
-                        requestTimeoutMs: backgroundTimeoutMs,
-                        runtimePromptPage,
-                        onProgress: persistConnectorProgress,
-                    });
-                    console.log("[agentRun.background] connector-result", {
-                        dialogId,
-                        agentKey,
-                        usedMachineConnector: Boolean(executionRun.connectorResult),
-                        contentBytes: byteLength(String(executionRun.connectorResult?.content ?? "")),
-                    });
-                    return executionRun;
-                })(), backgroundTimeoutMs);
-                workspaceLease = resolvedWorkspaceLease;
-                await settleBackgroundExecutionSuccess({ result, workspaceLease });
-            } catch (e) {
-                console.error(`[background] dialog=${dialogId} failed:`, e);
-                await settleBackgroundExecutionFailure({ error: e });
-            } finally {
-                decActiveStream();
-            }
-        };
-        dispatchBackgroundExecution().catch((e) => { console.error(`[background] unhandled rejection dialog=${dialogId}:`, e); });
-
-        return agentRunJson({ dialogId, status: "pending" }, 202);
-    }
-
-    // ── 前台同步模式 ───────────────────────────────────────────────────────────
-    const dispatchSyncExecution = async () => {
-        const startTime = Date.now();
-        // 注意：sync 新建 dialog 的首轮执行在 saveRunAsDialog 之前，runAgentLoop 此时还拿不到最终 dialogId。
-        // 这意味着首轮 server-side external tool charge 还无法稳定投影进 dialog.totalCost；
-        // continue/background 场景已有 dialogId，可正常回写。后续若要补齐这里，需要先拿稳定 dialogId 再执行工具链。
-        const { result, workspaceLease } = await runExecutionResult({
-            userId,
-            requestTimeoutMs: effectiveAgentRunTimeoutMs,
-            dialogId: continueDialogId ?? undefined,
-            spaceId,
-        });
-        const durationMs = Date.now() - startTime;
-
-        const { dialogId, dialogKey } = await completeSyncAgentRunDialog({
-            continueDialogId,
-            existingDialogKey,
-            dialogAgentKey,
-            traceAgentKey,
-            continueDialogUserId,
-            result,
-            durationMs,
-            workspaceLease,
-            appendToExistingDialog,
-            saveRunAsDialog,
-            summarizeMessagesForDebug,
-            ...dialogLifecyclePersistenceContext,
-        });
-        await writeAgentRunBillingIfNeeded({
-            agentConfig: executionAgentConfig,
-            agentKey,
-            result,
-            dialogId,
-            mode: "sync",
-            userId,
-        });
-
-        const debugContext = buildAgentRunDebugContext({
-            enabled: debugContextLayers,
-            runtimeSystemMessageContext,
-            selectedMemoryItems: executionMemoryRuntime.selectedItems,
-        });
-
-        return agentRunJson({
-            ...result,
-            dialogId,
-            dialogKey,
-            ...(debugContext ? { debug: debugContext } : {}),
-        });
-    };
-    try {
-        return await dispatchSyncExecution();
-    } catch (e: any) {
-        const connectorFailureResponse = resolveConnectorFailureResponse(e, executionAgentConfig);
-        if (connectorFailureResponse) return connectorFailureResponse;
-        return agentRunError(e.message ?? "Internal server error", 500);
-    }
-}