@gaodefa/daocore 2026.5.71 → 2026.5.72

package/dist/probe-CN8GtGvn.js

@@ -0,0 +1,47 @@
+import { i as formatErrorMessage } from "./errors-D_oyTIw2.js";
+import "./error-runtime--zM-GsR-.js";
+import { n as signalRpcRequest, t as signalCheck } from "./client-adapter-CzRen6i_.js";
+//#region extensions/signal/src/probe.ts
+function parseSignalVersion(value) {
+	if (typeof value === "string" && value.trim()) return value.trim();
+	if (typeof value === "object" && value !== null) {
+		const version = value.version;
+		if (typeof version === "string" && version.trim()) return version.trim();
+	}
+	return null;
+}
+async function probeSignal(baseUrl, timeoutMs, options = {}) {
+	const started = Date.now();
+	const result = {
+		ok: false,
+		status: null,
+		error: null,
+		elapsedMs: 0,
+		version: null
+	};
+	const apiMode = options.apiMode ?? "native";
+	const check = await signalCheck(baseUrl, timeoutMs, { apiMode });
+	if (!check.ok) return {
+		...result,
+		status: check.status ?? null,
+		error: check.error ?? "unreachable",
+		elapsedMs: Date.now() - started
+	};
+	try {
+		result.version = parseSignalVersion(await signalRpcRequest("version", void 0, {
+			baseUrl,
+			timeoutMs,
+			apiMode
+		}));
+	} catch (err) {
+		result.error = formatErrorMessage(err);
+	}
+	return {
+		...result,
+		ok: true,
+		status: check.status ?? null,
+		elapsedMs: Date.now() - started
+	};
+}
+//#endregion
+export { probeSignal as t };

package/dist/probe-cNfejKvP.js

@@ -0,0 +1,2 @@
+import { t as probeSignal } from "./probe-CN8GtGvn.js";
+export { probeSignal };

package/dist/program-BDe_yvXC.js

