@pixelzx/genesis 2026.5.5-2 → 2026.5.5-3

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

@@ -0,0 +1,144 @@
+import { i as redactToolDetail } from "./redact-Bl2deF7j.js";
+import "./errors-Jbvi20TW.js";
+import { b as truncateUtf16Safe } from "./utils-DaGfogP-.js";
+import { t as createSubsystemLogger } from "./subsystem-DTMy5YmO.js";
+import "./version-BoqlEm3e.js";
+import "./agent-scope-CDjZLqNk.js";
+import { o as listCodexAppServerExtensionFactories } from "./loader-D3VsvOWx.js";
+import { s as joinPresentTextSegments, t as getGlobalHookRunner } from "./hook-runner-global-DA2gGjRr.js";
+import "./agent-paths-C8JZWFei.js";
+import "./session-write-lock-_RrZZt0E.js";
+import "./model-auth-CDl8OFEJ.js";
+import "./tool-schema-runtime-BCx7p6Ey.js";
+import "./logger-E_fmQU2g.js";
+import { r as resolveToolDisplay, t as formatToolDetail } from "./tool-display-BWPMZ4Xm.js";
+import "./attempt.tool-run-context-BmuljBMs.js";
+import "./pi-tools.before-tool-call-DdPCGWCs.js";
+import "./gateway-C0YHaLXO.js";
+import "./runs-DUTtPgDm.js";
+import "./sandbox-DAnx9TYc.js";
+import "./attempt.thread-helpers-ScWw-xjS.js";
+import { i as buildAgentHookContext } from "./lifecycle-hook-helpers-B-p0SqJw.js";
+import "./native-hook-relay-BygYZoeR.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;
+/**
+* Derive the same compact user-facing tool detail that Pi uses for progress logs.
+*/
+function inferToolMetaFromArgs(toolName, args) {
+	return formatToolDetail(resolveToolDisplay({
+		name: toolName,
+		args
+	}));
+}
+/**
+* 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)...`;
+}
+//#endregion
+export { resolveAgentHarnessBeforePromptBuildResult as a, createCodexAppServerToolResultExtensionRunner as i, formatToolProgressOutput as n, runAgentHarnessAfterCompactionHook as o, inferToolMetaFromArgs as r, runAgentHarnessBeforeCompactionHook as s, TOOL_PROGRESS_OUTPUT_MAX_CHARS as t };

package/dist/agent-runner-utils-CMe-JIDq.js

@@ -0,0 +1,239 @@
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-C1IzJjqi.js";
+import { a as normalizeAnyChannelId, o as normalizeChannelId } from "./registry-CXnn3dzM.js";
+import { t as getChannelPlugin } from "./registry-DXDC8Wqv.js";
+import { a as getRuntimeConfigSourceSnapshot, r as getRuntimeConfigSnapshot, u as selectApplicableRuntimeConfig } from "./runtime-snapshot-C5PRsFS9.js";
+import { n as resolveProviderIdForAuth } from "./provider-auth-aliases-CAzO2CSB.js";
+import { f as resolveRunModelFallbacksOverride } from "./agent-scope-CDjZLqNk.js";
+import "./config-3He3LWHw.js";
+import "./plugins-DNe6i7Rv.js";
+import { t as isReasoningTagProvider } from "./provider-utils-BR35tIjk.js";
+import { t as resolveMessageSecretScope } from "./message-secret-scope-ChHjTYfU.js";
+import { t as resolveCommandSecretRefsViaGateway } from "./command-secret-gateway-ChRXthnT.js";
+import { o as getScopedChannelsCommandSecretTargets, t as getAgentRuntimeCommandSecretTargetIds } from "./command-secret-targets-DG3i8iiK.js";
+import { n as resolveOriginMessageProvider, r as resolveOriginMessageTo } from "./origin-routing-BGPWh_y8.js";
+//#region src/auto-reply/reply/agent-runner-auth-profile.ts
+function resolveProviderScopedAuthProfile(params) {
+	const aliasParams = {
+		config: params.config,
+		workspaceDir: params.workspaceDir
+	};
+	const authProfileId = resolveProviderIdForAuth(params.provider, aliasParams) === resolveProviderIdForAuth(params.primaryProvider, aliasParams) ? params.authProfileId : void 0;
+	return {
+		authProfileId,
+		authProfileIdSource: authProfileId ? params.authProfileIdSource : void 0
+	};
+}
+function resolveRunAuthProfile(run, provider, params) {
+	return resolveProviderScopedAuthProfile({
+		provider,
+		primaryProvider: run.provider,
+		authProfileId: run.authProfileId,
+		authProfileIdSource: run.authProfileIdSource,
+		config: params?.config ?? run.config,
+		workspaceDir: run.workspaceDir
+	});
+}
+//#endregion
+//#region src/auto-reply/reply/agent-runner-utils.ts
+const BUN_FETCH_SOCKET_ERROR_RE = /socket connection was closed unexpectedly/i;
+function resolveQueuedReplyRuntimeConfig(config) {
+	return selectApplicableRuntimeConfig({
+		inputConfig: config,
+		runtimeConfig: typeof getRuntimeConfigSnapshot === "function" ? getRuntimeConfigSnapshot() : null,
+		runtimeSourceConfig: typeof getRuntimeConfigSourceSnapshot === "function" ? getRuntimeConfigSourceSnapshot() : null
+	}) ?? config;
+}
+async function resolveQueuedReplyExecutionConfig(config, params) {
+	const runtimeConfig = resolveQueuedReplyRuntimeConfig(config);
+	const { resolvedConfig } = await resolveCommandSecretRefsViaGateway({
+		config: runtimeConfig,
+		commandName: "reply",
+		targetIds: getAgentRuntimeCommandSecretTargetIds()
+	});
+	const baseResolvedConfig = resolvedConfig ?? runtimeConfig;
+	const scope = resolveMessageSecretScope({
+		channel: params?.originatingChannel,
+		fallbackChannel: params?.messageProvider,
+		accountId: params?.originatingAccountId,
+		fallbackAccountId: params?.agentAccountId
+	});
+	if (!scope.channel) return baseResolvedConfig;
+	const scopedTargets = getScopedChannelsCommandSecretTargets({
+		config: baseResolvedConfig,
+		channel: scope.channel,
+		accountId: scope.accountId
+	});
+	if (scopedTargets.targetIds.size === 0) return baseResolvedConfig;
+	return (await resolveCommandSecretRefsViaGateway({
+		config: baseResolvedConfig,
+		commandName: "reply",
+		targetIds: scopedTargets.targetIds,
+		...scopedTargets.allowedPaths ? { allowedPaths: scopedTargets.allowedPaths } : {}
+	})).resolvedConfig ?? baseResolvedConfig;
+}
+/**
+* Build provider-specific threading context for tool auto-injection.
+*/
+function buildThreadingToolContext(params) {
+	const { sessionCtx, config, hasRepliedRef } = params;
+	const currentMessageId = sessionCtx.MessageSidFull ?? sessionCtx.MessageSid;
+	const originProvider = resolveOriginMessageProvider({
+		originatingChannel: sessionCtx.OriginatingChannel,
+		provider: sessionCtx.Provider
+	});
+	const originTo = resolveOriginMessageTo({
+		originatingTo: sessionCtx.OriginatingTo,
+		to: sessionCtx.To
+	});
+	if (!config) return { currentMessageId };
+	const rawProvider = normalizeOptionalLowercaseString(originProvider);
+	if (!rawProvider) return { currentMessageId };
+	const provider = normalizeChannelId(rawProvider) ?? normalizeAnyChannelId(rawProvider);
+	const threading = provider ? getChannelPlugin(provider)?.threading : void 0;
+	if (!threading?.buildToolContext) return {
+		currentChannelId: normalizeOptionalString(originTo),
+		currentChannelProvider: provider ?? rawProvider,
+		currentMessageId,
+		hasRepliedRef
+	};
+	const context = threading.buildToolContext({
+		cfg: config,
+		accountId: sessionCtx.AccountId,
+		context: {
+			Channel: originProvider,
+			From: sessionCtx.From,
+			To: originTo,
+			ChatType: sessionCtx.ChatType,
+			CurrentMessageId: currentMessageId,
+			ReplyToId: sessionCtx.ReplyToId,
+			ThreadLabel: sessionCtx.ThreadLabel,
+			MessageThreadId: sessionCtx.MessageThreadId,
+			NativeChannelId: sessionCtx.NativeChannelId
+		},
+		hasRepliedRef
+	}) ?? {};
+	return {
+		...context,
+		currentChannelProvider: provider,
+		currentMessageId: context.currentMessageId ?? currentMessageId
+	};
+}
+const isBunFetchSocketError = (message) => message ? BUN_FETCH_SOCKET_ERROR_RE.test(message) : false;
+const formatBunFetchSocketError = (message) => {
+	return [
+		"⚠️ LLM connection failed. This could be due to server issues, network problems, or context length exceeded (e.g., with local LLMs like LM Studio). Original error:",
+		"```",
+		message.trim() || "Unknown error",
+		"```"
+	].join("\n");
+};
+const resolveEnforceFinalTag = (run, provider, model = run.model) => (run.skipProviderRuntimeHints ? false : void 0) ?? (run.enforceFinalTag || isReasoningTagProvider(provider, {
+	config: run.config,
+	workspaceDir: run.workspaceDir,
+	modelId: model
+}));
+function resolveModelFallbackOptions(run) {
+	const config = run.config;
+	return {
+		cfg: config,
+		provider: run.provider,
+		model: run.model,
+		agentDir: run.agentDir,
+		fallbacksOverride: resolveRunModelFallbacksOverride({
+			cfg: config,
+			agentId: run.agentId,
+			sessionKey: run.sessionKey
+		})
+	};
+}
+function buildEmbeddedRunBaseParams(params) {
+	const config = params.run.config;
+	return {
+		sessionFile: params.run.sessionFile,
+		workspaceDir: params.run.workspaceDir,
+		agentDir: params.run.agentDir,
+		config,
+		skillsSnapshot: params.run.skillsSnapshot,
+		ownerNumbers: params.run.ownerNumbers,
+		inputProvenance: params.run.inputProvenance,
+		senderIsOwner: params.run.senderIsOwner,
+		enforceFinalTag: resolveEnforceFinalTag(params.run, params.provider, params.model),
+		silentExpected: params.run.silentExpected,
+		provider: params.provider,
+		model: params.model,
+		...params.authProfile,
+		thinkLevel: params.run.thinkLevel,
+		verboseLevel: params.run.verboseLevel,
+		reasoningLevel: params.run.reasoningLevel,
+		execOverrides: params.run.execOverrides,
+		bashElevated: params.run.bashElevated,
+		timeoutMs: params.run.timeoutMs,
+		runId: params.runId,
+		allowTransientCooldownProbe: params.allowTransientCooldownProbe
+	};
+}
+function buildEmbeddedContextFromTemplate(params) {
+	const config = params.run.config;
+	return {
+		sessionId: params.run.sessionId,
+		sessionKey: params.run.sessionKey,
+		sandboxSessionKey: params.run.runtimePolicySessionKey,
+		agentId: params.run.agentId,
+		messageProvider: resolveOriginMessageProvider({
+			originatingChannel: params.sessionCtx.OriginatingChannel,
+			provider: params.sessionCtx.Provider
+		}),
+		agentAccountId: params.sessionCtx.AccountId,
+		messageTo: resolveOriginMessageTo({
+			originatingTo: params.sessionCtx.OriginatingTo,
+			to: params.sessionCtx.To
+		}),
+		messageThreadId: params.sessionCtx.MessageThreadId ?? void 0,
+		memberRoleIds: normalizeMemberRoleIds(params.sessionCtx.MemberRoleIds),
+		...buildThreadingToolContext({
+			sessionCtx: params.sessionCtx,
+			config,
+			hasRepliedRef: params.hasRepliedRef
+		})
+	};
+}
+function normalizeMemberRoleIds(value) {
+	const roles = Array.isArray(value) ? value.map((roleId) => normalizeOptionalString(roleId)).filter((roleId) => Boolean(roleId)) : [];
+	return roles.length > 0 ? roles : void 0;
+}
+function buildTemplateSenderContext(sessionCtx) {
+	return {
+		senderId: normalizeOptionalString(sessionCtx.SenderId),
+		senderName: normalizeOptionalString(sessionCtx.SenderName),
+		senderUsername: normalizeOptionalString(sessionCtx.SenderUsername),
+		senderE164: normalizeOptionalString(sessionCtx.SenderE164)
+	};
+}
+function buildEmbeddedRunContexts(params) {
+	return {
+		authProfile: resolveRunAuthProfile(params.run, params.provider),
+		embeddedContext: buildEmbeddedContextFromTemplate({
+			run: params.run,
+			sessionCtx: params.sessionCtx,
+			hasRepliedRef: params.hasRepliedRef
+		}),
+		senderContext: buildTemplateSenderContext(params.sessionCtx)
+	};
+}
+function buildEmbeddedRunExecutionParams(params) {
+	const { authProfile, embeddedContext, senderContext } = buildEmbeddedRunContexts(params);
+	return {
+		embeddedContext,
+		senderContext,
+		runBaseParams: buildEmbeddedRunBaseParams({
+			run: params.run,
+			provider: params.provider,
+			model: params.model,
+			runId: params.runId,
+			authProfile,
+			allowTransientCooldownProbe: params.allowTransientCooldownProbe
+		})
+	};
+}
+//#endregion
+export { resolveModelFallbackOptions as a, resolveRunAuthProfile as c, isBunFetchSocketError as i, buildThreadingToolContext as n, resolveQueuedReplyExecutionConfig as o, formatBunFetchSocketError as r, resolveQueuedReplyRuntimeConfig as s, buildEmbeddedRunExecutionParams as t };