@gaodefa/daocore 2026.5.48 → 2026.5.51

package/dist/agent-components.runtime-CP2KCzTj.js

@@ -0,0 +1,10 @@
+import { t as createReplyReferencePlanner } from "./reply-reference-OJ849bWH.js";
+import { c as resolveTextChunkLimit, s as resolveChunkMode } from "./chunk-DeZRGIEM.js";
+import { f as parsePluginBindingApprovalCustomId, i as buildPluginBindingResolvedText, m as resolvePluginConversationBindingApproval } from "./conversation-binding-Ce5V8uhy.js";
+import { t as finalizeInboundContext } from "./inbound-context-Cg0uCtqQ.js";
+import { t as dispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher-CYuX21il.js";
+import { t as recordInboundSession } from "./session-DDNzwYpl.js";
+import "./reply-runtime-DyCbxbOD.js";
+import "./conversation-runtime-YK1oLoen.js";
+import { r as dispatchPluginInteractiveHandler } from "./plugin-runtime-TPqTSJyy.js";
+export { buildPluginBindingResolvedText, createReplyReferencePlanner, dispatchPluginInteractiveHandler, dispatchReplyWithBufferedBlockDispatcher, finalizeInboundContext, parsePluginBindingApprovalCustomId, recordInboundSession, resolveChunkMode, resolvePluginConversationBindingApproval, resolveTextChunkLimit };

package/dist/agent-components.runtime.js

@@ -1 +1 @@
-export * from "./agent-components.runtime-Bv--4UUq.js";
+export * from "./agent-components.runtime-CP2KCzTj.js";

package/dist/agent-harness-runtime-hAssTrVq.js

@@ -0,0 +1,180 @@
+import { c as redactToolDetail } from "./redact-BjrmHGQ6.js";
+import "./errors-D_oyTIw2.js";
+import { y as truncateUtf16Safe } from "./utils-CNnMhEDp.js";
+import "./version-QmPt05QD.js";
+import "./agent-scope-Dx1S0aWX.js";
+import { t as createSubsystemLogger } from "./subsystem-CppbuBPw.js";
+import "./registry-Crj56k7x.js";
+import { b as listCodexAppServerExtensionFactories } from "./loader-CZqEc_1x.js";
+import { c as joinPresentTextSegments, t as getGlobalHookRunner } from "./hook-runner-global-RR7B_IHd.js";
+import "./registry-BCmRCXCi.js";
+import "./transcript-CalMl_Y7.js";
+import "./session-write-lock-DvfEpka6.js";
+import { u as queueEmbeddedPiMessageWithOutcome } from "./runs-SleIj69Z.js";
+import "./heartbeat-tool-response-BCz-9pPv.js";
+import "./bootstrap-files-CqPzStB_.js";
+import "./pi-tools.before-tool-call-Cl9Ivz5u.js";
+import "./gateway-Dyc7qEu3.js";
+import "./model-auth-D1amzkLm.js";
+import "./attempt.tool-run-context-C5nkRM5Y.js";
+import { r as resolveToolDisplay, t as formatToolDetail } from "./tool-display-B0WPzVuH.js";
+import "./channel-streaming-BBW2i40H.js";
+import "./logger-DYJ7BvAc.js";
+import "./nodes-utils-CIusEv3-.js";
+import "./sandbox-BgrNfelZ.js";
+import "./context-engine-lifecycle-DAB4GWd5.js";
+import "./result-fallback-classifier-BkI5uV-W.js";
+import "./build-DOEtxYaU.js";
+import { o as buildAgentHookContext } from "./lifecycle-hook-helpers-DsCr5Yp0.js";
+import "./agent-dir-compat-X9XMR4LI.js";
+import "./native-hook-relay-D1fhxt1n.js";
+//#region src/agents/harness/prompt-compaction-hook-helpers.ts
+const log$1 = createSubsystemLogger("agents/harness");
+async function resolveAgentHarnessBeforePromptBuildResult(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("before_prompt_build") && !hookRunner?.hasHooks("before_agent_start")) return {
+		prompt: params.prompt,
+		developerInstructions: params.developerInstructions
+	};
+	const hookCtx = buildAgentHookContext(params.ctx);
+	const promptEvent = {
+		prompt: params.prompt,
+		messages: params.messages
+	};
+	const promptBuildResult = hookRunner.hasHooks("before_prompt_build") ? await hookRunner.runBeforePromptBuild(promptEvent, hookCtx).catch((error) => {
+		log$1.warn(`before_prompt_build hook failed: ${String(error)}`);
+	}) : void 0;
+	const legacyResult = hookRunner.hasHooks("before_agent_start") ? await hookRunner.runBeforeAgentStart(promptEvent, hookCtx).catch((error) => {
+		log$1.warn(`before_agent_start hook (legacy prompt build path) failed: ${String(error)}`);
+	}) : void 0;
+	const systemPrompt = resolvePromptBuildSystemPrompt({
+		developerInstructions: params.developerInstructions,
+		promptBuildResult,
+		legacyResult
+	});
+	return {
+		prompt: joinPresentTextSegments([
+			promptBuildResult?.prependContext,
+			legacyResult?.prependContext,
+			params.prompt
+		]) ?? params.prompt,
+		developerInstructions: joinPresentTextSegments([
+			promptBuildResult?.prependSystemContext,
+			legacyResult?.prependSystemContext,
+			systemPrompt,
+			promptBuildResult?.appendSystemContext,
+			legacyResult?.appendSystemContext
+		]) ?? systemPrompt
+	};
+}
+function resolvePromptBuildSystemPrompt(params) {
+	if (typeof params.promptBuildResult?.systemPrompt === "string") return params.promptBuildResult.systemPrompt;
+	if (typeof params.legacyResult?.systemPrompt === "string") return params.legacyResult.systemPrompt;
+	return params.developerInstructions;
+}
+async function runAgentHarnessBeforeCompactionHook(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("before_compaction")) return;
+	try {
+		await hookRunner.runBeforeCompaction({
+			messageCount: params.messages.length,
+			messages: params.messages,
+			sessionFile: params.sessionFile
+		}, buildAgentHookContext(params.ctx));
+	} catch (error) {
+		log$1.warn(`before_compaction hook failed: ${String(error)}`);
+	}
+}
+async function runAgentHarnessAfterCompactionHook(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("after_compaction")) return;
+	try {
+		await hookRunner.runAfterCompaction({
+			messageCount: params.messages.length,
+			compactedCount: params.compactedCount,
+			sessionFile: params.sessionFile
+		}, buildAgentHookContext(params.ctx));
+	} catch (error) {
+		log$1.warn(`after_compaction hook failed: ${String(error)}`);
+	}
+}
+//#endregion
+//#region src/agents/harness/codex-app-server-extensions.ts
+const log = createSubsystemLogger("agents/harness");
+function createCodexAppServerToolResultExtensionRunner(ctx, factories = listCodexAppServerExtensionFactories()) {
+	const handlers = [];
+	const runtime = { on(event, handler) {
+		if (event === "tool_result") handlers.push(handler);
+	} };
+	const initPromise = (async () => {
+		for (const factory of factories) await factory(runtime);
+	})();
+	return { async applyToolResultExtensions(event) {
+		await initPromise;
+		let current = event.result;
+		for (const handler of handlers) try {
+			const next = await handler({
+				...event,
+				result: current
+			}, ctx);
+			if (next?.result) current = next.result;
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			log.warn(`[codex] tool_result extension failed for ${event.toolName}: ${detail}`);
+		}
+		return current;
+	} };
+}
+//#endregion
+//#region src/plugin-sdk/agent-harness-runtime.ts
+const TOOL_PROGRESS_OUTPUT_MAX_CHARS = 8e3;
+/**
+* @deprecated Active-run queueing is an internal runtime concern. This legacy
+* boolean API only reports immediate queue eligibility and cannot observe async
+* runtime rejection; runtime-owned delivery paths should use acceptance-aware
+* steering instead of public SDK queueing.
+*/
+function queueAgentHarnessMessage(sessionId, text, options) {
+	return queueEmbeddedPiMessageWithOutcome(sessionId, text, options).queued;
+}
+async function loadCodexBundleMcpThreadConfig(params) {
+	const { loadCodexBundleMcpThreadConfig: load } = await import("./codex-mcp-config-DzOPUScO.js");
+	return load(params);
+}
+function inferToolMetaFromArgs(toolName, args, options) {
+	return formatToolDetail(resolveToolDisplay({
+		name: toolName,
+		args,
+		detailMode: options?.detailMode
+	}));
+}
+/**
+* Prepare verbose tool output for user-facing progress messages.
+*/
+function formatToolProgressOutput(output, options) {
+	const trimmed = output.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+	if (!trimmed) return;
+	const redacted = redactToolDetail(trimmed);
+	const maxChars = options?.maxChars ?? 8e3;
+	if (redacted.length <= maxChars) return redacted;
+	return `${truncateUtf16Safe(redacted, maxChars)}\n...(truncated)...`;
+}
+/**
+* Classify terminal harness turns that completed without assistant output that
+* should advance fallback. Deliberate silent replies such as NO_REPLY count as
+* intentional output, while whitespace-only text remains fallback-eligible.
+* This is intentionally SDK-level so plugin harness adapters such as Codex
+* preserve the same DaoCore-owned fallback signals as the built-in PI path
+* without re-implementing terminal-result policy.
+*/
+function classifyAgentHarnessTerminalOutcome(params) {
+	if (!params.turnCompleted || params.promptError !== void 0 && params.promptError !== null || hasVisibleAssistantText(params.assistantTexts)) return;
+	if (params.planText?.trim()) return "planning-only";
+	if (params.reasoningText?.trim()) return "reasoning-only";
+	return "empty";
+}
+function hasVisibleAssistantText(assistantTexts) {
+	return assistantTexts.some((text) => text.trim().length > 0);
+}
+//#endregion
+export { loadCodexBundleMcpThreadConfig as a, resolveAgentHarnessBeforePromptBuildResult as c, inferToolMetaFromArgs as i, runAgentHarnessAfterCompactionHook as l, classifyAgentHarnessTerminalOutcome as n, queueAgentHarnessMessage as o, formatToolProgressOutput as r, createCodexAppServerToolResultExtensionRunner as s, TOOL_PROGRESS_OUTPUT_MAX_CHARS as t, runAgentHarnessBeforeCompactionHook as u };

