@pixelzx/genesis 2026.7.8 → 2026.7.9

package/dist/runtime-DFsWYp04.js

@@ -0,0 +1,961 @@
+import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { i as getChildLogger, v as normalizeLogLevel } from "./logger-BRmjL88V.js";
+import { t as createSubsystemLogger } from "./subsystem-CNq69MoE.js";
+import { _ as resolveStateDir } from "./paths-Bv2rGpO9.js";
+import { n as VERSION } from "./version-qod78efn.js";
+import { a as shouldLogVerbose } from "./globals-wYf9_gv5.js";
+import { r as runCommandWithTimeout } from "./exec-BbrLAvgI.js";
+import { a as loadConfig, y as writeConfigFile } from "./io-Cy5vajWd.js";
+import { n as DEFAULT_MODEL, r as DEFAULT_PROVIDER } from "./defaults-Dg3aovOH.js";
+import { u as ensureAgentWorkspace } from "./workspace-CbdFyQfr.js";
+import { b as resolveAgentWorkspaceDir, y as resolveAgentDir } from "./agent-scope-BUYwVohk.js";
+import "./config-DYHZ3jG1.js";
+import "./logging-D96hbuQz.js";
+import { p as resolveThinkingDefault } from "./model-selection-D-mV4REq.js";
+import { i as resolveHumanDelayConfig, n as resolveAgentIdentity, r as resolveEffectiveMessagesConfig } from "./identity-BbTjMz-I.js";
+import { i as resolveSessionFilePath, u as resolveStorePath } from "./paths-CiRFr3OE.js";
+import { i as normalizeDeliveryContext } from "./delivery-context.shared-DnaA0DbE.js";
+import { t as loadSessionStore } from "./store-load-DLkfg3iM.js";
+import { a as updateLastRoute, i as saveSessionStore, n as readSessionUpdatedAt, r as recordSessionMetaFromInbound } from "./store-BtHVDH2Q.js";
+import "./sessions-C1_80mqv.js";
+import { n as onSessionTranscriptUpdate } from "./transcript-events-fSaEyJxo.js";
+import { l as onAgentEvent } from "./agent-events-DxDJre6N.js";
+import { h as mediaKindFromMime, t as detectMime } from "./mime-uYFJ8ocK.js";
+import { a as getImageMetadata, l as resizeToJpeg } from "./image-ops-BKoz9hKm.js";
+import { n as createLazyRuntimeMethodBinder, r as createLazyRuntimeModule, t as createLazyRuntimeMethod } from "./lazy-runtime-B-T6H2Zb.js";
+import { i as enqueueSystemEvent } from "./system-events-DEhWwh94.js";
+import { A as finishFlow, F as requestFlowCancel, L as resumeFlow, O as failFlow, R as setFlowWaiting, T as createManagedTaskFlow, d as listTasksForFlowId } from "./task-registry-CdNs7r4r.js";
+import { n as summarizeTaskRecords } from "./task-registry.summary-BpQCSMFI.js";
+import "./runtime-internal-BgtZ9qQE.js";
+import { c as getFlowTaskSummary, g as resolveTaskFlowForLookupTokenForOwner, h as listTaskFlowsForOwner, m as getTaskFlowByIdForOwner, p as findLatestTaskFlowForOwner, r as cancelFlowByIdForOwner, t as cancelDetachedTaskRunById, u as runTaskInFlowForOwner } from "./task-executor-CNDdWsuX.js";
+import { t as resolveAgentTimeoutMs } from "./timeout-11LJq59k.js";
+import { n as listRuntimeImageGenerationProviders, t as generateImage } from "./runtime-JVOgkIEF.js";
+import { l as saveMediaBuffer } from "./store-Il9HLBFt.js";
+import { n as fetchRemoteMedia } from "./fetch-C_QfeqLM.js";
+import { t as loadWebMedia } from "./web-media-vDmNzapG.js";
+import { n as resolveChannelGroupRequireMention, t as resolveChannelGroupPolicy } from "./group-policy-C6j1iFoy.js";
+import { a as chunkText, c as resolveTextChunkLimit, i as chunkMarkdownTextWithMode, o as chunkTextWithMode, r as chunkMarkdownText, s as resolveChunkMode, t as chunkByNewline } from "./chunk-DNCIrobv.js";
+import { t as loadChannelOutboundAdapter } from "./load-De5y28nW.js";
+import { i as resolveAgentRoute, t as buildAgentSessionKey } from "./resolve-route-DANUDWzO.js";
+import { n as listRuntimeMusicGenerationProviders, t as generateMusic } from "./runtime-CF03hfSQ.js";
+import { a as getTaskByIdForOwner, o as listTasksForRelatedSessionKeyForOwner, r as findLatestTaskForRelatedSessionKeyForOwner, s as resolveTaskForLookupTokenForOwner } from "./task-owner-access-DxjrTxvr.js";
+import { n as listRuntimeVideoGenerationProviders, t as generateVideo } from "./runtime-CYvH_wW3.js";
+import { r as listWebSearchProviders, s as runWebSearch } from "./runtime-rxWAKdda.js";
+import { t as convertMarkdownTables } from "./tables-DhnbAiVH.js";
+import { t as RequestScopedSubagentRuntimeError } from "./error-runtime-DZiTdNNG.js";
+import { n as gatewaySubagentState } from "./gateway-bindings-v2VJDaWI.js";
+import { i as shouldComputeCommandAuthorized, r as isControlCommandMessage, t as hasControlCommand } from "./command-detection-B7TB9nw5.js";
+import { f as shouldHandleTextCommands } from "./commands-registry-B5egnRQ_.js";
+import { a as createReplyDispatcherWithTyping, c as withReplyDispatcher, s as dispatchReplyFromConfig } from "./dispatch-MnxNMsTX.js";
+import { t as finalizeInboundContext } from "./inbound-context-DJVMrgDz.js";
+import { a as resolveEnvelopeFormatOptions, r as formatInboundEnvelope, t as formatAgentEnvelope } from "./envelope-pVilMBD8.js";
+import { n as resolveInboundDebounceMs, t as createInboundDebouncer } from "./inbound-debounce-D1NxHcy4.js";
+import { i as matchesMentionWithExplicit, n as buildMentionRegexes, r as matchesMentionPatterns } from "./mentions-DLBObkkw.js";
+import { t as dispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher-W0BQ6JBa.js";
+import { n as shouldAckReaction, t as removeAckReactionAfterReply } from "./ack-reactions-7zzbqxYR.js";
+import { t as resolveCommandAuthorizedFromAuthorizers } from "./command-gating-DK3daq-x.js";
+import { n as resolveInboundMentionDecision, t as implicitMentionKindWhen } from "./mention-gating-DK2KrT0w.js";
+import { n as setChannelConversationBindingMaxAgeBySessionKey, t as setChannelConversationBindingIdleTimeoutBySessionKey } from "./conversation-bindings-DybdXW_4.js";
+import { t as recordInboundSession } from "./session-BThNEh5u.js";
+import { t as resolveMarkdownTableMode } from "./markdown-tables-Cc3ku3eW.js";
+import { n as recordChannelActivity, t as getChannelActivity } from "./channel-activity-FZ93teQL.js";
+import { t as buildPairingReply } from "./pairing-messages-B7FKW7RH.js";
+import { a as readChannelAllowFromStore, d as upsertChannelPairingRequest } from "./pairing-store-T3f7yIx-.js";
+import { r as isVoiceCompatibleAudio } from "./audio-BHTUgu36.js";
+//#region src/plugins/runtime/runtime-cache.ts
+function defineCachedValue(target, key, create) {
+	let cached;
+	let ready = false;
+	Object.defineProperty(target, key, {
+		configurable: true,
+		enumerable: true,
+		get() {
+			if (!ready) {
+				cached = create();
+				ready = true;
+			}
+			return cached;
+		}
+	});
+}
+//#endregion
+//#region src/plugins/runtime/runtime-agent.ts
+const loadEmbeddedPiRuntime = createLazyRuntimeModule(() => import("./runtime-embedded-pi.runtime-DhHN3TPm.js"));
+function createRuntimeAgent() {
+	const agentRuntime = {
+		defaults: {
+			model: DEFAULT_MODEL,
+			provider: DEFAULT_PROVIDER
+		},
+		resolveAgentDir,
+		resolveAgentWorkspaceDir,
+		resolveAgentIdentity,
+		resolveThinkingDefault,
+		resolveAgentTimeoutMs,
+		ensureAgentWorkspace
+	};
+	defineCachedValue(agentRuntime, "runEmbeddedAgent", () => createLazyRuntimeMethod(loadEmbeddedPiRuntime, (runtime) => runtime.runEmbeddedAgent));
+	defineCachedValue(agentRuntime, "runEmbeddedPiAgent", () => createLazyRuntimeMethod(loadEmbeddedPiRuntime, (runtime) => runtime.runEmbeddedPiAgent));
+	defineCachedValue(agentRuntime, "session", () => ({
+		resolveStorePath,
+		loadSessionStore,
+		saveSessionStore,
+		resolveSessionFilePath
+	}));
+	return agentRuntime;
+}
+//#endregion
+//#region src/plugins/runtime/runtime-channel.ts
+const log = createSubsystemLogger("plugins/runtime-channel");
+function normalizeRuntimeContextString(value) {
+	return normalizeOptionalString(value) ?? "";
+}
+function normalizeRuntimeContextKey(params) {
+	const channelId = normalizeRuntimeContextString(params.channelId);
+	const capability = normalizeRuntimeContextString(params.capability);
+	const accountId = normalizeRuntimeContextString(params.accountId);
+	if (!channelId || !capability) return null;
+	return {
+		mapKey: `${channelId}\u0000${accountId}\u0000${capability}`,
+		normalizedKey: {
+			channelId,
+			capability,
+			...accountId ? { accountId } : {}
+		}
+	};
+}
+function doesRuntimeContextWatcherMatch(params) {
+	if (params.watcher.channelId && params.watcher.channelId !== params.event.key.channelId) return false;
+	if (params.watcher.accountId !== void 0 && params.watcher.accountId !== (params.event.key.accountId ?? "")) return false;
+	if (params.watcher.capability && params.watcher.capability !== params.event.key.capability) return false;
+	return true;
+}
+function createRuntimeChannel() {
+	const runtimeContexts = /* @__PURE__ */ new Map();
+	const runtimeContextWatchers = /* @__PURE__ */ new Set();
+	const emitRuntimeContextEvent = (event) => {
+		for (const watcher of runtimeContextWatchers) {
+			if (!doesRuntimeContextWatcherMatch({
+				watcher: watcher.filter,
+				event
+			})) continue;
+			try {
+				watcher.onEvent(event);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				log.error(`runtime context watcher failed during ${event.type} channel=${event.key.channelId} capability=${event.key.capability}` + (event.key.accountId ? ` account=${event.key.accountId}` : "") + `: ${message}`);
+			}
+		}
+	};
+	return {
+		text: {
+			chunkByNewline,
+			chunkMarkdownText,
+			chunkMarkdownTextWithMode,
+			chunkText,
+			chunkTextWithMode,
+			resolveChunkMode,
+			resolveTextChunkLimit,
+			hasControlCommand,
+			resolveMarkdownTableMode,
+			convertMarkdownTables
+		},
+		reply: {
+			dispatchReplyWithBufferedBlockDispatcher,
+			createReplyDispatcherWithTyping,
+			resolveEffectiveMessagesConfig,
+			resolveHumanDelayConfig,
+			dispatchReplyFromConfig,
+			withReplyDispatcher,
+			finalizeInboundContext,
+			formatAgentEnvelope,
+			formatInboundEnvelope,
+			resolveEnvelopeFormatOptions
+		},
+		routing: {
+			buildAgentSessionKey,
+			resolveAgentRoute
+		},
+		pairing: {
+			buildPairingReply,
+			readAllowFromStore: ({ channel, accountId, env }) => readChannelAllowFromStore(channel, env, accountId),
+			upsertPairingRequest: ({ channel, id, accountId, meta, env, pairingAdapter }) => upsertChannelPairingRequest({
+				channel,
+				id,
+				accountId,
+				meta,
+				env,
+				pairingAdapter
+			})
+		},
+		media: {
+			fetchRemoteMedia,
+			saveMediaBuffer
+		},
+		activity: {
+			record: recordChannelActivity,
+			get: getChannelActivity
+		},
+		session: {
+			resolveStorePath,
+			readSessionUpdatedAt,
+			recordSessionMetaFromInbound,
+			recordInboundSession,
+			updateLastRoute
+		},
+		mentions: {
+			buildMentionRegexes,
+			matchesMentionPatterns,
+			matchesMentionWithExplicit,
+			implicitMentionKindWhen,
+			resolveInboundMentionDecision
+		},
+		reactions: {
+			shouldAckReaction,
+			removeAckReactionAfterReply
+		},
+		groups: {
+			resolveGroupPolicy: resolveChannelGroupPolicy,
+			resolveRequireMention: resolveChannelGroupRequireMention
+		},
+		debounce: {
+			createInboundDebouncer,
+			resolveInboundDebounceMs
+		},
+		commands: {
+			resolveCommandAuthorizedFromAuthorizers,
+			isControlCommandMessage,
+			shouldComputeCommandAuthorized,
+			shouldHandleTextCommands
+		},
+		outbound: { loadAdapter: loadChannelOutboundAdapter },
+		threadBindings: {
+			setIdleTimeoutBySessionKey: ({ channelId, targetSessionKey, accountId, idleTimeoutMs }) => setChannelConversationBindingIdleTimeoutBySessionKey({
+				channelId,
+				targetSessionKey,
+				accountId,
+				idleTimeoutMs
+			}),
+			setMaxAgeBySessionKey: ({ channelId, targetSessionKey, accountId, maxAgeMs }) => setChannelConversationBindingMaxAgeBySessionKey({
+				channelId,
+				targetSessionKey,
+				accountId,
+				maxAgeMs
+			})
+		},
+		runtimeContexts: {
+			register: (params) => {
+				const normalized = normalizeRuntimeContextKey(params);
+				if (!normalized) return { dispose: () => {} };
+				if (params.abortSignal?.aborted) return { dispose: () => {} };
+				const token = Symbol(normalized.mapKey);
+				let disposed = false;
+				const dispose = () => {
+					if (disposed) return;
+					disposed = true;
+					const current = runtimeContexts.get(normalized.mapKey);
+					if (!current || current.token !== token) return;
+					runtimeContexts.delete(normalized.mapKey);
+					emitRuntimeContextEvent({
+						type: "unregistered",
+						key: normalized.normalizedKey
+					});
+				};
+				params.abortSignal?.addEventListener("abort", dispose, { once: true });
+				if (params.abortSignal?.aborted) {
+					dispose();
+					return { dispose };
+				}
+				runtimeContexts.set(normalized.mapKey, {
+					token,
+					context: params.context,
+					normalizedKey: normalized.normalizedKey
+				});
+				if (disposed) return { dispose };
+				emitRuntimeContextEvent({
+					type: "registered",
+					key: normalized.normalizedKey,
+					context: params.context
+				});
+				return { dispose };
+			},
+			get: (params) => {
+				const normalized = normalizeRuntimeContextKey(params);
+				if (!normalized) return;
+				return runtimeContexts.get(normalized.mapKey)?.context;
+			},
+			watch: (params) => {
+				const watcher = {
+					filter: {
+						...params.channelId?.trim() ? { channelId: params.channelId.trim() } : {},
+						...params.accountId != null ? { accountId: params.accountId.trim() } : {},
+						...params.capability?.trim() ? { capability: params.capability.trim() } : {}
+					},
+					onEvent: params.onEvent
+				};
+				runtimeContextWatchers.add(watcher);
+				return () => {
+					runtimeContextWatchers.delete(watcher);
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/plugins/runtime/runtime-config.ts
+function createRuntimeConfig() {
+	return {
+		loadConfig,
+		writeConfigFile
+	};
+}
+//#endregion
+//#region src/plugins/runtime/runtime-events.ts
+function createRuntimeEvents() {
+	return {
+		onAgentEvent,
+		onSessionTranscriptUpdate
+	};
+}
+//#endregion
+//#region src/plugins/runtime/runtime-logging.ts
+function createRuntimeLogging() {
+	return {
+		shouldLogVerbose,
+		getChildLogger: (bindings, opts) => {
+			const logger = getChildLogger(bindings, { level: opts?.level ? normalizeLogLevel(opts.level) : void 0 });
+			return {
+				debug: (message) => logger.debug?.(message),
+				info: (message) => logger.info(message),
+				warn: (message) => logger.warn(message),
+				error: (message) => logger.error(message)
+			};
+		}
+	};
+}
+//#endregion
+//#region src/plugins/runtime/runtime-media.ts
+function createRuntimeMedia() {
+	return {
+		loadWebMedia,
+		detectMime,
+		mediaKindFromMime,
+		isVoiceCompatibleAudio,
+		getImageMetadata,
+		resizeToJpeg
+	};
+}
+//#endregion
+//#region src/plugins/runtime/native-deps.ts
+function formatNativeDependencyHint(params) {
+	const manager = params.manager ?? "pnpm";
+	const rebuildCommand = params.rebuildCommand ?? (manager === "npm" ? `npm rebuild ${params.packageName}` : manager === "yarn" ? `yarn rebuild ${params.packageName}` : `pnpm rebuild ${params.packageName}`);
+	const steps = [
+		params.approveBuildsCommand ?? (manager === "pnpm" ? `pnpm approve-builds (select ${params.packageName})` : void 0),
+		rebuildCommand,
+		params.downloadCommand
+	].filter((step) => Boolean(step));
+	if (steps.length === 0) return `Install ${params.packageName} and rebuild its native module.`;
+	return `Install ${params.packageName} and rebuild its native module (${steps.join("; ")}).`;
+}
+//#endregion
+//#region src/plugins/runtime/runtime-system.ts
+function createRuntimeSystem() {
+	return {
+		enqueueSystemEvent,
+		runCommandWithTimeout,
+		formatNativeDependencyHint
+	};
+}
+//#endregion
+//#region src/plugins/runtime/runtime-taskflow.ts
+function assertSessionKey$1(sessionKey, errorMessage) {
+	const normalized = sessionKey?.trim();
+	if (!normalized) throw new Error(errorMessage);
+	return normalized;
+}
+function asManagedTaskFlowRecord(flow) {
+	if (!flow || flow.syncMode !== "managed" || !flow.controllerId) return;
+	return flow;
+}
+function resolveManagedFlowForOwner(params) {
+	const flow = getTaskFlowByIdForOwner({
+		flowId: params.flowId,
+		callerOwnerKey: params.ownerKey
+	});
+	if (!flow) return {
+		ok: false,
+		code: "not_found"
+	};
+	const managed = asManagedTaskFlowRecord(flow);
+	if (!managed) return {
+		ok: false,
+		code: "not_managed",
+		current: flow
+	};
+	return {
+		ok: true,
+		flow: managed
+	};
+}
+function mapFlowUpdateResult(result) {
+	if (result.applied) {
+		const managed = asManagedTaskFlowRecord(result.flow);
+		if (!managed) return {
+			applied: false,
+			code: "not_managed",
+			current: result.flow
+		};
+		return {
+			applied: true,
+			flow: managed
+		};
+	}
+	return {
+		applied: false,
+		code: result.reason,
+		...result.current ? { current: result.current } : {}
+	};
+}
+function createBoundTaskFlowRuntime(params) {
+	const ownerKey = assertSessionKey$1(params.sessionKey, "TaskFlow runtime requires a bound sessionKey.");
+	const requesterOrigin = params.requesterOrigin ? normalizeDeliveryContext(params.requesterOrigin) : void 0;
+	return {
+		sessionKey: ownerKey,
+		...requesterOrigin ? { requesterOrigin } : {},
+		createManaged: (input) => createManagedTaskFlow({
+			ownerKey,
+			controllerId: input.controllerId,
+			requesterOrigin,
+			status: input.status,
+			notifyPolicy: input.notifyPolicy,
+			goal: input.goal,
+			currentStep: input.currentStep,
+			stateJson: input.stateJson,
+			waitJson: input.waitJson,
+			cancelRequestedAt: input.cancelRequestedAt,
+			createdAt: input.createdAt,
+			updatedAt: input.updatedAt,
+			endedAt: input.endedAt
+		}),
+		get: (flowId) => getTaskFlowByIdForOwner({
+			flowId,
+			callerOwnerKey: ownerKey
+		}),
+		list: () => listTaskFlowsForOwner({ callerOwnerKey: ownerKey }),
+		findLatest: () => findLatestTaskFlowForOwner({ callerOwnerKey: ownerKey }),
+		resolve: (token) => resolveTaskFlowForLookupTokenForOwner({
+			token,
+			callerOwnerKey: ownerKey
+		}),
+		getTaskSummary: (flowId) => {
+			const flow = getTaskFlowByIdForOwner({
+				flowId,
+				callerOwnerKey: ownerKey
+			});
+			return flow ? getFlowTaskSummary(flow.flowId) : void 0;
+		},
+		setWaiting: (input) => {
+			const flow = resolveManagedFlowForOwner({
+				flowId: input.flowId,
+				ownerKey
+			});
+			if (!flow.ok) return {
+				applied: false,
+				code: flow.code,
+				...flow.current ? { current: flow.current } : {}
+			};
+			return mapFlowUpdateResult(setFlowWaiting({
+				flowId: flow.flow.flowId,
+				expectedRevision: input.expectedRevision,
+				currentStep: input.currentStep,
+				stateJson: input.stateJson,
+				waitJson: input.waitJson,
+				blockedTaskId: input.blockedTaskId,
+				blockedSummary: input.blockedSummary,
+				updatedAt: input.updatedAt
+			}));
+		},
+		resume: (input) => {
+			const flow = resolveManagedFlowForOwner({
+				flowId: input.flowId,
+				ownerKey
+			});
+			if (!flow.ok) return {
+				applied: false,
+				code: flow.code,
+				...flow.current ? { current: flow.current } : {}
+			};
+			return mapFlowUpdateResult(resumeFlow({
+				flowId: flow.flow.flowId,
+				expectedRevision: input.expectedRevision,
+				status: input.status,
+				currentStep: input.currentStep,
+				stateJson: input.stateJson,
+				updatedAt: input.updatedAt
+			}));
+		},
+		finish: (input) => {
+			const flow = resolveManagedFlowForOwner({
+				flowId: input.flowId,
+				ownerKey
+			});
+			if (!flow.ok) return {
+				applied: false,
+				code: flow.code,
+				...flow.current ? { current: flow.current } : {}
+			};
+			return mapFlowUpdateResult(finishFlow({
+				flowId: flow.flow.flowId,
+				expectedRevision: input.expectedRevision,
+				stateJson: input.stateJson,
+				updatedAt: input.updatedAt,
+				endedAt: input.endedAt
+			}));
+		},
+		fail: (input) => {
+			const flow = resolveManagedFlowForOwner({
+				flowId: input.flowId,
+				ownerKey
+			});
+			if (!flow.ok) return {
+				applied: false,
+				code: flow.code,
+				...flow.current ? { current: flow.current } : {}
+			};
+			return mapFlowUpdateResult(failFlow({
+				flowId: flow.flow.flowId,
+				expectedRevision: input.expectedRevision,
+				stateJson: input.stateJson,
+				blockedTaskId: input.blockedTaskId,
+				blockedSummary: input.blockedSummary,
+				updatedAt: input.updatedAt,
+				endedAt: input.endedAt
+			}));
+		},
+		requestCancel: (input) => {
+			const flow = resolveManagedFlowForOwner({
+				flowId: input.flowId,
+				ownerKey
+			});
+			if (!flow.ok) return {
+				applied: false,
+				code: flow.code,
+				...flow.current ? { current: flow.current } : {}
+			};
+			return mapFlowUpdateResult(requestFlowCancel({
+				flowId: flow.flow.flowId,
+				expectedRevision: input.expectedRevision,
+				cancelRequestedAt: input.cancelRequestedAt
+			}));
+		},
+		cancel: ({ flowId, cfg }) => cancelFlowByIdForOwner({
+			cfg,
+			flowId,
+			callerOwnerKey: ownerKey
+		}),
+		runTask: (input) => {
+			const created = runTaskInFlowForOwner({
+				flowId: input.flowId,
+				callerOwnerKey: ownerKey,
+				runtime: input.runtime,
+				sourceId: input.sourceId,
+				childSessionKey: input.childSessionKey,
+				parentTaskId: input.parentTaskId,
+				agentId: input.agentId,
+				runId: input.runId,
+				label: input.label,
+				task: input.task,
+				preferMetadata: input.preferMetadata,
+				notifyPolicy: input.notifyPolicy,
+				deliveryStatus: input.deliveryStatus,
+				status: input.status,
+				startedAt: input.startedAt,
+				lastEventAt: input.lastEventAt,
+				progressSummary: input.progressSummary
+			});
+			if (!created.created) return {
+				created: false,
+				found: created.found,
+				reason: created.reason ?? "Task was not created.",
+				...created.flow ? { flow: created.flow } : {}
+			};
+			const managed = asManagedTaskFlowRecord(created.flow);
+			if (!managed) return {
+				created: false,
+				found: true,
+				reason: "TaskFlow does not accept managed child tasks.",
+				flow: created.flow
+			};
+			if (!created.task) return {
+				created: false,
+				found: true,
+				reason: "Task was not created.",
+				flow: created.flow
+			};
+			return {
+				created: true,
+				flow: managed,
+				task: created.task
+			};
+		}
+	};
+}
+function createRuntimeTaskFlow() {
+	return {
+		bindSession: (params) => createBoundTaskFlowRuntime({
+			sessionKey: params.sessionKey,
+			requesterOrigin: params.requesterOrigin
+		}),
+		fromToolContext: (ctx) => createBoundTaskFlowRuntime({
+			sessionKey: assertSessionKey$1(ctx.sessionKey, "TaskFlow runtime requires tool context with a sessionKey."),
+			requesterOrigin: ctx.deliveryContext
+		})
+	};
+}
+//#endregion
+//#region src/tasks/task-domain-views.ts
+function mapTaskRunAggregateSummary(summary) {
+	return {
+		total: summary.total,
+		active: summary.active,
+		terminal: summary.terminal,
+		failures: summary.failures,
+		byStatus: { ...summary.byStatus },
+		byRuntime: { ...summary.byRuntime }
+	};
+}
+function mapTaskRunView(task) {
+	return {
+		id: task.taskId,
+		runtime: task.runtime,
+		...task.sourceId ? { sourceId: task.sourceId } : {},
+		sessionKey: task.requesterSessionKey,
+		ownerKey: task.ownerKey,
+		scope: task.scopeKind,
+		...task.childSessionKey ? { childSessionKey: task.childSessionKey } : {},
+		...task.parentFlowId ? { flowId: task.parentFlowId } : {},
+		...task.parentTaskId ? { parentTaskId: task.parentTaskId } : {},
+		...task.agentId ? { agentId: task.agentId } : {},
+		...task.runId ? { runId: task.runId } : {},
+		...task.label ? { label: task.label } : {},
+		title: task.task,
+		status: task.status,
+		deliveryStatus: task.deliveryStatus,
+		notifyPolicy: task.notifyPolicy,
+		createdAt: task.createdAt,
+		...task.startedAt !== void 0 ? { startedAt: task.startedAt } : {},
+		...task.endedAt !== void 0 ? { endedAt: task.endedAt } : {},
+		...task.lastEventAt !== void 0 ? { lastEventAt: task.lastEventAt } : {},
+		...task.cleanupAfter !== void 0 ? { cleanupAfter: task.cleanupAfter } : {},
+		...task.error ? { error: task.error } : {},
+		...task.progressSummary ? { progressSummary: task.progressSummary } : {},
+		...task.terminalSummary ? { terminalSummary: task.terminalSummary } : {},
+		...task.terminalOutcome ? { terminalOutcome: task.terminalOutcome } : {}
+	};
+}
+function mapTaskRunDetail(task) {
+	return mapTaskRunView(task);
+}
+function mapTaskFlowView(flow) {
+	return {
+		id: flow.flowId,
+		ownerKey: flow.ownerKey,
+		...flow.requesterOrigin ? { requesterOrigin: { ...flow.requesterOrigin } } : {},
+		status: flow.status,
+		notifyPolicy: flow.notifyPolicy,
+		goal: flow.goal,
+		...flow.currentStep ? { currentStep: flow.currentStep } : {},
+		...flow.cancelRequestedAt !== void 0 ? { cancelRequestedAt: flow.cancelRequestedAt } : {},
+		createdAt: flow.createdAt,
+		updatedAt: flow.updatedAt,
+		...flow.endedAt !== void 0 ? { endedAt: flow.endedAt } : {}
+	};
+}
+function mapTaskFlowDetail(params) {
+	const summary = params.summary ?? summarizeTaskRecords(params.tasks);
+	return {
+		...mapTaskFlowView(params.flow),
+		...params.flow.stateJson !== void 0 ? { state: params.flow.stateJson } : {},
+		...params.flow.waitJson !== void 0 ? { wait: params.flow.waitJson } : {},
+		...params.flow.blockedTaskId || params.flow.blockedSummary ? { blocked: {
+			...params.flow.blockedTaskId ? { taskId: params.flow.blockedTaskId } : {},
+			...params.flow.blockedSummary ? { summary: params.flow.blockedSummary } : {}
+		} } : {},
+		tasks: params.tasks.map((task) => mapTaskRunView(task)),
+		taskSummary: mapTaskRunAggregateSummary(summary)
+	};
+}
+//#endregion
+//#region src/plugins/runtime/runtime-tasks.ts
+function assertSessionKey(sessionKey, errorMessage) {
+	const normalized = sessionKey?.trim();
+	if (!normalized) throw new Error(errorMessage);
+	return normalized;
+}
+function mapCancelledTaskResult(result) {
+	return {
+		found: result.found,
+		cancelled: result.cancelled,
+		...result.reason ? { reason: result.reason } : {},
+		...result.task ? { task: mapTaskRunDetail(result.task) } : {}
+	};
+}
+function createBoundTaskRunsRuntime(params) {
+	const ownerKey = assertSessionKey(params.sessionKey, "Tasks runtime requires a bound sessionKey.");
+	const requesterOrigin = params.requesterOrigin ? normalizeDeliveryContext(params.requesterOrigin) : void 0;
+	return {
+		sessionKey: ownerKey,
+		...requesterOrigin ? { requesterOrigin } : {},
+		get: (taskId) => {
+			const task = getTaskByIdForOwner({
+				taskId,
+				callerOwnerKey: ownerKey
+			});
+			return task ? mapTaskRunDetail(task) : void 0;
+		},
+		list: () => listTasksForRelatedSessionKeyForOwner({
+			relatedSessionKey: ownerKey,
+			callerOwnerKey: ownerKey
+		}).map((task) => mapTaskRunView(task)),
+		findLatest: () => {
+			const task = findLatestTaskForRelatedSessionKeyForOwner({
+				relatedSessionKey: ownerKey,
+				callerOwnerKey: ownerKey
+			});
+			return task ? mapTaskRunDetail(task) : void 0;
+		},
+		resolve: (token) => {
+			const task = resolveTaskForLookupTokenForOwner({
+				token,
+				callerOwnerKey: ownerKey
+			});
+			return task ? mapTaskRunDetail(task) : void 0;
+		},
+		cancel: async ({ taskId, cfg }) => {
+			const task = getTaskByIdForOwner({
+				taskId,
+				callerOwnerKey: ownerKey
+			});
+			if (!task) return {
+				found: false,
+				cancelled: false,
+				reason: "Task not found."
+			};
+			return mapCancelledTaskResult(await cancelDetachedTaskRunById({
+				cfg,
+				taskId: task.taskId
+			}));
+		}
+	};
+}
+function createBoundTaskFlowsRuntime(params) {
+	const ownerKey = assertSessionKey(params.sessionKey, "TaskFlow runtime requires a bound sessionKey.");
+	const requesterOrigin = params.requesterOrigin ? normalizeDeliveryContext(params.requesterOrigin) : void 0;
+	const getDetail = (flowId) => {
+		const flow = getTaskFlowByIdForOwner({
+			flowId,
+			callerOwnerKey: ownerKey
+		});
+		if (!flow) return;
+		return mapTaskFlowDetail({
+			flow,
+			tasks: listTasksForFlowId(flow.flowId),
+			summary: getFlowTaskSummary(flow.flowId)
+		});
+	};
+	return {
+		sessionKey: ownerKey,
+		...requesterOrigin ? { requesterOrigin } : {},
+		get: (flowId) => getDetail(flowId),
+		list: () => listTaskFlowsForOwner({ callerOwnerKey: ownerKey }).map((flow) => mapTaskFlowView(flow)),
+		findLatest: () => {
+			const flow = findLatestTaskFlowForOwner({ callerOwnerKey: ownerKey });
+			return flow ? getDetail(flow.flowId) : void 0;
+		},
+		resolve: (token) => {
+			const flow = resolveTaskFlowForLookupTokenForOwner({
+				token,
+				callerOwnerKey: ownerKey
+			});
+			return flow ? getDetail(flow.flowId) : void 0;
+		},
+		getTaskSummary: (flowId) => {
+			const flow = getTaskFlowByIdForOwner({
+				flowId,
+				callerOwnerKey: ownerKey
+			});
+			return flow ? mapTaskRunAggregateSummary(getFlowTaskSummary(flow.flowId)) : void 0;
+		}
+	};
+}
+function createRuntimeTaskRuns() {
+	return {
+		bindSession: (params) => createBoundTaskRunsRuntime({
+			sessionKey: params.sessionKey,
+			requesterOrigin: params.requesterOrigin
+		}),
+		fromToolContext: (ctx) => createBoundTaskRunsRuntime({
+			sessionKey: assertSessionKey(ctx.sessionKey, "Tasks runtime requires tool context with a sessionKey."),
+			requesterOrigin: ctx.deliveryContext
+		})
+	};
+}
+function createRuntimeTaskFlows() {
+	return {
+		bindSession: (params) => createBoundTaskFlowsRuntime({
+			sessionKey: params.sessionKey,
+			requesterOrigin: params.requesterOrigin
+		}),
+		fromToolContext: (ctx) => createBoundTaskFlowsRuntime({
+			sessionKey: assertSessionKey(ctx.sessionKey, "TaskFlow runtime requires tool context with a sessionKey."),
+			requesterOrigin: ctx.deliveryContext
+		})
+	};
+}
+function createRuntimeTasks(params) {
+	return {
+		runs: createRuntimeTaskRuns(),
+		flows: createRuntimeTaskFlows(),
+		flow: params.legacyTaskFlow
+	};
+}
+//#endregion
+//#region src/plugins/runtime/index.ts
+const loadTtsRuntime = createLazyRuntimeModule(() => import("./tts-BNUOZoEX.js"));
+const loadMediaUnderstandingRuntime = createLazyRuntimeModule(() => import("./runtime-DFBduVee.js"));
+const loadModelAuthRuntime = createLazyRuntimeModule(() => import("./runtime-model-auth.runtime-DmrrI2hP.js"));
+function createRuntimeTts() {
+	const bindTtsRuntime = createLazyRuntimeMethodBinder(loadTtsRuntime);
+	return {
+		textToSpeech: bindTtsRuntime((runtime) => runtime.textToSpeech),
+		textToSpeechTelephony: bindTtsRuntime((runtime) => runtime.textToSpeechTelephony),
+		listVoices: bindTtsRuntime((runtime) => runtime.listSpeechVoices)
+	};
+}
+function createRuntimeMediaUnderstandingFacade() {
+	const bindMediaUnderstandingRuntime = createLazyRuntimeMethodBinder(loadMediaUnderstandingRuntime);
+	return {
+		runFile: bindMediaUnderstandingRuntime((runtime) => runtime.runMediaUnderstandingFile),
+		describeImageFile: bindMediaUnderstandingRuntime((runtime) => runtime.describeImageFile),
+		describeImageFileWithModel: bindMediaUnderstandingRuntime((runtime) => runtime.describeImageFileWithModel),
+		describeVideoFile: bindMediaUnderstandingRuntime((runtime) => runtime.describeVideoFile),
+		transcribeAudioFile: bindMediaUnderstandingRuntime((runtime) => runtime.transcribeAudioFile)
+	};
+}
+function createRuntimeImageGeneration() {
+	return {
+		generate: (params) => generateImage(params),
+		listProviders: (params) => listRuntimeImageGenerationProviders(params)
+	};
+}
+function createRuntimeVideoGeneration() {
+	return {
+		generate: (params) => generateVideo(params),
+		listProviders: (params) => listRuntimeVideoGenerationProviders(params)
+	};
+}
+function createRuntimeMusicGeneration() {
+	return {
+		generate: (params) => generateMusic(params),
+		listProviders: (params) => listRuntimeMusicGenerationProviders(params)
+	};
+}
+function createRuntimeModelAuth() {
+	const getApiKeyForModel = createLazyRuntimeMethod(loadModelAuthRuntime, (runtime) => runtime.getApiKeyForModel);
+	const getRuntimeAuthForModel = createLazyRuntimeMethod(loadModelAuthRuntime, (runtime) => runtime.getRuntimeAuthForModel);
+	const resolveApiKeyForProvider = createLazyRuntimeMethod(loadModelAuthRuntime, (runtime) => runtime.resolveApiKeyForProvider);
+	return {
+		getApiKeyForModel: (params) => getApiKeyForModel({
+			model: params.model,
+			cfg: params.cfg
+		}),
+		getRuntimeAuthForModel: (params) => getRuntimeAuthForModel({
+			model: params.model,
+			cfg: params.cfg,
+			workspaceDir: params.workspaceDir
+		}),
+		resolveApiKeyForProvider: (params) => resolveApiKeyForProvider({
+			provider: params.provider,
+			cfg: params.cfg
+		})
+	};
+}
+function createUnavailableSubagentRuntime() {
+	const unavailable = () => {
+		throw new RequestScopedSubagentRuntimeError();
+	};
+	return {
+		run: unavailable,
+		waitForRun: unavailable,
+		getSessionMessages: unavailable,
+		getSession: unavailable,
+		deleteSession: unavailable
+	};
+}
+/**
+* Create a late-binding subagent that resolves to:
+* 1. An explicitly provided subagent (from runtimeOptions), OR
+* 2. The process-global gateway subagent when the caller explicitly opts in, OR
+* 3. The unavailable fallback (throws with a clear error message).
+*/
+function createLateBindingSubagent(explicit, allowGatewaySubagentBinding = false) {
+	if (explicit) return explicit;
+	const unavailable = createUnavailableSubagentRuntime();
+	if (!allowGatewaySubagentBinding) return unavailable;
+	return new Proxy(unavailable, { get(_target, prop, _receiver) {
+		const resolved = gatewaySubagentState.subagent ?? unavailable;
+		return Reflect.get(resolved, prop, resolved);
+	} });
+}
+function createUnavailableNodesRuntime() {
+	const unavailable = () => {
+		throw new Error("Plugin node runtime is only available inside the Gateway.");
+	};
+	return {
+		list: unavailable,
+		invoke: unavailable
+	};
+}
+function createLateBindingNodes(allowGatewayBinding = false) {
+	const unavailable = createUnavailableNodesRuntime();
+	if (!allowGatewayBinding) return unavailable;
+	return new Proxy(unavailable, { get(_target, prop, _receiver) {
+		const resolved = gatewaySubagentState.nodes ?? unavailable;
+		return Reflect.get(resolved, prop, resolved);
+	} });
+}
+function createPluginRuntime(_options = {}) {
+	const mediaUnderstanding = createRuntimeMediaUnderstandingFacade();
+	const taskFlow = createRuntimeTaskFlow();
+	const tasks = createRuntimeTasks({ legacyTaskFlow: taskFlow });
+	const runtime = {
+		version: VERSION,
+		config: createRuntimeConfig(),
+		agent: createRuntimeAgent(),
+		subagent: createLateBindingSubagent(_options.subagent, _options.allowGatewaySubagentBinding === true),
+		nodes: _options.nodes ?? createLateBindingNodes(_options.allowGatewaySubagentBinding === true),
+		system: createRuntimeSystem(),
+		media: createRuntimeMedia(),
+		webSearch: {
+			listProviders: listWebSearchProviders,
+			search: runWebSearch
+		},
+		channel: createRuntimeChannel(),
+		events: createRuntimeEvents(),
+		logging: createRuntimeLogging(),
+		state: { resolveStateDir },
+		tasks,
+		taskFlow
+	};
+	defineCachedValue(runtime, "tts", createRuntimeTts);
+	defineCachedValue(runtime, "mediaUnderstanding", () => mediaUnderstanding);
+	defineCachedValue(runtime, "stt", () => ({ transcribeAudioFile: mediaUnderstanding.transcribeAudioFile }));
+	defineCachedValue(runtime, "modelAuth", createRuntimeModelAuth);
+	defineCachedValue(runtime, "imageGeneration", createRuntimeImageGeneration);
+	defineCachedValue(runtime, "videoGeneration", createRuntimeVideoGeneration);
+	defineCachedValue(runtime, "musicGeneration", createRuntimeMusicGeneration);
+	return runtime;
+}
+//#endregion
+export { createPluginRuntime as t };