@gaodefa/daocore 2026.5.74 → 2026.5.75

package/dist/model-qHmcK-wV.js

@@ -1,74 +0,0 @@
-import { S as setAgentEffectiveModelPrimary, a as resolveAgentEffectiveModelPrimary } from "./agent-scope-Dx1S0aWX.js";
-import { c as resolveDefaultAgentId } from "./agent-scope-config-CJUQxn7u.js";
-import "./agent-runtime-Cio-RAUW.js";
-import { c as readString } from "./helpers-w2CyK9G6.js";
-import { a as HERMES_REASON_DEFAULT_MODEL_CONFIGURED, d as hermesItemConflict, f as hermesItemError, i as HERMES_REASON_CONFIG_RUNTIME_UNAVAILABLE, m as readHermesModelDetails, p as hermesItemSkipped, t as HERMES_REASON_ALREADY_CONFIGURED } from "./items-EdIOLB5m.js";
-//#region extensions/migrate-hermes/model.ts
-function resolveHermesModelRef(config) {
-	const model = config.model;
-	if (typeof model === "string" && model.trim()) {
-		const rawModel = model.trim();
-		const provider = readString(config.provider);
-		if (provider && !rawModel.includes("/")) return `${provider}/${rawModel}`;
-		return rawModel;
-	}
-	if (model && typeof model === "object" && !Array.isArray(model)) {
-		const modelRecord = model;
-		const rawModel = readString(modelRecord.default) ?? readString(modelRecord.model);
-		const provider = readString(modelRecord.provider);
-		if (rawModel && provider && !rawModel.includes("/")) return `${provider}/${rawModel}`;
-		return rawModel;
-	}
-	const rootModel = readString(config.default_model) ?? readString(config.model_name);
-	const rootProvider = readString(config.provider);
-	if (rootModel && rootProvider && !rootModel.includes("/")) return `${rootProvider}/${rootModel}`;
-	return rootModel;
-}
-function resolveDefaultAgentModelState(config) {
-	const agentId = resolveDefaultAgentId(config);
-	return {
-		agentId,
-		effectivePrimary: resolveAgentEffectiveModelPrimary(config, agentId)
-	};
-}
-function resolveCurrentModelRef(ctx) {
-	return resolveDefaultAgentModelState(ctx.config).effectivePrimary;
-}
-var ModelApplyAbortError = class extends Error {
-	constructor(status, reason) {
-		super(reason);
-		this.status = status;
-		this.reason = reason;
-		this.name = "ModelApplyAbortError";
-	}
-};
-async function applyModelItem(ctx, item) {
-	const details = readHermesModelDetails(item);
-	if (!details || item.status !== "planned") return item;
-	try {
-		const configApi = ctx.runtime?.config;
-		if (!configApi?.current || !configApi.mutateConfigFile) return hermesItemError(item, HERMES_REASON_CONFIG_RUNTIME_UNAVAILABLE);
-		const currentState = resolveDefaultAgentModelState(configApi.current());
-		if (currentState.effectivePrimary === details.model) return hermesItemSkipped(item, HERMES_REASON_ALREADY_CONFIGURED);
-		if (currentState.effectivePrimary && !ctx.overwrite) return hermesItemConflict(item, HERMES_REASON_DEFAULT_MODEL_CONFIGURED);
-		await configApi.mutateConfigFile({
-			base: "runtime",
-			afterWrite: { mode: "auto" },
-			mutate(draft) {
-				const mutationState = resolveDefaultAgentModelState(draft);
-				if (mutationState.effectivePrimary === details.model) throw new ModelApplyAbortError("skipped", HERMES_REASON_ALREADY_CONFIGURED);
-				if (mutationState.effectivePrimary && !ctx.overwrite) throw new ModelApplyAbortError("conflict", HERMES_REASON_DEFAULT_MODEL_CONFIGURED);
-				setAgentEffectiveModelPrimary(draft, mutationState.agentId, details.model);
-			}
-		});
-		return {
-			...item,
-			status: "migrated"
-		};
-	} catch (err) {
-		if (err instanceof ModelApplyAbortError) return err.status === "conflict" ? hermesItemConflict(item, err.reason) : hermesItemSkipped(item, err.reason);
-		return hermesItemError(item, err instanceof Error ? err.message : String(err));
-	}
-}
-//#endregion
-export { resolveCurrentModelRef as n, resolveHermesModelRef as r, applyModelItem as t };