package/dist/agent-harness-task-runtime-VSFzRIbH.js

@@ -0,0 +1,140 @@
+import { r as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-core-C7o0LP7q.js";
+import "./message-channel-CRza_Xs_.js";
+import { So as AGENT_INTERNAL_EVENT_TYPE_TASK_COMPLETION } from "./protocol-BqIJbb8x.js";
+import { f as listTaskRecords } from "./task-registry-XxKmge32.js";
+import "./runtime-internal-CQ1hy6SS.js";
+import { c as recordTaskRunProgressByRunId, i as createRunningTaskRun, l as setDetachedTaskDeliveryStatusByRunId, o as finalizeTaskRunByRunId } from "./detached-task-runtime-B8jNifvc.js";
+import { n as isInternalAnnounceRequesterSession, o as resolveSubagentCompletionOrigin, r as loadRequesterSessionEntry, t as deliverSubagentAnnouncement } from "./subagent-announce-delivery-M73wDt9b.js";
+import { n as formatAgentInternalEventsForPrompt } from "./internal-events-hTD06P4Z.js";
+import { n as buildAnnounceIdempotencyKey } from "./announce-idempotency-DV6_8Blm.js";
+import { t as assertAgentHarnessTaskRuntimeScope } from "./agent-harness-task-runtime-scope-7M8SSTK6.js";
+import { t as resolveAnnounceOrigin } from "./subagent-announce-origin-CB1tkSD0.js";
+//#region src/plugin-sdk/agent-harness-task-runtime.ts
+const AGENT_HARNESS_COMPLETION_SOURCE_TOOL = "agent_harness_task";
+function createAgentHarnessTaskRuntime(params) {
+	const runtime = params.runtime;
+	const requesterSessionKey = assertAgentHarnessTaskRuntimeScope(params.scope).requesterSessionKey;
+	const taskKind = normalizeOptionalString(params.taskKind);
+	const runIdPrefix = normalizeOptionalString(params.runIdPrefix);
+	const assertRunId = (runId) => assertScopedRunId(runId, runIdPrefix);
+	return {
+		createRunningTaskRun(taskParams) {
+			assertRunId(taskParams.runId);
+			return createRunningTaskRun({
+				...taskParams,
+				runtime,
+				...taskKind ? { taskKind } : {},
+				requesterSessionKey,
+				ownerKey: requesterSessionKey,
+				scopeKind: "session"
+			});
+		},
+		recordTaskRunProgressByRunId(taskParams) {
+			assertRunId(taskParams.runId);
+			return recordTaskRunProgressByRunId({
+				...taskParams,
+				runtime,
+				sessionKey: requesterSessionKey
+			});
+		},
+		finalizeTaskRunByRunId(taskParams) {
+			assertRunId(taskParams.runId);
+			return finalizeTaskRunByRunId({
+				...taskParams,
+				runtime,
+				sessionKey: requesterSessionKey
+			});
+		},
+		setDetachedTaskDeliveryStatusByRunId(taskParams) {
+			assertRunId(taskParams.runId);
+			return setDetachedTaskDeliveryStatusByRunId({
+				...taskParams,
+				runtime,
+				sessionKey: requesterSessionKey
+			});
+		},
+		listTaskRecords() {
+			return listTaskRecords().filter((task) => task.runtime === runtime && (!taskKind || task.taskKind === taskKind) && task.scopeKind === "session" && task.ownerKey === requesterSessionKey && (!runIdPrefix || task.runId?.startsWith(runIdPrefix)));
+		}
+	};
+}
+async function deliverAgentHarnessTaskCompletion(params) {
+	const scope = assertAgentHarnessTaskRuntimeScope(params.scope);
+	const requesterSessionKey = scope.requesterSessionKey;
+	const childSessionKey = params.childSessionKey.trim();
+	const childSessionId = params.childSessionId.trim();
+	const taskLabel = params.taskLabel?.trim() || "Agent harness task";
+	const announceType = params.announceType?.trim() || "Agent harness task";
+	const statusLabel = params.statusLabel?.trim() || params.status;
+	const eventStatus = mapHarnessCompletionStatus(params.status);
+	const requesterIsSubagent = isInternalAnnounceRequesterSession(requesterSessionKey);
+	let directOrigin = scope.requesterOrigin;
+	if (!requesterIsSubagent) {
+		const { entry } = loadRequesterSessionEntry(requesterSessionKey);
+		directOrigin = resolveAnnounceOrigin(entry, scope.requesterOrigin);
+	}
+	const completionDirectOrigin = requesterIsSubagent || !directOrigin ? directOrigin : await resolveSubagentCompletionOrigin({
+		childSessionKey,
+		requesterSessionKey,
+		requesterOrigin: directOrigin,
+		childRunId: childSessionKey,
+		spawnMode: "run",
+		expectsCompletionMessage: true
+	});
+	const internalEvents = [{
+		type: AGENT_INTERNAL_EVENT_TYPE_TASK_COMPLETION,
+		source: "subagent",
+		childSessionKey,
+		childSessionId,
+		announceType,
+		taskLabel,
+		status: eventStatus,
+		statusLabel,
+		result: params.result,
+		replyInstruction: params.replyInstruction?.trim() || "Use the completed harness task result to continue or wrap up the parent task. If this is a channel session, send the visible response with the message tool instead of only writing a transcript final answer."
+	}];
+	const prompt = formatAgentInternalEventsForPrompt(internalEvents);
+	return await deliverSubagentAnnouncement({
+		requesterSessionKey,
+		announceId: params.announceId,
+		triggerMessage: prompt,
+		steerMessage: prompt,
+		internalEvents,
+		summaryLine: taskLabel,
+		requesterSessionOrigin: scope.requesterOrigin,
+		requesterOrigin: completionDirectOrigin ?? directOrigin,
+		completionDirectOrigin: completionDirectOrigin ?? directOrigin,
+		directOrigin,
+		sourceSessionKey: childSessionKey,
+		sourceChannel: INTERNAL_MESSAGE_CHANNEL,
+		sourceTool: AGENT_HARNESS_COMPLETION_SOURCE_TOOL,
+		targetRequesterSessionKey: requesterSessionKey,
+		requesterIsSubagent,
+		expectsCompletionMessage: true,
+		bestEffortDeliver: true,
+		directIdempotencyKey: buildAnnounceIdempotencyKey(params.announceId),
+		signal: params.signal
+	});
+}
+function mapHarnessCompletionStatus(status) {
+	if (status === "succeeded") return "ok";
+	return "error";
+}
+function isDurableAgentHarnessCompletionDelivery(delivery) {
+	if (!delivery.delivered) return false;
+	if (delivery.path === "steered") return true;
+	if (delivery.path !== "direct") return false;
+	const phases = Array.isArray(delivery.phases) ? delivery.phases : void 0;
+	if (!phases) return true;
+	return phases.some((phase) => phase.phase === "direct-primary" && phase.delivered && phase.path === "direct");
+}
+function normalizeOptionalString(value) {
+	return value?.trim() || void 0;
+}
+function assertScopedRunId(runId, runIdPrefix) {
+	const normalized = runId.trim();
+	if (!normalized) throw new Error("Agent harness task runtime requires runId");
+	if (runIdPrefix && !normalized.startsWith(runIdPrefix)) throw new Error("Agent harness task runId is outside the configured scope");
+}
+//#endregion
+export { deliverAgentHarnessTaskCompletion as n, isDurableAgentHarnessCompletionDelivery as r, createAgentHarnessTaskRuntime as t };

package/dist/agent-rg2WmmbX.js

@@ -0,0 +1,3 @@
+import { n as agentCommandFromIngress } from "./agent-command-DeA1YV0L.js";
+import "./agent-CsPtASj4.js";
+export { agentCommandFromIngress };