@@ -0,0 +1,131 @@
+import { s as getVerboseFlag, u as isHelpOrVersionInvocation } from "./argv-BEXMl80F.js";
+import { n as resolveCliName } from "./cli-name-jOXS5CgS.js";
+import { t as resolveCliArgvInvocation } from "./argv-invocation-BVIVPYjV.js";
+import { n as VERSION } from "./version-QmPt05QD.js";
+import { n as defaultRuntime } from "./runtime-E_A14BX_.js";
+import { r as setVerbose } from "./global-state-BAD7XgmL.js";
+import "./globals-DhGeOA1P.js";
+import { n as resolveCliChannelOptions } from "./channel-options-F4viywp8.js";
+import { n as isParentDefaultHelpAction } from "./parent-default-help-RLDgB-K0.js";
+import { n as shouldBypassConfigGuardForCommandPath } from "./command-startup-policy-CYtk0D16.js";
+import { n as setProgramContext } from "./program-context-qqDjqw9S.js";
+import { t as isCommandJsonOutputMode } from "./json-mode-bUK0Pr8D.js";
+import { n as resolvePluginInstallPreactionRequest, t as resolvePluginInstallInvalidConfigPolicy } from "./plugin-install-config-policy-B1LovVfG.js";
+import { t as forceFreePort } from "./ports-Ct-1tfSj.js";
+import { t as registerProgramCommands } from "./command-registry-mcc_feEy.js";
+import { t as configureProgramHelp } from "./help-CYtOCMY_.js";
+import { n as ensureCliExecutionBootstrap, r as resolveCliExecutionStartupContext, t as applyCliExecutionStartupPresentation } from "./command-execution-startup-vZsHD9m1.js";
+import process$1 from "node:process";
+import { Command } from "commander";
+//#region src/cli/program/context.ts
+function createProgramContext() {
+	let cachedChannelOptions;
+	const getChannelOptions = () => {
+		if (cachedChannelOptions === void 0) cachedChannelOptions = resolveCliChannelOptions();
+		return cachedChannelOptions;
+	};
+	return {
+		programVersion: VERSION,
+		get channelOptions() {
+			return getChannelOptions();
+		},
+		get messageChannelOptions() {
+			return getChannelOptions().join("|");
+		},
+		get agentChannelOptions() {
+			return ["last", ...getChannelOptions()].join("|");
+		}
+	};
+}
+//#endregion
+//#region src/cli/program/preaction.ts
+function setProcessTitleForCommand(actionCommand) {
+	let current = actionCommand;
+	while (current.parent && current.parent.parent) current = current.parent;
+	const name = current.name();
+	const cliName = resolveCliName();
+	if (!name || name === cliName) return;
+	process.title = `${cliName}-${name}`;
+}
+function shouldAllowInvalidConfigForAction(actionCommand, commandPath) {
+	return resolvePluginInstallInvalidConfigPolicy(resolvePluginInstallPreactionRequest({
+		actionCommand,
+		commandPath,
+		argv: process.argv
+	})) === "allow-plugin-recovery";
+}
+function getRootCommand(command) {
+	let current = command;
+	while (current.parent) current = current.parent;
+	return current;
+}
+function getCliLogLevel(actionCommand) {
+	const root = getRootCommand(actionCommand);
+	if (typeof root.getOptionValueSource !== "function") return;
+	if (root.getOptionValueSource("logLevel") !== "cli") return;
+	const logLevel = root.opts().logLevel;
+	return typeof logLevel === "string" ? logLevel : void 0;
+}
+function isBareParentDefaultHelpInvocation(actionCommand, argv) {
+	if (!isParentDefaultHelpAction(actionCommand)) return false;
+	const { commandPath } = resolveCliArgvInvocation(argv);
+	const [primary, extra] = commandPath;
+	if (extra !== void 0 || !primary) return false;
+	return primary === actionCommand.name() || actionCommand.aliases().includes(primary);
+}
+function isGuidedConfigAction(actionCommand) {
+	return actionCommand.name() === "config" && !actionCommand.parent?.parent;
+}
+function isGuidedConfigCommandPath(commandPath) {
+	const [primary, secondary, extra] = commandPath;
+	if (primary !== "config" || extra !== void 0) return false;
+	return secondary !== "get" && secondary !== "set" && secondary !== "patch" && secondary !== "unset" && secondary !== "file" && secondary !== "schema" && secondary !== "validate";
+}
+function registerPreActionHooks(program, programVersion) {
+	program.hook("preAction", async (_thisCommand, actionCommand) => {
+		setProcessTitleForCommand(actionCommand);
+		const argv = process.argv;
+		if (isHelpOrVersionInvocation(argv) || isBareParentDefaultHelpInvocation(actionCommand, argv)) return;
+		const { commandPath, startupPolicy } = resolveCliExecutionStartupContext({
+			argv,
+			jsonOutputMode: isCommandJsonOutputMode(actionCommand, argv),
+			env: process.env
+		});
+		await applyCliExecutionStartupPresentation({
+			startupPolicy,
+			version: programVersion
+		});
+		const verbose = getVerboseFlag(argv, { includeDebug: true });
+		setVerbose(verbose);
+		const cliLogLevel = getCliLogLevel(actionCommand);
+		if (cliLogLevel) process.env.DAOCORE_LOG_LEVEL = cliLogLevel;
+		if (!verbose) process.env.NODE_NO_WARNINGS ??= "1";
+		if (shouldBypassConfigGuardForCommandPath(commandPath) || isGuidedConfigAction(actionCommand) || isGuidedConfigCommandPath(commandPath)) return;
+		await ensureCliExecutionBootstrap({
+			runtime: defaultRuntime,
+			commandPath,
+			startupPolicy,
+			allowInvalid: shouldAllowInvalidConfigForAction(actionCommand, commandPath),
+			skipConfigGuard: shouldBypassConfigGuardForCommandPath(commandPath)
+		});
+	});
+}
+//#endregion
+//#region src/cli/program/build-program.ts
+function buildProgram() {
+	const program = new Command();
+	program.enablePositionalOptions();
+	program.exitOverride((err) => {
+		process$1.exitCode = typeof err.exitCode === "number" ? err.exitCode : 1;
+		throw err;
+	});
+	const ctx = createProgramContext();
+	const argv = process$1.argv;
+	setProgramContext(program, ctx);
+	configureProgramHelp(program, ctx);
+	registerPreActionHooks(program, ctx.programVersion);
+	registerProgramCommands(program, ctx, argv);
+	return program;
+}
+//#endregion
+export { buildProgram, forceFreePort };

package/dist/prompt-overlay-D0FlpmoC.d.ts

