fengming 0.3.7 → 0.3.9

package/dist/agent-via-gateway-CZ0X0YkM.js

@@ -0,0 +1,486 @@
+import { c as normalizeOptionalString } from "./string-coerce-DKw2K5wM.js";
+import { g as parseStrictNonNegativeInteger } from "./number-coercion-D1aDmIZp.js";
+import "./parse-finite-number-CpgOyjPq.js";
+import { t as formatCliCommand } from "./command-format-Jv8eeOPe.js";
+import { r as writeRuntimeJson } from "./runtime-BkTkFkXs.js";
+import { a as routeLogsToStderr } from "./console-B8_FW6uR.js";
+import { d as resolveAgentIdFromSessionKey, h as scopeLegacySessionKeyToAgent, l as normalizeAgentId, o as classifySessionKeyShape, s as isUnscopedSessionKeySentinel } from "./session-key-CJf5_zWs.js";
+import { c as resolveDefaultAgentId, n as listAgentIds } from "./agent-scope-config-BHdZonI2.js";
+import { i as getRuntimeConfig } from "./io-T1CV3Z1L.js";
+import { i as GATEWAY_CLIENT_NAMES, r as GATEWAY_CLIENT_MODES } from "./client-info-D6_UASoA.js";
+import { i as normalizeMessageChannel } from "./message-channel-normalize-CaOaCinb.js";
+import "./message-channel-DcN_7tYD.js";
+import { t as ADMIN_SCOPE } from "./operator-scopes-DGvgHuOd.js";
+import { d as isGatewayTransportError, f as randomIdempotencyKey, i as callGateway } from "./call-CLicF0UE.js";
+import { m as resolveSendableOutboundReplyParts } from "./reply-payload-swpu2tGD.js";
+import { r as withProgress } from "./progress-G9DILAx2.js";
+import { randomUUID } from "node:crypto";
+//#region src/commands/agent-via-gateway.ts
+const NO_GATEWAY_TIMEOUT_MS = 2147e6;
+const EMBEDDED_FALLBACK_META = {
+	transport: "embedded",
+	fallbackFrom: "gateway"
+};
+const GATEWAY_TIMEOUT_FALLBACK_SESSION_PREFIX = "gateway-fallback-";
+const GATEWAY_TRANSIENT_CONNECT_RETRY_DELAYS_MS = [
+	1e3,
+	2e3,
+	5e3,
+	1e4,
+	15e3
+];
+const AGENT_CLI_SIGNALS = ["SIGINT", "SIGTERM"];
+const GATEWAY_ABORT_RETRY_DELAYS_MS = [
+	50,
+	150,
+	300,
+	600
+];
+const GATEWAY_ABORT_REQUEST_TIMEOUT_MS = 2e3;
+const AGENT_CLI_SIGNAL_EXIT_CODES = {
+	SIGINT: 130,
+	SIGTERM: 143
+};
+let embeddedAgentCommandPromise;
+let agentSessionModulePromise;
+const defaultAgentSessionModuleLoader = () => import("./session-pNUlyb-s.js");
+let agentSessionModuleLoader = defaultAgentSessionModuleLoader;
+function loadEmbeddedAgentCommand() {
+	embeddedAgentCommandPromise ??= import("./agent-DZi6j3o6.js").then((module) => module.agentCommand);
+	return embeddedAgentCommandPromise;
+}
+function loadAgentSessionModule() {
+	agentSessionModulePromise ??= agentSessionModuleLoader();
+	return agentSessionModulePromise;
+}
+function protectJsonStdout(opts) {
+	if (opts.json === true) routeLogsToStderr();
+}
+function parseTimeoutSeconds(opts) {
+	const raw = opts.timeout !== void 0 ? parseStrictNonNegativeInteger(opts.timeout) : opts.cfg.agents?.defaults?.timeoutSeconds ?? 600;
+	if (raw === void 0) throw new Error(`Invalid --timeout. Use seconds as a non-negative integer, for example --timeout 600. Use --timeout 0 to disable the timeout.`);
+	return raw;
+}
+function getGatewayDispatchConfig() {
+	return getRuntimeConfig({
+		skipPluginValidation: true,
+		pin: false
+	});
+}
+function formatPayloadForLog(payload) {
+	const parts = resolveSendableOutboundReplyParts({
+		text: payload.text,
+		mediaUrls: payload.mediaUrls,
+		mediaUrl: typeof payload.mediaUrl === "string" ? payload.mediaUrl : void 0
+	});
+	const lines = [];
+	if (parts.text) lines.push(parts.text.trimEnd());
+	for (const url of parts.mediaUrls) lines.push(`MEDIA:${url}`);
+	return lines.join("\n").trimEnd();
+}
+function isGatewayAgentTimeoutError(err) {
+	if (isGatewayTransportError(err)) return err.kind === "timeout";
+	return err instanceof Error && err.message.includes("gateway request timeout for agent");
+}
+function isControlCommandThatMustNotFallback(opts) {
+	const normalized = opts.message.trim().toLowerCase();
+	return normalized === "/compact" || normalized.startsWith("/compact ");
+}
+function isGatewayAgentEmbeddedFallbackError(err) {
+	return isGatewayTransportError(err);
+}
+function isTransientGatewayAgentConnectClose(err) {
+	if (!isGatewayTransportError(err) || err.kind !== "closed") return false;
+	const code = typeof err.code === "number" ? err.code : void 0;
+	const reason = normalizeOptionalString(err.reason);
+	return code === 1e3 && (!reason || reason === "no close reason");
+}
+function validateExplicitSessionKeyForDispatch(opts) {
+	const sessionKey = opts.sessionKey?.trim();
+	if (!sessionKey) return;
+	if (classifySessionKeyShape(sessionKey) === "malformed_agent") throw new Error(`Invalid --session-key "${sessionKey}". Agent-prefixed session keys must use agent:<agent-id>:<session-key>.`);
+	const agentIdRaw = opts.agent?.trim() || void 0;
+	if (!agentIdRaw || classifySessionKeyShape(sessionKey) !== "agent") return;
+	const agentId = normalizeAgentId(agentIdRaw);
+	const sessionAgentId = resolveAgentIdFromSessionKey(sessionKey);
+	if (sessionAgentId !== agentId) throw new Error(`Agent id "${agentIdRaw}" does not match session key agent "${sessionAgentId}".`);
+}
+function normalizeSessionKeyOptsForDispatch(opts) {
+	const rawSessionKey = opts.sessionKey?.trim();
+	const isLegacySessionKey = rawSessionKey && classifySessionKeyShape(rawSessionKey) === "legacy_or_alias";
+	const agentIdRaw = opts.agent?.trim();
+	const shouldScopeDefaultAgentKey = isLegacySessionKey && !agentIdRaw && !isUnscopedSessionKeySentinel(rawSessionKey);
+	const cfg = isLegacySessionKey && (agentIdRaw || shouldScopeDefaultAgentKey) ? opts.local === true ? getRuntimeConfig() : getGatewayDispatchConfig() : void 0;
+	const sessionKey = scopeLegacySessionKeyToAgent({
+		agentId: agentIdRaw ?? (shouldScopeDefaultAgentKey ? resolveDefaultAgentId(cfg) : void 0),
+		sessionKey: opts.sessionKey,
+		mainKey: cfg?.session?.mainKey
+	});
+	if (sessionKey === opts.sessionKey) return opts;
+	return {
+		...opts,
+		sessionKey
+	};
+}
+function isAbortError(err) {
+	return err instanceof Error && err.name === "AbortError";
+}
+function readAcceptedRunContext(payload) {
+	if (!payload || typeof payload !== "object") return {};
+	const runId = payload.runId;
+	const sessionKey = payload.sessionKey;
+	if (payload.status !== "accepted") return {};
+	return {
+		runId: typeof runId === "string" && runId.trim() ? runId.trim() : void 0,
+		sessionKey: typeof sessionKey === "string" && sessionKey.trim() ? sessionKey.trim() : void 0
+	};
+}
+function createAgentCliSignalBridge(processLike = process) {
+	const controller = new AbortController();
+	let receivedSignal;
+	const handlers = /* @__PURE__ */ new Map();
+	const detachHandlers = () => {
+		for (const [signal, handler] of handlers) processLike.off(signal, handler);
+		handlers.clear();
+	};
+	for (const signal of AGENT_CLI_SIGNALS) {
+		const handler = () => {
+			receivedSignal = signal;
+			if (!controller.signal.aborted) {
+				controller.abort();
+				detachHandlers();
+			}
+		};
+		handlers.set(signal, handler);
+		processLike.on(signal, handler);
+	}
+	return {
+		signal: controller.signal,
+		getReceivedSignal: () => receivedSignal,
+		dispose: detachHandlers
+	};
+}
+function isAgentCliProcessLike(value) {
+	return Boolean(value) && typeof value === "object" && typeof value.on === "function" && typeof value.off === "function";
+}
+function resolveAgentCliProcessLike(deps) {
+	if (!deps || !Object.prototype.hasOwnProperty.call(deps, "process")) return process;
+	const processLike = deps.process;
+	return isAgentCliProcessLike(processLike) ? processLike : process;
+}
+function createAbortDelayError() {
+	const err = /* @__PURE__ */ new Error("网关 Agent 重试已中止");
+	err.name = "AbortError";
+	return err;
+}
+function delayMs(ms, signal) {
+	if (signal?.aborted) return Promise.reject(createAbortDelayError());
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+			reject(createAbortDelayError());
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function isConfirmedChatAbortResponseForRun(value, runId) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const response = value;
+	if (response.aborted !== true) return false;
+	if (response.runIds === void 0) return true;
+	return Array.isArray(response.runIds) && response.runIds.includes(runId);
+}
+async function abortAcceptedGatewayAgentRunWithRequest(params) {
+	if (!params.signal || !params.runId || !params.sessionKey) return false;
+	try {
+		if (isConfirmedChatAbortResponseForRun(await params.request("chat.abort", {
+			sessionKey: params.sessionKey,
+			runId: params.runId
+		}, { timeoutMs: GATEWAY_ABORT_REQUEST_TIMEOUT_MS }), params.runId)) return true;
+		if (params.logFailure !== false) params.runtime.error?.(`Interrupted by ${params.signal}; Gateway run ${params.runId} was not confirmed aborted.`);
+		return false;
+	} catch (err) {
+		if (params.logFailure !== false) params.runtime.error?.(`Interrupted by ${params.signal}; failed to abort Gateway run ${params.runId}: ${String(err)}`);
+		return false;
+	}
+}
+async function abortAcceptedGatewayAgentRunWithGatewayCall(params) {
+	const request = async (method, requestParams, opts) => await callGateway({
+		method,
+		params: requestParams,
+		timeoutMs: opts?.timeoutMs ?? void 0,
+		expectFinal: opts?.expectFinal,
+		config: params.config,
+		...params.gatewayIdentity
+	});
+	for (const [attempt, retryDelayMs] of [...GATEWAY_ABORT_RETRY_DELAYS_MS, 0].entries()) {
+		const isFinalAttempt = attempt === GATEWAY_ABORT_RETRY_DELAYS_MS.length;
+		if (await abortAcceptedGatewayAgentRunWithRequest({
+			runId: params.runId,
+			sessionKey: params.sessionKey,
+			signal: params.signal,
+			runtime: params.runtime,
+			request,
+			logFailure: isFinalAttempt
+		}) || isFinalAttempt) return;
+		await delayMs(retryDelayMs);
+	}
+}
+async function abortAcceptedGatewayAgentRunOnActiveConnection(params) {
+	for (const [attempt, retryDelayMs] of [...GATEWAY_ABORT_RETRY_DELAYS_MS, 0].entries()) {
+		const isFinalAttempt = attempt === GATEWAY_ABORT_RETRY_DELAYS_MS.length;
+		const aborted = await abortAcceptedGatewayAgentRunWithRequest({
+			runId: params.runId,
+			sessionKey: params.sessionKey,
+			signal: params.signal,
+			runtime: params.runtime,
+			request: params.request,
+			logFailure: false
+		});
+		if (aborted || isFinalAttempt) return aborted;
+		await delayMs(retryDelayMs);
+	}
+	return false;
+}
+function exitForReceivedSignal(signal, runtime) {
+	if (!signal) return false;
+	runtime.exit(AGENT_CLI_SIGNAL_EXIT_CODES[signal]);
+	return true;
+}
+function returnAfterSignalExit(value, signal, runtime) {
+	return exitForReceivedSignal(signal, runtime) ? void 0 : value;
+}
+function createGatewayTimeoutFallbackSessionId() {
+	return `${GATEWAY_TIMEOUT_FALLBACK_SESSION_PREFIX}${randomUUID()}`;
+}
+function createGatewayTimeoutFallbackSession(agentId) {
+	const sessionId = createGatewayTimeoutFallbackSessionId();
+	return {
+		sessionId,
+		sessionKey: `agent:${normalizeAgentId(agentId)}:explicit:${sessionId.trim()}`
+	};
+}
+async function resolveAgentIdForGatewayTimeoutFallback(opts) {
+	const explicitSessionKey = opts.sessionKey?.trim();
+	if (classifySessionKeyShape(explicitSessionKey) === "agent") return resolveAgentIdFromSessionKey(explicitSessionKey);
+	if (isUnscopedSessionKeySentinel(explicitSessionKey)) return resolveDefaultAgentId(getGatewayDispatchConfig());
+	const agentIdRaw = opts.agent?.trim();
+	if (agentIdRaw) return normalizeAgentId(agentIdRaw);
+	if (!opts.to && !opts.sessionId) return;
+	const cfg = getGatewayDispatchConfig();
+	const { resolveSessionKeyForRequest } = await loadAgentSessionModule();
+	const resolvedSessionKey = resolveSessionKeyForRequest({
+		cfg,
+		to: opts.to,
+		sessionId: opts.sessionId
+	}).sessionKey;
+	return classifySessionKeyShape(resolvedSessionKey) === "agent" ? resolveAgentIdFromSessionKey(resolvedSessionKey) : void 0;
+}
+function buildGatewayJsonResponse(response) {
+	const deliveryStatus = response.result?.deliveryStatus;
+	if (deliveryStatus === void 0) return response;
+	return {
+		...response,
+		deliveryStatus
+	};
+}
+function isInFlightGatewayAgentResponse(response) {
+	return response.status === "in_flight";
+}
+function formatInFlightGatewayAgentMessage(response) {
+	return response.runId ? `Agent run ${response.runId} is already in flight; not starting a duplicate run.` : "Agent run is already in flight; not starting a duplicate run.";
+}
+async function agentViaGatewayCommand(opts, runtime, signalBridge) {
+	protectJsonStdout(opts);
+	const body = (opts.message ?? "").trim();
+	const explicitSessionKey = opts.sessionKey?.trim();
+	if (!body) throw new Error(`Missing message. Use ${formatCliCommand("fengming agent --message \"...\" --agent <id>")} or pass --to/--session-key/--session-id for an existing conversation.`);
+	if (!opts.to && !opts.sessionId && !opts.agent && !explicitSessionKey) throw new Error(`No target session selected. Use --agent <id>, --session-key <key>, --session-id <id>, or --to <E.164>. Run ${formatCliCommand("fengming agents list")} to see agents.`);
+	const cfg = getGatewayDispatchConfig();
+	const agentIdRaw = opts.agent?.trim();
+	const agentId = agentIdRaw ? normalizeAgentId(agentIdRaw) : void 0;
+	if (agentId) {
+		if (!listAgentIds(cfg).includes(agentId)) throw new Error(`Unknown agent id "${agentIdRaw}". Use "${formatCliCommand("fengming agents list")}" to see configured agents.`);
+	}
+	const timeoutSeconds = parseTimeoutSeconds({
+		cfg,
+		timeout: opts.timeout
+	});
+	const gatewayTimeoutMs = timeoutSeconds === 0 ? NO_GATEWAY_TIMEOUT_MS : Math.max(1e4, (timeoutSeconds + 30) * 1e3);
+	const sessionKey = classifySessionKeyShape(explicitSessionKey) === "agent" ? explicitSessionKey : (await loadAgentSessionModule()).resolveSessionKeyForRequest({
+		cfg,
+		agentId,
+		to: opts.to,
+		sessionId: opts.sessionId,
+		sessionKey: explicitSessionKey
+	}).sessionKey;
+	const channel = normalizeMessageChannel(opts.channel);
+	const idempotencyKey = normalizeOptionalString(opts.runId) || randomIdempotencyKey();
+	const modelOverride = normalizeOptionalString(opts.model);
+	const gatewayIdentity = Boolean(modelOverride) ? {
+		clientName: GATEWAY_CLIENT_NAMES.GATEWAY_CLIENT,
+		mode: GATEWAY_CLIENT_MODES.BACKEND,
+		scopes: [ADMIN_SCOPE]
+	} : {
+		clientName: GATEWAY_CLIENT_NAMES.CLI,
+		mode: GATEWAY_CLIENT_MODES.CLI
+	};
+	let acceptedRunId = idempotencyKey;
+	let acceptedSessionKey = sessionKey;
+	let acceptedGatewayRun = false;
+	let activeConnectionAbortAttempted = false;
+	let activeConnectionAbortSucceeded = false;
+	let response;
+	try {
+		response = await withProgress({
+			label: "Waiting for agent reply…",
+			indeterminate: true,
+			enabled: opts.json !== true
+		}, async () => await callGateway({
+			method: "agent",
+			params: {
+				message: body,
+				agentId,
+				model: modelOverride,
+				to: opts.to,
+				replyTo: opts.replyTo,
+				sessionId: opts.sessionId,
+				sessionKey,
+				thinking: opts.thinking,
+				deliver: Boolean(opts.deliver),
+				channel,
+				replyChannel: opts.replyChannel,
+				replyAccountId: opts.replyAccount,
+				bestEffortDeliver: opts.bestEffortDeliver,
+				timeout: timeoutSeconds,
+				lane: opts.lane,
+				extraSystemPrompt: opts.extraSystemPrompt,
+				idempotencyKey
+			},
+			expectFinal: true,
+			timeoutMs: gatewayTimeoutMs,
+			config: cfg,
+			signal: signalBridge.signal,
+			onAccepted: (payload) => {
+				acceptedGatewayRun = true;
+				const accepted = readAcceptedRunContext(payload);
+				acceptedRunId = accepted.runId ?? acceptedRunId;
+				acceptedSessionKey = accepted.sessionKey ?? acceptedSessionKey;
+			},
+			onSignalAbort: async (request) => {
+				activeConnectionAbortAttempted = true;
+				activeConnectionAbortSucceeded = await abortAcceptedGatewayAgentRunOnActiveConnection({
+					runId: acceptedRunId,
+					sessionKey: acceptedSessionKey,
+					signal: signalBridge.getReceivedSignal(),
+					runtime,
+					request
+				});
+			},
+			...gatewayIdentity
+		}));
+	} catch (err) {
+		if (isAbortError(err) && !activeConnectionAbortSucceeded && (acceptedGatewayRun || activeConnectionAbortAttempted)) await abortAcceptedGatewayAgentRunWithGatewayCall({
+			runId: acceptedRunId,
+			sessionKey: acceptedSessionKey,
+			signal: signalBridge.getReceivedSignal(),
+			runtime,
+			gatewayIdentity,
+			config: cfg
+		});
+		throw err;
+	}
+	if (opts.json) {
+		writeRuntimeJson(runtime, buildGatewayJsonResponse(response));
+		return response;
+	}
+	const payloads = (response?.result)?.payloads ?? [];
+	if (isInFlightGatewayAgentResponse(response)) {
+		runtime.error?.(formatInFlightGatewayAgentMessage(response));
+		return response;
+	}
+	if (payloads.length === 0) {
+		if (response?.status !== "ok") runtime.log(response?.summary ? response.summary : "No reply from agent.");
+		return response;
+	}
+	for (const payload of payloads) {
+		const out = formatPayloadForLog(payload);
+		if (out) runtime.log(out);
+	}
+	return response;
+}
+async function agentViaGatewayCommandWithTransientRetries(opts, runtime, signalBridge) {
+	for (const [attempt, retryDelayMs] of [...GATEWAY_TRANSIENT_CONNECT_RETRY_DELAYS_MS, 0].entries()) try {
+		return await agentViaGatewayCommand(opts, runtime, signalBridge);
+	} catch (err) {
+		if (isAbortError(err)) throw err;
+		if (attempt === GATEWAY_TRANSIENT_CONNECT_RETRY_DELAYS_MS.length || !isTransientGatewayAgentConnectClose(err)) throw err;
+		runtime.error?.(`Gateway agent connection closed during handshake; retrying in ${retryDelayMs}ms before embedded fallback.`);
+		await delayMs(retryDelayMs, signalBridge.signal);
+	}
+	throw new Error("网关 Agent 重试循环意外耗尽。");
+}
+async function agentCliCommand(opts, runtime, deps) {
+	protectJsonStdout(opts);
+	const dispatchOpts = normalizeSessionKeyOptsForDispatch(opts);
+	validateExplicitSessionKeyForDispatch(dispatchOpts);
+	const gatewayDispatchOpts = dispatchOpts.runId ? dispatchOpts : {
+		...dispatchOpts,
+		runId: randomIdempotencyKey()
+	};
+	const signalBridge = createAgentCliSignalBridge(resolveAgentCliProcessLike(deps));
+	const localOpts = {
+		...gatewayDispatchOpts,
+		agentId: gatewayDispatchOpts.agent,
+		replyAccountId: gatewayDispatchOpts.replyAccount,
+		cleanupBundleMcpOnRunEnd: true,
+		cleanupCliLiveSessionOnRunEnd: true,
+		abortSignal: signalBridge.signal
+	};
+	try {
+		if (dispatchOpts.local === true) return returnAfterSignalExit(await (await loadEmbeddedAgentCommand())(localOpts, runtime, deps), signalBridge.getReceivedSignal(), runtime);
+		try {
+			return returnAfterSignalExit(await agentViaGatewayCommandWithTransientRetries(gatewayDispatchOpts, runtime, signalBridge), signalBridge.getReceivedSignal(), runtime);
+		} catch (err) {
+			if (isAbortError(err)) {
+				if (exitForReceivedSignal(signalBridge.getReceivedSignal(), runtime)) return;
+				throw err;
+			}
+			if (isGatewayAgentTimeoutError(err)) {
+				if (isControlCommandThatMustNotFallback(dispatchOpts)) throw err;
+				const fallbackSession = createGatewayTimeoutFallbackSession(await resolveAgentIdForGatewayTimeoutFallback(dispatchOpts));
+				runtime.error?.(`EMBEDDED FALLBACK: Gateway agent timed out; running embedded agent with fresh session ${fallbackSession.sessionId}: ${String(err)}`);
+				return returnAfterSignalExit(await (await loadEmbeddedAgentCommand())({
+					...localOpts,
+					sessionId: fallbackSession.sessionId,
+					sessionKey: fallbackSession.sessionKey,
+					runId: fallbackSession.sessionId,
+					resultMetaOverrides: {
+						...EMBEDDED_FALLBACK_META,
+						fallbackReason: "gateway_timeout",
+						fallbackSessionId: fallbackSession.sessionId,
+						fallbackSessionKey: fallbackSession.sessionKey
+					}
+				}, runtime, deps), signalBridge.getReceivedSignal(), runtime);
+			}
+			if (!isGatewayAgentEmbeddedFallbackError(err)) throw err;
+			runtime.error?.(`EMBEDDED FALLBACK: Gateway agent failed; running embedded agent: ${String(err)}`);
+			return returnAfterSignalExit(await (await loadEmbeddedAgentCommand())({
+				...localOpts,
+				resultMetaOverrides: EMBEDDED_FALLBACK_META
+			}, runtime, deps), signalBridge.getReceivedSignal(), runtime);
+		}
+	} catch (err) {
+		if (isAbortError(err) && exitForReceivedSignal(signalBridge.getReceivedSignal(), runtime)) return;
+		throw err;
+	} finally {
+		signalBridge.dispose();
+	}
+}
+//#endregion
+export { agentCliCommand };