package/dist/model-selection-C_bNk70D.js

@@ -1,272 +0,0 @@
-import { t as createLazyImportLoader } from "./lazy-promise-Djskx0qC.js";
-import { r as normalizeProviderId } from "./provider-id-zTW9Rdln.js";
-import "./agent-scope-Dx1S0aWX.js";
-import { r as resolveAgentConfig } from "./agent-scope-config-CJUQxn7u.js";
-import "./defaults-mDjiWzE5.js";
-import { a as listOpenAIAuthProfileProvidersForAgentRuntime } from "./openai-codex-routing-VOt1IwnF.js";
-import { t as resolveAgentHarnessPolicy } from "./policy-DqVcSoDg.js";
-import { f as parseConfiguredModelVisibilityEntries, r as buildConfiguredModelCatalog } from "./model-selection-shared-BZqZE4Cv.js";
-import { n as modelKey, r as normalizeModelRef } from "./model-selection-normalize-DLmoprpp.js";
-import { d as resolveReasoningDefault, l as resolvePersistedOverrideModelRef, m as resolveThinkingDefault } from "./model-selection-CGiHa_L6.js";
-import { o as resolveContextTokensForModel } from "./context-DQV42rBU.js";
-import "./selection-DTrJ8MmR.js";
-import { t as applyModelOverrideToSessionEntry } from "./model-overrides-CUnMI0Oj.js";
-import { t as createModelVisibilityPolicy } from "./model-visibility-policy-CN8jz_lZ.js";
-import { n as resolveStoredModelOverride, t as isStaleHeartbeatAutoFallbackOverride } from "./stored-model-override-eRE-R7Tk.js";
-import { t as clearSessionAuthProfileOverride } from "./session-override-Dx55fWtc.js";
-import "./model-selection-directive-JabHa2M7.js";
-//#region src/auto-reply/reply/model-selection.ts
-function createFastTestModelSelectionState(params) {
-	return {
-		provider: params.provider,
-		model: params.model,
-		allowedModelKeys: /* @__PURE__ */ new Set(),
-		allowedModelCatalog: [],
-		resetModelOverride: false,
-		resetModelOverrideRef: void 0,
-		resolveThinkingCatalog: async () => [],
-		resolveDefaultThinkingLevel: async () => params.agentCfg?.thinkingDefault,
-		resolveDefaultReasoningLevel: async () => "off",
-		needsModelCatalog: false
-	};
-}
-function shouldLogModelSelectionTiming() {
-	return process.env.DAOCORE_DEBUG_INGRESS_TIMING === "1";
-}
-const modelCatalogRuntimeLoader = createLazyImportLoader(() => import("./agents/model-catalog.runtime.js"));
-const sessionStoreRuntimeLoader = createLazyImportLoader(() => import("./store.runtime.js"));
-function loadModelCatalogRuntime() {
-	return modelCatalogRuntimeLoader.load();
-}
-function loadSessionStoreRuntime() {
-	return sessionStoreRuntimeLoader.load();
-}
-async function createModelSelectionState(params) {
-	const timingEnabled = shouldLogModelSelectionTiming();
-	const startMs = timingEnabled ? Date.now() : 0;
-	const logStage = (stage, extra) => {
-		if (!timingEnabled) return;
-		const suffix = extra ? ` ${extra}` : "";
-		console.log(`[model-selection] session=${params.sessionKey ?? "(no-session)"} stage=${stage} elapsedMs=${Date.now() - startMs}${suffix}`);
-	};
-	const { cfg, agentCfg, sessionEntry, sessionStore, sessionKey, parentSessionKey, storePath, defaultProvider, defaultModel } = params;
-	let provider = params.provider;
-	let model = params.model;
-	const primaryProvider = params.primaryProvider ?? defaultProvider;
-	const primaryModel = params.primaryModel ?? defaultModel;
-	const hasOneTurnModelOverride = params.hasOneTurnModelOverride === true;
-	const hasAllowlist = agentCfg?.models && Object.keys(agentCfg.models).length > 0;
-	const visibility = parseConfiguredModelVisibilityEntries({ cfg });
-	const defaultProviderVisibleByWildcard = visibility.providerWildcards.has(normalizeProviderId(defaultProvider));
-	const configuredModelCatalog = buildConfiguredModelCatalog({ cfg });
-	const needsModelCatalog = params.hasModelDirective || Boolean(hasAllowlist && visibility.providerWildcards.size > 0 && !defaultProviderVisibleByWildcard);
-	let allowedModelKeys = /* @__PURE__ */ new Set();
-	let allowedModelCatalog = configuredModelCatalog;
-	let visibilityPolicy = createModelVisibilityPolicy({
-		cfg,
-		catalog: configuredModelCatalog,
-		defaultProvider,
-		defaultModel,
-		agentId: params.agentId
-	});
-	let modelCatalog = null;
-	let resetModelOverride = false;
-	let resetModelOverrideRef;
-	const agentEntry = params.agentId ? resolveAgentConfig(cfg, params.agentId) : void 0;
-	const directStoredOverride = resolvePersistedOverrideModelRef({
-		defaultProvider,
-		overrideProvider: sessionEntry?.providerOverride,
-		overrideModel: sessionEntry?.modelOverride
-	});
-	const directStoredModelOverride = directStoredOverride ? {
-		...directStoredOverride,
-		source: "session"
-	} : null;
-	const staleHeartbeatAutoFallbackOverride = isStaleHeartbeatAutoFallbackOverride({
-		isHeartbeat: params.isHeartbeat,
-		hasResolvedHeartbeatModelOverride: params.hasResolvedHeartbeatModelOverride,
-		sessionEntry,
-		storedOverride: directStoredModelOverride,
-		defaultProvider,
-		defaultModel,
-		primaryProvider: params.primaryProvider,
-		primaryModel: params.primaryModel
-	});
-	if (needsModelCatalog) {
-		modelCatalog = await (await loadModelCatalogRuntime()).loadModelCatalog({ config: cfg });
-		logStage("catalog-loaded", `entries=${modelCatalog.length}`);
-		visibilityPolicy = createModelVisibilityPolicy({
-			cfg,
-			catalog: modelCatalog,
-			defaultProvider,
-			defaultModel,
-			agentId: params.agentId
-		});
-		allowedModelCatalog = visibilityPolicy.allowedCatalog;
-		allowedModelKeys = visibilityPolicy.allowedKeys;
-		logStage("allowlist-built", `allowed=${allowedModelCatalog.length} keys=${allowedModelKeys.size}`);
-	} else if (hasAllowlist) {
-		visibilityPolicy = createModelVisibilityPolicy({
-			cfg,
-			catalog: configuredModelCatalog,
-			defaultProvider,
-			defaultModel,
-			agentId: params.agentId
-		});
-		allowedModelCatalog = visibilityPolicy.allowedCatalog;
-		allowedModelKeys = visibilityPolicy.allowedKeys;
-		logStage("configured-allowlist-built", `allowed=${allowedModelCatalog.length} keys=${allowedModelKeys.size}`);
-	} else if (configuredModelCatalog.length > 0) logStage("configured-catalog-ready", `entries=${configuredModelCatalog.length}`);
-	if (sessionEntry && sessionStore && sessionKey && directStoredOverride && !hasOneTurnModelOverride) {
-		const normalizedOverride = normalizeModelRef(directStoredOverride.provider, directStoredOverride.model);
-		const key = modelKey(normalizedOverride.provider, normalizedOverride.model);
-		if (staleHeartbeatAutoFallbackOverride || !visibilityPolicy.allowsKey(key)) {
-			const { updated } = applyModelOverrideToSessionEntry({
-				entry: sessionEntry,
-				selection: {
-					provider: primaryProvider,
-					model: primaryModel,
-					isDefault: true
-				},
-				preserveAuthProfileOverride: staleHeartbeatAutoFallbackOverride
-			});
-			if (updated) {
-				sessionStore[sessionKey] = sessionEntry;
-				if (storePath) await (await loadSessionStoreRuntime()).updateSessionStore(storePath, (store) => {
-					store[sessionKey] = sessionEntry;
-				});
-			}
-			resetModelOverride = updated;
-			if (updated) resetModelOverrideRef = key;
-		}
-	}
-	if (staleHeartbeatAutoFallbackOverride) {
-		const normalizedCurrentSelection = normalizeModelRef(provider, model);
-		const currentSelectionKey = modelKey(normalizedCurrentSelection.provider, normalizedCurrentSelection.model);
-		const normalizedDirectOverride = directStoredOverride ? normalizeModelRef(directStoredOverride.provider, directStoredOverride.model) : null;
-		if (currentSelectionKey === (normalizedDirectOverride ? modelKey(normalizedDirectOverride.provider, normalizedDirectOverride.model) : void 0)) {
-			provider = primaryProvider;
-			model = primaryModel;
-		}
-	}
-	const storedOverride = resolveStoredModelOverride({
-		sessionEntry,
-		sessionStore,
-		sessionKey,
-		parentSessionKey,
-		defaultProvider
-	});
-	const skipStoredOverride = params.skipStoredModelOverride === true || hasOneTurnModelOverride || params.hasResolvedHeartbeatModelOverride === true || staleHeartbeatAutoFallbackOverride && storedOverride?.source === "session";
-	if (storedOverride?.model && !skipStoredOverride) {
-		const normalizedStoredOverride = normalizeModelRef(storedOverride.provider || defaultProvider, storedOverride.model);
-		const key = modelKey(normalizedStoredOverride.provider, normalizedStoredOverride.model);
-		if (visibilityPolicy.allowsKey(key)) {
-			provider = normalizedStoredOverride.provider;
-			model = normalizedStoredOverride.model;
-		}
-	}
-	if (!params.hasModelDirective && !hasOneTurnModelOverride) {
-		const allowedInitialSelection = visibilityPolicy.resolveSelection({
-			provider,
-			model
-		});
-		if (!allowedInitialSelection) throw new Error(`Configured default model "${modelKey(provider, model)}" is not allowed by agents.defaults.models, and no allowed model is available.`);
-		provider = allowedInitialSelection.provider;
-		model = allowedInitialSelection.model;
-	}
-	if (!params.skipStoredModelOverride && sessionEntry && sessionStore && sessionKey && sessionEntry.authProfileOverride) {
-		const { ensureAuthProfileStore } = await import("./agents/auth-profiles.runtime.js");
-		const store = ensureAuthProfileStore(void 0, { allowKeychainPrompt: false });
-		logStage("auth-profile-store-loaded", `profiles=${Object.keys(store.profiles).length}`);
-		const profile = store.profiles[sessionEntry.authProfileOverride];
-		const profileProvider = profile ? normalizeProviderId(profile.provider) : void 0;
-		const harnessPolicy = resolveAgentHarnessPolicy({
-			provider,
-			modelId: model,
-			config: cfg,
-			agentId: params.agentId,
-			sessionKey
-		});
-		const acceptedAuthProviders = listOpenAIAuthProfileProvidersForAgentRuntime({
-			provider,
-			harnessRuntime: harnessPolicy.runtime,
-			config: cfg
-		}).map(normalizeProviderId);
-		if (!profile || !acceptedAuthProviders.includes(profileProvider ?? "")) await clearSessionAuthProfileOverride({
-			sessionEntry,
-			sessionStore,
-			sessionKey,
-			storePath
-		});
-	}
-	let thinkingCatalog;
-	const resolveThinkingCatalog = async () => {
-		if (thinkingCatalog) return thinkingCatalog;
-		let catalogForThinking = modelCatalog && modelCatalog.length > 0 ? modelCatalog : allowedModelCatalog;
-		const selectedCatalogEntry = catalogForThinking?.find((entry) => entry.provider === provider && entry.id === model);
-		if (!modelCatalog && (!selectedCatalogEntry || selectedCatalogEntry.reasoning === void 0)) {
-			modelCatalog = await (await loadModelCatalogRuntime()).loadModelCatalog({ config: cfg });
-			logStage("catalog-loaded-for-thinking", `entries=${modelCatalog.length}`);
-			catalogForThinking = modelCatalog.find((entry) => entry.provider === provider && entry.id === model) || !catalogForThinking || catalogForThinking.length === 0 ? modelCatalog.length > 0 ? modelCatalog : allowedModelCatalog : allowedModelCatalog;
-		}
-		thinkingCatalog = catalogForThinking.length > 0 ? catalogForThinking : void 0;
-		return thinkingCatalog;
-	};
-	let defaultThinkingLevel;
-	const resolveDefaultThinkingLevel = async () => {
-		if (defaultThinkingLevel) return defaultThinkingLevel;
-		const agentThinkingDefault = agentEntry?.thinkingDefault;
-		const configuredThinkingDefault = agentCfg?.thinkingDefault;
-		const explicitThinkingDefault = agentThinkingDefault ?? configuredThinkingDefault;
-		if (explicitThinkingDefault) {
-			defaultThinkingLevel = explicitThinkingDefault;
-			return defaultThinkingLevel;
-		}
-		const catalogForThinking = await resolveThinkingCatalog();
-		defaultThinkingLevel = resolveThinkingDefault({
-			cfg,
-			provider,
-			model,
-			catalog: catalogForThinking
-		}) ?? "off";
-		return defaultThinkingLevel;
-	};
-	const resolveDefaultReasoningLevel = async () => {
-		let catalogForReasoning = modelCatalog ?? allowedModelCatalog;
-		if (!catalogForReasoning || catalogForReasoning.length === 0) {
-			modelCatalog = await (await loadModelCatalogRuntime()).loadModelCatalog({ config: cfg });
-			logStage("catalog-loaded-for-reasoning", `entries=${modelCatalog.length}`);
-			catalogForReasoning = modelCatalog;
-		}
-		return resolveReasoningDefault({
-			provider,
-			model,
-			catalog: catalogForReasoning
-		});
-	};
-	return {
-		provider,
-		model,
-		allowedModelKeys,
-		allowedModelCatalog,
-		resetModelOverride,
-		resetModelOverrideRef,
-		resolveThinkingCatalog,
-		resolveDefaultThinkingLevel,
-		resolveDefaultReasoningLevel,
-		needsModelCatalog
-	};
-}
-function resolveContextTokens(params) {
-	const modelContextTokens = resolveContextTokensForModel({
-		cfg: params.cfg,
-		provider: params.provider,
-		model: params.model,
-		allowAsyncLoad: false
-	});
-	const agentContextTokens = typeof params.agentCfg?.contextTokens === "number" && params.agentCfg.contextTokens > 0 ? Math.floor(params.agentCfg.contextTokens) : void 0;
-	if (agentContextTokens !== void 0) return modelContextTokens !== void 0 ? Math.min(agentContextTokens, modelContextTokens) : agentContextTokens;
-	return modelContextTokens ?? 2e5;
-}
-//#endregion
-export { createModelSelectionState as n, resolveContextTokens as r, createFastTestModelSelectionState as t };