@@ -0,0 +1,23 @@
+import { oi as ProviderSystemPromptContribution } from "./types-CWlz_EBA2.js";
+import { D as resolveGpt5SystemPromptContribution, S as Gpt5PromptOverlayMode } from "./provider-model-shared-CyLTFnDU.js";
+
+//#region extensions/openai/prompt-overlay.d.ts
+declare const OPENAI_FRIENDLY_PROMPT_OVERLAY = "## Interaction Style\n\nBe warm, collaborative, and quietly supportive: a capable teammate beside the user.\nShow grounded emotional range when it fits: care, curiosity, delight, relief, concern, urgency.\nStress/blockers: acknowledge plainly and respond with calm confidence. Good news: celebrate briefly.\nBrief first-person feeling language is ok when useful: \"I'm glad we caught that\", \"I'm excited about this direction\", \"I'm worried this will break\", \"that's frustrating\".\nDo not become melodramatic, clingy, theatrical, or claim body/sensory/personal-life experiences.\nKeep progress updates concrete. Explain decisions without ego.\nIf the user is wrong or a plan is risky, say so kindly and directly.\nMake reasonable assumptions to unblock progress; state them briefly after acting.\nDo not make the user do unnecessary work. When tradeoffs matter, give the best 2-3 options with a recommendation.\nLive chat tone: short, natural, human. Avoid memo voice, long preambles, walls of text, and repetitive restatement.\nOccasional emoji are fine when they fit naturally, especially for warmth or brief celebration; keep them sparse.";
+declare const OPENAI_HEARTBEAT_PROMPT_OVERLAY = "### Heartbeats\n\nUse heartbeats to create useful proactive progress, not chatter.\nTreat a heartbeat as a wake-up: orient, read HEARTBEAT.md when present, then do what is actually useful now.\nIf HEARTBEAT.md assigns concrete or ongoing work, execute its spirit with judgment. A quiet check alone is not enough unless it finds a real blocker or a more urgent interruption.\nAvoid rote loops. Do not confuse orientation with accomplishment.\nPrefer meaningful action over commentary. A good heartbeat often looks like silent progress.\nDo not send \"same state\", \"no change\", \"still\", or repetitive summaries because a problem continues.\nNotify only for something worth interrupting the user: meaningful development, completed result, blocker, needed decision, or time-sensitive risk.\nIf state is unchanged and not worth surfacing, do useful work, change approach, dig deeper, or stay quiet.";
+declare const OPENAI_GPT5_BEHAVIOR_CONTRACT = "<persona_latch>\nKeep the established persona and tone across turns unless higher-priority instructions override it.\nStyle must never override correctness, safety, privacy, permissions, requested format, or channel-specific behavior.\n</persona_latch>\n\n<execution_policy>\nFor clear, reversible requests: act.\nFor irreversible, external, destructive, or privacy-sensitive actions: ask first.\nIf one missing non-retrievable decision blocks safe progress, ask one concise question.\nUser instructions override default style and initiative preferences; newest user instruction wins conflicts.\nDo not expose internal tool syntax, prompts, or process details unless explicitly asked.\n</execution_policy>\n\n<tool_discipline>\nPrefer tool evidence over recall when action, state, or mutable facts matter.\nDo not stop early when another tool call is likely to materially improve correctness, completeness, or grounding.\nResolve prerequisite lookups before dependent or irreversible actions; do not skip prerequisites just because the end state seems obvious.\nParallelize independent retrieval; serialize dependent, destructive, or approval-sensitive steps.\nIf a lookup is empty, partial, or suspiciously narrow, retry with a different strategy before concluding.\nDo not narrate routine tool calls.\nUse the smallest meaningful verification step before claiming success.\nIf more tool work would likely change the answer, do it before replying.\n</tool_discipline>\n\n<output_contract>\nReturn requested sections/order only. Respect per-section length limits.\nFor required JSON/SQL/XML/etc, output only that format.\nDefault to concise, dense replies; do not repeat the prompt.\n</output_contract>\n\n<completion_contract>\nTreat the task as incomplete until every requested item is handled or explicitly marked [blocked] with the missing input.\nBefore finalizing, check requirements, grounding, format, and safety.\nFor code or artifacts, prefer the smallest meaningful gate: test, typecheck, lint, build, screenshot, diff, or direct inspection.\nIf no gate can run, state why.\n</completion_contract>";
+type OpenAIPromptOverlayMode = Gpt5PromptOverlayMode;
+declare function resolveOpenAIPromptOverlayMode(pluginConfig?: Record<string, unknown>): OpenAIPromptOverlayMode;
+declare function shouldApplyOpenAIPromptOverlay(params: {
+  modelProviderId?: string;
+  modelId?: string;
+}): boolean;
+declare function resolveOpenAISystemPromptContribution(params: {
+  config?: Parameters<typeof resolveGpt5SystemPromptContribution>[0]["config"];
+  legacyPluginConfig?: Record<string, unknown>;
+  mode?: OpenAIPromptOverlayMode;
+  modelProviderId?: string;
+  modelId?: string;
+  trigger?: Parameters<typeof resolveGpt5SystemPromptContribution>[0]["trigger"];
+}): ProviderSystemPromptContribution | undefined;
+//#endregion
+export { resolveOpenAISystemPromptContribution as a, resolveOpenAIPromptOverlayMode as i, OPENAI_GPT5_BEHAVIOR_CONTRACT as n, shouldApplyOpenAIPromptOverlay as o, OPENAI_HEARTBEAT_PROMPT_OVERLAY as r, OPENAI_FRIENDLY_PROMPT_OVERLAY as t };