package/dist/agent-wait-dedupe-I81_F2tr.js

@@ -0,0 +1,180 @@
+import { a as asFiniteNumber } from "./number-coercion-D1aDmIZp.js";
+import { i as asOptionalRecord } from "./record-coerce-Btbek4uV.js";
+import { t as setSafeTimeout } from "./timer-delay-QZRLOpQs.js";
+import { i as mergeAgentRunTerminalOutcome, l as normalizeBlockedLivenessWaitStatus, r as isStickyAgentRunTerminalOutcome, t as buildAgentRunTerminalOutcome } from "./agent-run-terminal-outcome-uM9dOCUm.js";
+import { m as isNonTerminalAgentRunStatus } from "./subagent-announce-delivery-CtmEvLTS.js";
+//#region src/gateway/server-methods/agent-wait-dedupe.ts
+const AGENT_WAITERS_BY_RUN_ID = /* @__PURE__ */ new Map();
+function normalizeTerminalOutcomeForWaitSnapshot(outcome) {
+	if (outcome.reason === "hard_timeout") return {
+		status: outcome.status,
+		error: outcome.error
+	};
+	return normalizeBlockedLivenessWaitStatus(outcome);
+}
+function parseRunIdFromDedupeKey(key) {
+	if (key.startsWith("agent:")) return key.slice(6) || null;
+	if (key.startsWith("chat:")) return key.slice(5) || null;
+	return null;
+}
+function asString(value) {
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+function removeWaiter(runId, waiter) {
+	const waiters = AGENT_WAITERS_BY_RUN_ID.get(runId);
+	if (!waiters) return;
+	waiters.delete(waiter);
+	if (waiters.size === 0) AGENT_WAITERS_BY_RUN_ID.delete(runId);
+}
+function addWaiter(runId, waiter) {
+	const normalizedRunId = runId.trim();
+	if (!normalizedRunId) return () => {};
+	const existing = AGENT_WAITERS_BY_RUN_ID.get(normalizedRunId);
+	if (existing) {
+		existing.add(waiter);
+		return () => removeWaiter(normalizedRunId, waiter);
+	}
+	AGENT_WAITERS_BY_RUN_ID.set(normalizedRunId, new Set([waiter]));
+	return () => removeWaiter(normalizedRunId, waiter);
+}
+function notifyWaiters(runId) {
+	const normalizedRunId = runId.trim();
+	if (!normalizedRunId) return;
+	const waiters = AGENT_WAITERS_BY_RUN_ID.get(normalizedRunId);
+	if (!waiters || waiters.size === 0) return;
+	for (const waiter of waiters) waiter();
+}
+function readTerminalSnapshotFromDedupeEntry(entry) {
+	const payload = entry.payload;
+	const status = typeof payload?.status === "string" ? payload.status : void 0;
+	if (isNonTerminalAgentRunStatus(status)) return null;
+	const startedAt = asFiniteNumber(payload?.startedAt);
+	const endedAt = asFiniteNumber(payload?.endedAt) ?? entry.ts;
+	const resultMeta = asOptionalRecord(asOptionalRecord(payload?.result)?.meta);
+	const stopReason = asString(payload?.stopReason) ?? asString(resultMeta?.stopReason);
+	const livenessState = asString(payload?.livenessState) ?? asString(resultMeta?.livenessState);
+	const yielded = payload?.yielded === true || resultMeta?.yielded === true;
+	const timeoutPhase = payload?.timeoutPhase ?? resultMeta?.timeoutPhase;
+	const providerStarted = payload?.providerStarted ?? resultMeta?.providerStarted;
+	const errorMessage = typeof payload?.error === "string" ? payload.error : typeof payload?.summary === "string" ? payload.summary : entry.error?.message;
+	if (status === "ok" || status === "timeout") {
+		const terminalOutcome = buildAgentRunTerminalOutcome({
+			status,
+			livenessState,
+			error: errorMessage,
+			stopReason,
+			timeoutPhase,
+			providerStarted,
+			startedAt,
+			endedAt
+		});
+		const normalized = normalizeTerminalOutcomeForWaitSnapshot(terminalOutcome);
+		return {
+			status: normalized.status,
+			startedAt,
+			endedAt,
+			error: normalized.status === "error" ? normalized.error : normalized.status === "timeout" ? terminalOutcome.error : void 0,
+			stopReason,
+			livenessState,
+			...yielded ? { yielded } : {},
+			...terminalOutcome.timeoutPhase ? { timeoutPhase: terminalOutcome.timeoutPhase } : {},
+			...terminalOutcome.providerStarted !== void 0 ? { providerStarted: terminalOutcome.providerStarted } : {}
+		};
+	}
+	if (status === "error" || !entry.ok) {
+		const terminalOutcome = buildAgentRunTerminalOutcome({
+			status: "error",
+			livenessState,
+			error: errorMessage,
+			stopReason,
+			timeoutPhase,
+			providerStarted,
+			startedAt,
+			endedAt
+		});
+		const normalized = normalizeTerminalOutcomeForWaitSnapshot(terminalOutcome);
+		return {
+			status: normalized.status,
+			startedAt,
+			endedAt,
+			error: normalized.status === "error" ? normalized.error : normalized.status === "timeout" ? terminalOutcome.error : void 0,
+			stopReason,
+			livenessState,
+			...yielded ? { yielded } : {},
+			...terminalOutcome.timeoutPhase ? { timeoutPhase: terminalOutcome.timeoutPhase } : {},
+			...terminalOutcome.providerStarted !== void 0 ? { providerStarted: terminalOutcome.providerStarted } : {}
+		};
+	}
+	return null;
+}
+function terminalOutcomeFromWaitSnapshot(snapshot) {
+	if (snapshot.pendingError) return;
+	return buildAgentRunTerminalOutcome(snapshot);
+}
+function readTerminalSnapshotFromGatewayDedupe(params) {
+	if (params.ignoreAgentTerminalSnapshot) {
+		const chatEntry = params.dedupe.get(`chat:${params.runId}`);
+		if (!chatEntry) return null;
+		return readTerminalSnapshotFromDedupeEntry(chatEntry);
+	}
+	const chatEntry = params.dedupe.get(`chat:${params.runId}`);
+	const chatSnapshot = chatEntry ? readTerminalSnapshotFromDedupeEntry(chatEntry) : null;
+	const agentEntry = params.dedupe.get(`agent:${params.runId}`);
+	const agentSnapshot = agentEntry ? readTerminalSnapshotFromDedupeEntry(agentEntry) : null;
+	if (agentEntry) {
+		if (!agentSnapshot) {
+			if (chatSnapshot && chatEntry && chatEntry.ts > agentEntry.ts) return chatSnapshot;
+			return null;
+		}
+	}
+	if (agentSnapshot && chatSnapshot && agentEntry && chatEntry) return chatEntry.ts > agentEntry.ts ? chatSnapshot : agentSnapshot;
+	return agentSnapshot ?? chatSnapshot;
+}
+async function waitForTerminalGatewayDedupe(params) {
+	const initial = readTerminalSnapshotFromGatewayDedupe(params);
+	if (initial) return initial;
+	if (params.timeoutMs <= 0 || params.signal?.aborted) return null;
+	return await new Promise((resolve) => {
+		let settled = false;
+		let timeoutHandle;
+		let onAbort;
+		let removeWaiter;
+		const finish = (snapshot) => {
+			if (settled) return;
+			settled = true;
+			if (timeoutHandle) clearTimeout(timeoutHandle);
+			if (onAbort) params.signal?.removeEventListener("abort", onAbort);
+			removeWaiter?.();
+			resolve(snapshot);
+		};
+		const onWake = () => {
+			const snapshot = readTerminalSnapshotFromGatewayDedupe(params);
+			if (snapshot) finish(snapshot);
+		};
+		removeWaiter = addWaiter(params.runId, onWake);
+		onWake();
+		if (settled) return;
+		timeoutHandle = setSafeTimeout(() => finish(null), params.timeoutMs);
+		timeoutHandle.unref?.();
+		onAbort = () => finish(null);
+		params.signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function setGatewayDedupeEntry(params) {
+	const existing = params.dedupe.get(params.key);
+	const existingSnapshot = existing ? readTerminalSnapshotFromDedupeEntry(existing) : null;
+	const incomingSnapshot = readTerminalSnapshotFromDedupeEntry(params.entry);
+	const existingOutcome = existingSnapshot ? terminalOutcomeFromWaitSnapshot(existingSnapshot) : void 0;
+	const incomingOutcome = incomingSnapshot ? terminalOutcomeFromWaitSnapshot(incomingSnapshot) : void 0;
+	if (existingOutcome && isStickyAgentRunTerminalOutcome(existingOutcome) && !incomingOutcome) return;
+	if (existingOutcome && incomingOutcome && isStickyAgentRunTerminalOutcome(existingOutcome)) {
+		if (mergeAgentRunTerminalOutcome(existingOutcome, incomingOutcome) === existingOutcome) return;
+	}
+	params.dedupe.set(params.key, params.entry);
+	const runId = parseRunIdFromDedupeKey(params.key);
+	if (!runId) return;
+	if (!incomingSnapshot) return;
+	notifyWaiters(runId);
+}
+//#endregion
+export { setGatewayDedupeEntry as n, waitForTerminalGatewayDedupe as r, readTerminalSnapshotFromGatewayDedupe as t };

package/dist/agents/embedded-agent-runner/run/runtime-context-prompt.d.ts

@@ -1,4 +1,4 @@
-import { ds as FENGMING_RUNTIME_CONTEXT_CUSTOM_TYPE, os as CurrentInboundPromptContext } from "../../../types-DI62NfFe.js";
+import { ds as FENGMING_RUNTIME_CONTEXT_CUSTOM_TYPE, os as CurrentInboundPromptContext } from "../../../types-BQw1qXGl.js";
 
 //#region src/agents/embedded-agent-runner/run/runtime-context-prompt.d.ts
 type RuntimeContextPromptParts = {

package/dist/agents/embedded-agent-runner/tool-split.d.ts

@@ -1,2 +1,2 @@
-import { t as splitSdkTools } from "../../tool-split-BhiQ8676.js";
+import { t as splitSdkTools } from "../../tool-split-Bedy42Ms.js";
 export { splitSdkTools };

package/dist/agents/model-catalog.runtime.d.ts

@@ -1,2 +1,2 @@
-import { n as loadModelCatalog, t as loadManifestModelCatalog } from "../model-catalog-DCnRkX8f.js";
+import { n as loadModelCatalog, t as loadManifestModelCatalog } from "../model-catalog-BBMLIjhq.js";
 export { loadManifestModelCatalog, loadModelCatalog };

package/dist/api-BDB5xHYj.js

@@ -0,0 +1,3 @@
+import "./core-Bpk-qSJH.js";
+import "./agent-runtime-DZsmp1xr.js";
+export {};