package/dist/models-0m6kj9Kh.js

@@ -1,104 +0,0 @@
-import { s as readCodexModelListResponse } from "./protocol-validators-_gKDcd0x.js";
-//#region extensions/codex/src/app-server/models.ts
-async function listCodexAppServerModels(options = {}) {
-	return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) => requestModelListPage(client, {
-		...options,
-		timeoutMs
-	}));
-}
-async function listAllCodexAppServerModels(options = {}) {
-	const maxPages = normalizeMaxPages(options.maxPages);
-	return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) => {
-		const models = [];
-		let cursor = options.cursor;
-		let nextCursor;
-		for (let page = 0; page < maxPages; page += 1) {
-			const result = await requestModelListPage(client, {
-				...options,
-				timeoutMs,
-				cursor
-			});
-			models.push(...result.models);
-			nextCursor = result.nextCursor;
-			if (!nextCursor) return { models };
-			cursor = nextCursor;
-		}
-		return {
-			models,
-			nextCursor,
-			truncated: true
-		};
-	});
-}
-async function withCodexAppServerModelClient(options, run) {
-	const timeoutMs = options.timeoutMs ?? 2500;
-	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getSharedCodexAppServerClient } = await import("./shared-client-C3MyzMO-.js");
-	const client = useSharedClient ? await getSharedCodexAppServerClient({
-		startOptions: options.startOptions,
-		timeoutMs,
-		authProfileId: options.authProfileId,
-		agentDir: options.agentDir,
-		config: options.config
-	}) : await createIsolatedCodexAppServerClient({
-		startOptions: options.startOptions,
-		timeoutMs,
-		authProfileId: options.authProfileId,
-		agentDir: options.agentDir,
-		config: options.config
-	});
-	try {
-		return await run({
-			client,
-			timeoutMs
-		});
-	} finally {
-		if (!useSharedClient) client.close();
-	}
-}
-async function requestModelListPage(client, options) {
-	return readModelListResult(await client.request("model/list", {
-		limit: options.limit ?? null,
-		cursor: options.cursor ?? null,
-		includeHidden: options.includeHidden ?? null
-	}, { timeoutMs: options.timeoutMs }));
-}
-function readModelListResult(value) {
-	const response = readCodexModelListResponse(value);
-	if (!response) return { models: [] };
-	const models = response.data.map((entry) => readCodexModel(entry)).filter((entry) => entry !== void 0);
-	const nextCursor = response.nextCursor ?? void 0;
-	return {
-		models,
-		...nextCursor ? { nextCursor } : {}
-	};
-}
-function readCodexModel(value) {
-	const id = readNonEmptyString(value.id);
-	const model = readNonEmptyString(value.model) ?? id;
-	if (!id || !model) return;
-	return {
-		id,
-		model,
-		...readNonEmptyString(value.displayName) ? { displayName: readNonEmptyString(value.displayName) } : {},
-		...readNonEmptyString(value.description) ? { description: readNonEmptyString(value.description) } : {},
-		hidden: value.hidden,
-		isDefault: value.isDefault,
-		inputModalities: value.inputModalities,
-		supportedReasoningEfforts: readReasoningEfforts(value.supportedReasoningEfforts),
-		...readNonEmptyString(value.defaultReasoningEffort) ? { defaultReasoningEffort: readNonEmptyString(value.defaultReasoningEffort) } : {}
-	};
-}
-function readReasoningEfforts(value) {
-	const efforts = value.map((entry) => readNonEmptyString(entry.reasoningEffort)).filter((entry) => entry !== void 0);
-	return [...new Set(efforts)];
-}
-function readNonEmptyString(value) {
-	if (typeof value !== "string") return;
-	return value.trim() || void 0;
-}
-function normalizeMaxPages(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 20;
-}
-//#endregion
-export { listCodexAppServerModels as n, readModelListResult as r, listAllCodexAppServerModels as t };

package/dist/models-P3tVodj6.js

@@ -1,2 +0,0 @@
-import { n as listCodexAppServerModels } from "./models-0m6kj9Kh.js";
-export { listCodexAppServerModels };