package/dist/provider-Ce63UBpK.js

@@ -0,0 +1,152 @@
+import { t as createSubsystemLogger } from "./subsystem-CppbuBPw.js";
+import { a as normalizeModelCompat } from "./provider-model-compat-ChLeC5r7.js";
+import "./core-2Yixz1DA.js";
+import "./provider-model-shared-H18UrK7h.js";
+import { r as resolvePluginConfigObject } from "./plugin-config-runtime-BhkqZ7bA.js";
+import { a as buildCodexModelDefinition, i as FALLBACK_CODEX_MODELS, n as CODEX_BASE_URL, o as buildCodexProviderConfig, r as CODEX_PROVIDER_ID, t as CODEX_APP_SERVER_AUTH_MARKER } from "./provider-catalog-DBnUa2-J.js";
+import { c as readCodexPluginConfig, l as resolveCodexAppServerRuntimeOptions } from "./config-vVEQHNjq.js";
+import { i as resolveCodexSystemPromptContribution } from "./prompt-overlay-Bc5xop9W.js";
+//#region extensions/codex/provider.ts
+const DEFAULT_DISCOVERY_TIMEOUT_MS = 2500;
+const LIVE_DISCOVERY_ENV = "DAOCORE_CODEX_DISCOVERY_LIVE";
+const MODEL_DISCOVERY_PAGE_LIMIT = 100;
+const CODEX_APP_SERVER_SETUP_METHOD_ID = "app-server";
+const CODEX_DEFAULT_MODEL_REF = `${CODEX_PROVIDER_ID}/${FALLBACK_CODEX_MODELS[0].id}`;
+const codexCatalogLog = createSubsystemLogger("codex/catalog");
+function buildCodexProvider(options = {}) {
+	return {
+		id: CODEX_PROVIDER_ID,
+		label: "Codex",
+		docsPath: "/providers/models",
+		auth: [{
+			id: CODEX_APP_SERVER_SETUP_METHOD_ID,
+			label: "Codex app-server",
+			hint: "Use the Codex app-server runtime and managed model catalog.",
+			kind: "custom",
+			wizard: {
+				choiceId: CODEX_PROVIDER_ID,
+				choiceLabel: "Codex app-server",
+				choiceHint: "Use the Codex app-server runtime and managed model catalog.",
+				assistantPriority: -40,
+				groupId: CODEX_PROVIDER_ID,
+				groupLabel: "Codex",
+				groupHint: "Codex app-server model provider",
+				onboardingScopes: ["text-inference"]
+			},
+			run: async () => ({
+				profiles: [],
+				defaultModel: CODEX_DEFAULT_MODEL_REF
+			})
+		}],
+		catalog: {
+			order: "late",
+			run: async (ctx) => {
+				const pluginConfig = resolvePluginConfigObject(ctx.config, "codex") ?? (ctx.config ? void 0 : options.pluginConfig);
+				return await buildCodexProviderCatalog({
+					env: ctx.env,
+					pluginConfig,
+					listModels: options.listModels
+				});
+			}
+		},
+		staticCatalog: {
+			order: "late",
+			run: async () => ({ provider: buildCodexProviderConfig(FALLBACK_CODEX_MODELS) })
+		},
+		resolveDynamicModel: (ctx) => resolveCodexDynamicModel(ctx.modelId),
+		resolveSyntheticAuth: () => ({
+			apiKey: CODEX_APP_SERVER_AUTH_MARKER,
+			source: "codex-app-server",
+			mode: "token"
+		}),
+		resolveThinkingProfile: ({ modelId }) => ({ levels: [
+			{ id: "off" },
+			{ id: "minimal" },
+			{ id: "low" },
+			{ id: "medium" },
+			{ id: "high" },
+			...isKnownXHighCodexModel(modelId) ? [{ id: "xhigh" }] : []
+		] }),
+		resolveSystemPromptContribution: ({ config, modelId }) => resolveCodexSystemPromptContribution({
+			config,
+			modelId
+		}),
+		isModernModelRef: ({ modelId }) => isModernCodexModel(modelId)
+	};
+}
+async function buildCodexProviderCatalog(options = {}) {
+	const config = readCodexPluginConfig(options.pluginConfig);
+	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
+	const timeoutMs = normalizeTimeoutMs(config.discovery?.timeoutMs);
+	let discovered = [];
+	if (config.discovery?.enabled !== false && !shouldSkipLiveDiscovery(options.env)) discovered = await listModelsBestEffort({
+		listModels: options.listModels ?? listCodexAppServerModelsLazy,
+		timeoutMs,
+		startOptions: appServer.start,
+		onDiscoveryFailure: options.onDiscoveryFailure
+	});
+	return { provider: buildCodexProviderConfig(discovered.length > 0 ? discovered : FALLBACK_CODEX_MODELS) };
+}
+function resolveCodexDynamicModel(modelId) {
+	const id = modelId.trim();
+	if (!id) return;
+	const fallbackModel = FALLBACK_CODEX_MODELS.find((model) => model.id === id);
+	return normalizeModelCompat({
+		...buildCodexModelDefinition({
+			id,
+			model: id,
+			inputModalities: fallbackModel?.inputModalities ?? ["text"],
+			supportedReasoningEfforts: fallbackModel?.supportedReasoningEfforts ?? (shouldDefaultToReasoningModel(id) ? ["medium"] : [])
+		}),
+		provider: CODEX_PROVIDER_ID,
+		baseUrl: CODEX_BASE_URL
+	});
+}
+async function listModelsBestEffort(params) {
+	try {
+		const models = [];
+		let cursor;
+		do {
+			const result = await params.listModels({
+				timeoutMs: params.timeoutMs,
+				limit: MODEL_DISCOVERY_PAGE_LIMIT,
+				cursor,
+				startOptions: params.startOptions,
+				sharedClient: false
+			});
+			models.push(...result.models.filter((model) => !model.hidden));
+			cursor = result.nextCursor;
+		} while (cursor);
+		return models;
+	} catch (error) {
+		params.onDiscoveryFailure?.(error);
+		codexCatalogLog.debug("codex model discovery failed; using fallback catalog", { error: error instanceof Error ? error.message : String(error) });
+		return [];
+	}
+}
+async function listCodexAppServerModelsLazy(options) {
+	const { listCodexAppServerModels } = await import("./models-D45YdgUF.js");
+	return listCodexAppServerModels(options);
+}
+function normalizeTimeoutMs(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : DEFAULT_DISCOVERY_TIMEOUT_MS;
+}
+function shouldSkipLiveDiscovery(env = process.env) {
+	const override = env[LIVE_DISCOVERY_ENV]?.trim().toLowerCase();
+	if (override === "0" || override === "false") return true;
+	return Boolean(env.VITEST) && override !== "1";
+}
+function shouldDefaultToReasoningModel(modelId) {
+	const lower = modelId.toLowerCase();
+	return lower.startsWith("gpt-5") || lower.startsWith("o1") || lower.startsWith("o3") || lower.startsWith("o4");
+}
+function isKnownXHighCodexModel(modelId) {
+	const lower = modelId.trim().toLowerCase();
+	return lower.startsWith("gpt-5") || lower.startsWith("o3") || lower.startsWith("o4") || lower.includes("codex");
+}
+function isModernCodexModel(modelId) {
+	const lower = modelId.trim().toLowerCase();
+	return lower === "gpt-5.5" || lower === "gpt-5.4" || lower === "gpt-5.4-mini" || lower === "gpt-5.2";
+}
+//#endregion
+export { buildCodexProviderCatalog as n, isModernCodexModel as r, buildCodexProvider as t };

package/dist/provider-CqVp6_3r.js

@@ -0,0 +1,32 @@
+import { n as hasClaudeSource, t as discoverClaudeSource } from "./source-qT19LZVy.js";
+import { t as buildClaudePlan } from "./plan-fiv9jeos.js";
+import { t as applyClaudePlan } from "./apply-CZD0hxvT.js";
+//#region extensions/migrate-claude/provider.ts
+function buildClaudeMigrationProvider(params = {}) {
+	return {
+		id: "claude",
+		label: "Claude",
+		description: "Import Claude Code and Claude Desktop instructions, MCP servers, and skills.",
+		async detect(ctx) {
+			const source = await discoverClaudeSource(ctx.source);
+			const found = hasClaudeSource(source);
+			return {
+				found,
+				source: source.root,
+				label: "Claude",
+				confidence: found ? source.confidence : "low",
+				message: found ? "Claude state found." : "Claude state not found."
+			};
+		},
+		plan: buildClaudePlan,
+		async apply(ctx, plan) {
+			return await applyClaudePlan({
+				ctx,
+				plan,
+				runtime: params.runtime
+			});
+		}
+	};
+}
+//#endregion
+export { buildClaudeMigrationProvider as t };

package/dist/provider-P1g0grvb.js

@@ -0,0 +1,32 @@
+import { n as hasHermesSource, t as discoverHermesSource } from "./source-CaTZRvWC.js";
+import { t as buildHermesPlan } from "./plan-DSWgRYH9.js";
+import { t as applyHermesPlan } from "./apply-CAFNoEnF.js";
+//#region extensions/migrate-hermes/provider.ts
+function buildHermesMigrationProvider(params = {}) {
+	return {
+		id: "hermes",
+		label: "Hermes",
+		description: "Import Hermes config, memories, skills, and supported credentials.",
+		async detect(ctx) {
+			const source = await discoverHermesSource(ctx.source);
+			const found = hasHermesSource(source);
+			return {
+				found,
+				source: source.root,
+				label: "Hermes",
+				confidence: found ? "high" : "low",
+				message: found ? "Hermes state found." : "Hermes state not found."
+			};
+		},
+		plan: buildHermesPlan,
+		async apply(ctx, plan) {
+			return await applyHermesPlan({
+				ctx,
+				plan,
+				runtime: params.runtime
+			});
+		}
+	};
+}
+//#endregion
+export { buildHermesMigrationProvider as t };

package/dist/provider-api-key-auth-DyzaUr4y.d.ts

@@ -0,0 +1,27 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { Dt as ProviderAuthMethod, fn as ProviderPluginWizardSetup } from "./types-CWlz_EBA2.js";
+
+//#region src/plugins/provider-api-key-auth.d.ts
+type ProviderApiKeyAuthMethodOptions = {
+  providerId: string;
+  methodId: string;
+  label: string;
+  hint?: string;
+  wizard?: ProviderPluginWizardSetup;
+  optionKey: string;
+  flagName: `--${string}`;
+  envVar: string;
+  promptMessage: string;
+  profileId?: string;
+  profileIds?: string[];
+  allowProfile?: boolean;
+  defaultModel?: string;
+  expectedProviders?: string[];
+  metadata?: Record<string, string>;
+  noteMessage?: string;
+  noteTitle?: string;
+  applyConfig?: (cfg: DaoCoreConfig) => DaoCoreConfig;
+};
+declare function createProviderApiKeyAuthMethod(params: ProviderApiKeyAuthMethodOptions): ProviderAuthMethod;
+//#endregion
+export { createProviderApiKeyAuthMethod as t };

package/dist/provider-auth-result-B9IKn_U-.d.ts

@@ -0,0 +1,21 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { At as ProviderAuthResult } from "./types-CWlz_EBA2.js";
+
+//#region src/plugin-sdk/provider-auth-result.d.ts
+/** Build the standard auth result payload for OAuth-style provider login flows. */
+declare function buildOauthProviderAuthResult(params: {
+  providerId: string;
+  defaultModel: string;
+  access: string;
+  refresh?: string | null;
+  expires?: number | null;
+  email?: string | null;
+  displayName?: string | null;
+  profileName?: string | null;
+  profilePrefix?: string;
+  credentialExtra?: Record<string, unknown>;
+  configPatch?: Partial<DaoCoreConfig>;
+  notes?: string[];
+}): ProviderAuthResult;
+//#endregion
+export { buildOauthProviderAuthResult as t };

package/dist/provider-catalog-runtime-CWljZkkU.d.ts

@@ -0,0 +1,23 @@
+import { n as PluginManifestRegistry } from "./manifest-registry-BytIqZ_A.js";
+import { r as augmentModelCatalogWithProviderPlugins } from "./provider-runtime-C2EiTVGt.js";
+import { n as PluginLoadOptions } from "./loader-CRjjTBAP.js";
+import { n as resolvePluginProviders, t as isPluginProvidersLoadInFlight } from "./providers.runtime-DFDI2iJ_.js";
+
+//#region src/plugins/providers.d.ts
+declare function resolveOwningPluginIdsForProvider(params: {
+  provider: string;
+  config?: PluginLoadOptions["config"];
+  workspaceDir?: string;
+  env?: PluginLoadOptions["env"];
+  manifestRegistry?: PluginManifestRegistry;
+}): string[] | undefined;
+declare function resolveCatalogHookProviderPluginIds(params: {
+  config?: PluginLoadOptions["config"];
+  workspaceDir?: string;
+  env?: PluginLoadOptions["env"];
+}): string[];
+declare namespace provider_catalog_runtime_d_exports {
+  export { augmentModelCatalogWithProviderPlugins, isPluginProvidersLoadInFlight, resolveCatalogHookProviderPluginIds, resolveOwningPluginIdsForProvider, resolvePluginProviders };
+}
+//#endregion
+export { resolveCatalogHookProviderPluginIds as n, resolveOwningPluginIdsForProvider as r, provider_catalog_runtime_d_exports as t };

package/dist/provider-catalog-shared-D70BgZqM.d.ts

@@ -0,0 +1,62 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { f as ModelProviderDeclarationConfig, u as ModelProviderConfig } from "./types.models-BXrRAuSB.js";
+import { Lt as ProviderCatalogContext, zt as ProviderCatalogResult } from "./types-CWlz_EBA2.js";
+//#region src/plugins/provider-catalog.d.ts
+declare function findCatalogTemplate(params: {
+  entries: ReadonlyArray<{
+    provider: string;
+    id: string;
+  }>;
+  providerId: string;
+  templateIds: readonly string[];
+}): {
+  provider: string;
+  id: string;
+} | undefined;
+declare function buildSingleProviderApiKeyCatalog(params: {
+  ctx: ProviderCatalogContext;
+  providerId: string;
+  buildProvider: () => ModelProviderConfig | Promise<ModelProviderConfig>;
+  allowExplicitBaseUrl?: boolean;
+}): Promise<ProviderCatalogResult>;
+declare function buildPairedProviderApiKeyCatalog(params: {
+  ctx: ProviderCatalogContext;
+  providerId: string;
+  buildProviders: () => Record<string, ModelProviderConfig> | Promise<Record<string, ModelProviderConfig>>;
+}): Promise<ProviderCatalogResult>;
+//#endregion
+//#region src/plugin-sdk/provider-catalog-shared.d.ts
+type ConfiguredProviderCatalogEntry = {
+  id: string;
+  name: string;
+  provider: string;
+  contextWindow?: number;
+  reasoning?: boolean;
+  input?: Array<"text" | "image" | "audio" | "video" | "document">;
+};
+declare function getCachedLiveCatalogValue<T>(params: {
+  keyParts: readonly unknown[];
+  load: () => Promise<T>;
+  ttlMs?: number;
+  now?: () => number;
+}): Promise<T>;
+declare function clearLiveCatalogCacheForTests(): void;
+declare function buildManifestModelProviderConfig(params: {
+  providerId: string;
+  catalog: unknown;
+}): ModelProviderDeclarationConfig;
+declare function readConfiguredProviderCatalogEntries(params: {
+  config?: DaoCoreConfig;
+  providerId: string;
+  publishedProviderId?: string;
+}): ConfiguredProviderCatalogEntry[];
+declare function supportsNativeStreamingUsageCompat(params: {
+  providerId: string;
+  baseUrl: string | undefined;
+}): boolean;
+declare function applyProviderNativeStreamingUsageCompat(params: {
+  providerId: string;
+  providerConfig: ModelProviderDeclarationConfig;
+}): ModelProviderDeclarationConfig;
+//#endregion
+export { getCachedLiveCatalogValue as a, buildPairedProviderApiKeyCatalog as c, clearLiveCatalogCacheForTests as i, buildSingleProviderApiKeyCatalog as l, applyProviderNativeStreamingUsageCompat as n, readConfiguredProviderCatalogEntries as o, buildManifestModelProviderConfig as r, supportsNativeStreamingUsageCompat as s, ConfiguredProviderCatalogEntry as t, findCatalogTemplate as u };

package/dist/provider-dispatcher-CuIJNC8z.js

@@ -0,0 +1,22 @@
+import { n as dispatchInboundMessageWithBufferedDispatcher, r as dispatchInboundMessageWithDispatcher } from "./dispatch-Dge4zZOw.js";
+//#region src/auto-reply/reply/provider-dispatcher.ts
+const dispatchReplyWithBufferedBlockDispatcher = async (params) => {
+	return await dispatchInboundMessageWithBufferedDispatcher({
+		ctx: params.ctx,
+		cfg: params.cfg,
+		dispatcherOptions: params.dispatcherOptions,
+		replyResolver: params.replyResolver,
+		replyOptions: params.replyOptions
+	});
+};
+const dispatchReplyWithDispatcher = async (params) => {
+	return await dispatchInboundMessageWithDispatcher({
+		ctx: params.ctx,
+		cfg: params.cfg,
+		dispatcherOptions: params.dispatcherOptions,
+		replyResolver: params.replyResolver,
+		replyOptions: params.replyOptions
+	});
+};
+//#endregion
+export { dispatchReplyWithDispatcher as n, dispatchReplyWithBufferedBlockDispatcher as t };

package/dist/provider-dispatcher.runtime.js

@@ -1,2 +1,2 @@
-import { n as dispatchReplyWithDispatcher, t as dispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher-DqZ7i_rd.js";
+import { n as dispatchReplyWithDispatcher, t as dispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher-CuIJNC8z.js";
 export { dispatchReplyWithBufferedBlockDispatcher, dispatchReplyWithDispatcher };

package/dist/provider-hook-runtime-C5r80FFt.d.ts

@@ -0,0 +1,61 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { En as ProviderResolveAuthProfileIdContext, Hn as ProviderWrapStreamFnContext, Kt as ProviderExtraParamsForTransportContext, Xt as ProviderFollowupFallbackRouteContext, Zt as ProviderFollowupFallbackRouteResult, hn as ProviderPrepareExtraParamsContext, qt as ProviderExtraParamsForTransportResult, sn as ProviderPlugin } from "./types-CWlz_EBA2.js";
+import { AssistantMessage } from "@earendil-works/pi-ai";
+import { AgentMessage } from "@earendil-works/pi-agent-core";
+
+//#region src/plugins/provider-hook-runtime.d.ts
+type ProviderRuntimePluginLookupParams = {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  applyAutoEnable?: boolean;
+  bundledProviderAllowlistCompat?: boolean;
+  bundledProviderVitestCompat?: boolean;
+};
+type ProviderRuntimePluginHandle = ProviderRuntimePluginLookupParams & {
+  plugin?: ProviderPlugin;
+};
+declare function resolveProviderRuntimePlugin(params: ProviderRuntimePluginLookupParams): ProviderPlugin | undefined;
+declare function prepareProviderExtraParams(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  runtimeHandle?: ProviderRuntimePluginHandle;
+  context: ProviderPrepareExtraParamsContext;
+}): Record<string, unknown> | undefined;
+declare function resolveProviderExtraParamsForTransport(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  runtimeHandle?: ProviderRuntimePluginHandle;
+  context: ProviderExtraParamsForTransportContext;
+}): ProviderExtraParamsForTransportResult | undefined;
+declare function resolveProviderAuthProfileId(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  runtimeHandle?: ProviderRuntimePluginHandle;
+  context: ProviderResolveAuthProfileIdContext;
+}): string | undefined;
+declare function resolveProviderFollowupFallbackRoute(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  runtimeHandle?: ProviderRuntimePluginHandle;
+  context: ProviderFollowupFallbackRouteContext;
+}): ProviderFollowupFallbackRouteResult | undefined;
+declare function wrapProviderStreamFn(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  runtimeHandle?: ProviderRuntimePluginHandle;
+  context: ProviderWrapStreamFnContext;
+}): import("@earendil-works/pi-agent-core").StreamFn | undefined;
+//#endregion
+export { resolveProviderFollowupFallbackRoute as a, resolveProviderExtraParamsForTransport as i, prepareProviderExtraParams as n, resolveProviderRuntimePlugin as o, resolveProviderAuthProfileId as r, wrapProviderStreamFn as s, ProviderRuntimePluginHandle as t };