@gaodefa/daocore 2026.5.99 → 2026.5.100

package/dist/mentions.types-BCI-lsmN.d.ts

@@ -0,0 +1,18 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+
+//#region src/auto-reply/reply/mentions.types.d.ts
+type BuildMentionRegexes = (cfg: DaoCoreConfig | undefined, agentId?: string) => RegExp[];
+type MatchesMentionPatterns = (text: string, mentionRegexes: RegExp[]) => boolean;
+type ExplicitMentionSignal = {
+  hasAnyMention: boolean;
+  isExplicitlyMentioned: boolean;
+  canResolveExplicit: boolean;
+};
+type MatchesMentionWithExplicit = (params: {
+  text: string;
+  mentionRegexes: RegExp[];
+  explicit?: ExplicitMentionSignal;
+  transcript?: string;
+}) => boolean;
+//#endregion
+export { MatchesMentionWithExplicit as i, ExplicitMentionSignal as n, MatchesMentionPatterns as r, BuildMentionRegexes as t };

package/dist/migration-Cv9c6g2y.d.ts

@@ -0,0 +1,45 @@
+import { $ as MigrationPlan, Y as MigrationItem, et as MigrationProviderContext, rt as MigrationSummary } from "./types-DEEPn4W72.js";
+
+//#region src/plugin-sdk/migration.d.ts
+declare const MIGRATION_REASON_MISSING_SOURCE_OR_TARGET = "missing source or target";
+declare const MIGRATION_REASON_TARGET_EXISTS = "target exists";
+declare function createMigrationItem(params: Omit<MigrationItem, "status"> & {
+  status?: MigrationItem["status"];
+}): MigrationItem;
+declare function markMigrationItemConflict(item: MigrationItem, reason: string): MigrationItem;
+declare function markMigrationItemError(item: MigrationItem, reason: string): MigrationItem;
+declare function markMigrationItemSkipped(item: MigrationItem, reason: string): MigrationItem;
+declare function summarizeMigrationItems(items: readonly MigrationItem[]): MigrationSummary;
+type MigrationConfigPatchDetails = {
+  path: string[];
+  value: unknown;
+};
+declare function readMigrationConfigPath(root: Record<string, unknown>, path: readonly string[]): unknown;
+declare function mergeMigrationConfigValue(left: unknown, right: unknown): unknown;
+declare function writeMigrationConfigPath(root: Record<string, unknown>, path: readonly string[], value: unknown): void;
+declare function hasMigrationConfigPatchConflict(config: MigrationProviderContext["config"], path: readonly string[], value: unknown): boolean;
+declare function createMigrationConfigPatchItem(params: {
+  id: string;
+  target: string;
+  path: string[];
+  value: unknown;
+  message: string;
+  conflict?: boolean;
+  reason?: string;
+  source?: string;
+  details?: Record<string, unknown>;
+}): MigrationItem;
+declare function createMigrationManualItem(params: {
+  id: string;
+  source: string;
+  message: string;
+  recommendation: string;
+}): MigrationItem;
+declare function readMigrationConfigPatchDetails(item: MigrationItem): MigrationConfigPatchDetails | undefined;
+declare function applyMigrationConfigPatchItem(ctx: MigrationProviderContext, item: MigrationItem): Promise<MigrationItem>;
+declare function applyMigrationManualItem(item: MigrationItem): MigrationItem;
+declare function redactMigrationValue(value: unknown): unknown;
+declare function redactMigrationItem(item: MigrationItem): MigrationItem;
+declare function redactMigrationPlan<T extends MigrationPlan>(plan: T): T;
+//#endregion
+export { redactMigrationPlan as _, applyMigrationManualItem as a, writeMigrationConfigPath as b, createMigrationManualItem as c, markMigrationItemError as d, markMigrationItemSkipped as f, redactMigrationItem as g, readMigrationConfigPath as h, applyMigrationConfigPatchItem as i, hasMigrationConfigPatchConflict as l, readMigrationConfigPatchDetails as m, MIGRATION_REASON_TARGET_EXISTS as n, createMigrationConfigPatchItem as o, mergeMigrationConfigValue as p, MigrationConfigPatchDetails as r, createMigrationItem as s, MIGRATION_REASON_MISSING_SOURCE_OR_TARGET as t, markMigrationItemConflict as u, redactMigrationValue as v, summarizeMigrationItems as y };

package/dist/model-B1PaJrHd.d.ts

@@ -0,0 +1,33 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { a as normalizeProviderResolvedModelWithPlugin, i as buildProviderUnknownModelHintWithPlugin, l as runProviderDynamicModel, n as applyProviderResolvedTransportWithPlugin, o as normalizeProviderTransportWithPlugin, s as prepareProviderDynamicModel, t as applyProviderResolvedModelCompatWithPlugins, u as shouldPreferProviderRuntimeResolvedModel } from "./provider-runtime-D0MotroP.js";
+import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { Api, Model } from "@earendil-works/pi-ai";
+
+//#region src/agents/pi-embedded-runner/model.d.ts
+type ProviderRuntimeHooks = {
+  applyProviderResolvedModelCompatWithPlugins?: (params: Parameters<typeof applyProviderResolvedModelCompatWithPlugins>[0]) => unknown;
+  applyProviderResolvedTransportWithPlugin?: (params: Parameters<typeof applyProviderResolvedTransportWithPlugin>[0]) => unknown;
+  buildProviderUnknownModelHintWithPlugin: (params: Parameters<typeof buildProviderUnknownModelHintWithPlugin>[0]) => string | undefined;
+  prepareProviderDynamicModel: (params: Parameters<typeof prepareProviderDynamicModel>[0]) => Promise<void>;
+  runProviderDynamicModel: (params: Parameters<typeof runProviderDynamicModel>[0]) => unknown;
+  shouldPreferProviderRuntimeResolvedModel?: (params: Parameters<typeof shouldPreferProviderRuntimeResolvedModel>[0]) => boolean;
+  normalizeProviderResolvedModelWithPlugin: (params: Parameters<typeof normalizeProviderResolvedModelWithPlugin>[0]) => unknown;
+  normalizeProviderTransportWithPlugin: typeof normalizeProviderTransportWithPlugin;
+};
+declare function resolveModelAsync(provider: string, modelId: string, agentDir?: string, cfg?: DaoCoreConfig, options?: {
+  authStorage?: AuthStorage;
+  modelRegistry?: ModelRegistry;
+  allowBundledStaticCatalogFallback?: boolean;
+  retryTransientProviderRuntimeMiss?: boolean;
+  runtimeHooks?: ProviderRuntimeHooks;
+  skipProviderRuntimeHooks?: boolean;
+  skipPiDiscovery?: boolean;
+  workspaceDir?: string;
+}): Promise<{
+  model?: Model<Api>;
+  error?: string;
+  authStorage: AuthStorage;
+  modelRegistry: ModelRegistry;
+}>;
+//#endregion
+export { resolveModelAsync as t };

package/dist/model-auth-DB025YdC.d.ts

@@ -0,0 +1,93 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { b as ResolvedProviderAuth } from "./types-core-C_yvb0RI.js";
+import { s as AuthProfileStore } from "./types-DCT-w72n.js";
+import { t as EnvApiKeyLookupOptions } from "./model-auth-env-CW5EMFvS.js";
+import { Api, Model } from "@earendil-works/pi-ai";
+
+//#region src/agents/model-auth.d.ts
+type ProviderCredentialPrecedence = "profile-first" | "env-first";
+type RuntimeProviderAuthLookup = {
+  envApiKey: Pick<EnvApiKeyLookupOptions, "aliasMap" | "candidateMap" | "authEvidenceMap">;
+  syntheticAuthProviderRefs?: readonly string[];
+};
+declare function createRuntimeProviderAuthLookup(params: {
+  cfg?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+}): RuntimeProviderAuthLookup;
+declare function getCustomProviderApiKey(cfg: DaoCoreConfig | undefined, provider: string): string | undefined;
+type ResolvedCustomProviderApiKey = {
+  apiKey: string;
+  source: string;
+};
+declare function resolveUsableCustomProviderApiKey(params: {
+  cfg: DaoCoreConfig | undefined;
+  provider: string;
+  env?: NodeJS.ProcessEnv;
+}): ResolvedCustomProviderApiKey | null;
+declare function hasUsableCustomProviderApiKey(cfg: DaoCoreConfig | undefined, provider: string, env?: NodeJS.ProcessEnv): boolean;
+declare function shouldPreferExplicitConfigApiKeyAuth(cfg: DaoCoreConfig | undefined, provider: string): boolean;
+declare function hasSyntheticLocalProviderAuthConfig(params: {
+  cfg: DaoCoreConfig | undefined;
+  provider: string;
+}): boolean;
+declare function hasRuntimeAvailableProviderAuth(params: {
+  provider: string;
+  cfg?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  allowPluginSyntheticAuth?: boolean;
+  runtimeLookup?: RuntimeProviderAuthLookup;
+}): boolean;
+declare function resolveApiKeyForProvider(params: {
+  provider: string;
+  cfg?: DaoCoreConfig;
+  profileId?: string;
+  preferredProfile?: string;
+  store?: AuthProfileStore;
+  agentDir?: string;
+  workspaceDir?: string;
+  /** When true, treat profileId as a user-locked selection that must not be
+   *  silently overridden by env/config credentials. */
+  lockedProfile?: boolean;
+  forceRefresh?: boolean;
+  credentialPrecedence?: ProviderCredentialPrecedence;
+  modelApi?: string;
+}): Promise<ResolvedProviderAuth>;
+type ModelAuthMode = "api-key" | "oauth" | "token" | "mixed" | "aws-sdk" | "unknown";
+declare function resolveModelAuthMode(provider?: string, cfg?: DaoCoreConfig, store?: AuthProfileStore, options?: {
+  workspaceDir?: string;
+}): ModelAuthMode | undefined;
+declare function hasAvailableAuthForProvider(params: {
+  provider: string;
+  cfg?: DaoCoreConfig;
+  preferredProfile?: string;
+  store?: AuthProfileStore;
+  agentDir?: string;
+  workspaceDir?: string;
+}): Promise<boolean>;
+declare function getApiKeyForModel(params: {
+  model: Model<Api>;
+  cfg?: DaoCoreConfig;
+  profileId?: string;
+  preferredProfile?: string;
+  store?: AuthProfileStore;
+  agentDir?: string;
+  workspaceDir?: string;
+  lockedProfile?: boolean;
+  credentialPrecedence?: ProviderCredentialPrecedence;
+}): Promise<ResolvedProviderAuth>;
+declare function applyLocalNoAuthHeaderOverride<T extends Model<Api>>(model: T, auth: ResolvedProviderAuth | null | undefined): T;
+/**
+ * When the provider config sets `authHeader: true`, inject an explicit
+ * `Authorization: Bearer <apiKey>` header into the model so downstream SDKs
+ * (e.g. `@google/genai`) send credentials via the standard HTTP Authorization
+ * header instead of vendor-specific headers like `x-goog-api-key`.
+ *
+ * This is a no-op when `authHeader` is not `true`, when no API key is
+ * available, or when the API key is a synthetic marker (e.g. local-server
+ * placeholders) rather than a real credential.
+ */
+declare function applyAuthHeaderOverride<T extends Model<Api>>(model: T, auth: ResolvedProviderAuth | null | undefined, cfg: DaoCoreConfig | undefined): T;
+//#endregion
+export { applyLocalNoAuthHeaderOverride as a, getCustomProviderApiKey as c, hasSyntheticLocalProviderAuthConfig as d, hasUsableCustomProviderApiKey as f, shouldPreferExplicitConfigApiKeyAuth as g, resolveUsableCustomProviderApiKey as h, applyAuthHeaderOverride as i, hasAvailableAuthForProvider as l, resolveModelAuthMode as m, ProviderCredentialPrecedence as n, createRuntimeProviderAuthLookup as o, resolveApiKeyForProvider as p, RuntimeProviderAuthLookup as r, getApiKeyForModel as s, ModelAuthMode as t, hasRuntimeAvailableProviderAuth as u };

package/dist/model-auth-env-CW5EMFvS.d.ts

@@ -0,0 +1,19 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { t as ProviderAuthEvidence } from "./provider-env-vars-CpPLRUjN.js";
+
+//#region src/agents/model-auth-env.d.ts
+type EnvApiKeyResult = {
+  apiKey: string;
+  source: string;
+};
+type EnvApiKeyLookupOptions = {
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  aliasMap?: Readonly<Record<string, string>>;
+  candidateMap?: Readonly<Record<string, readonly string[]>>;
+  authEvidenceMap?: Readonly<Record<string, readonly ProviderAuthEvidence[]>>;
+  skipSetupProviderFallback?: boolean;
+};
+declare function resolveEnvApiKey(provider: string, env?: NodeJS.ProcessEnv, options?: EnvApiKeyLookupOptions): EnvApiKeyResult | null;
+//#endregion
+export { EnvApiKeyResult as n, resolveEnvApiKey as r, EnvApiKeyLookupOptions as t };

package/dist/model-catalog-ljdQhwtW.d.ts

@@ -0,0 +1,41 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { n as PluginMetadataSnapshot } from "./plugin-metadata-snapshot.types-CFcWzFfQ.js";
+import { n as ModelInputType, t as ModelCatalogEntry } from "./model-catalog.types-BnioQy7H.js";
+import { t as pi_model_discovery_runtime_d_exports } from "./pi-model-discovery-runtime-BuSxhwZa.js";
+
+//#region src/agents/model-catalog-lookup.d.ts
+declare function modelSupportsInput(entry: ModelCatalogEntry | undefined, input: ModelInputType): boolean;
+declare function findModelInCatalog(catalog: ModelCatalogEntry[], provider: string, modelId: string): ModelCatalogEntry | undefined;
+declare function findModelCatalogEntry(catalog: ModelCatalogEntry[], params: {
+  provider?: string;
+  modelId: string;
+}): ModelCatalogEntry | undefined;
+//#endregion
+//#region src/agents/model-catalog.d.ts
+type PiSdkModule = typeof pi_model_discovery_runtime_d_exports;
+declare function resetModelCatalogCache(): void;
+declare function resetModelCatalogCacheForTest(): void;
+declare function setModelCatalogImportForTest(loader?: () => Promise<PiSdkModule>): void;
+declare function loadManifestModelCatalog(params: {
+  config: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  fallbackToMetadataScan?: boolean;
+  metadataSnapshot?: PluginMetadataSnapshot;
+}): ModelCatalogEntry[];
+declare function loadModelCatalog(params?: {
+  config?: DaoCoreConfig;
+  useCache?: boolean;
+  readOnly?: boolean;
+  metadataSnapshot?: PluginMetadataSnapshot;
+}): Promise<ModelCatalogEntry[]>;
+/**
+ * Check if a model supports image input based on its catalog entry.
+ */
+declare function modelSupportsVision(entry: ModelCatalogEntry | undefined): boolean;
+/**
+ * Check if a model supports native document/PDF input based on its catalog entry.
+ */
+declare function modelSupportsDocument(entry: ModelCatalogEntry | undefined): boolean;
+//#endregion
+export { resetModelCatalogCache as a, findModelCatalogEntry as c, modelSupportsVision as i, findModelInCatalog as l, loadModelCatalog as n, resetModelCatalogCacheForTest as o, modelSupportsDocument as r, setModelCatalogImportForTest as s, loadManifestModelCatalog as t, modelSupportsInput as u };

package/dist/model-overrides-4-1S_I0M.d.ts

@@ -0,0 +1,44 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { o as SessionEntry } from "./types-DyE5xc5O.js";
+import { n as ChannelMatchSource } from "./channel-config-SOo4scvx.js";
+
+//#region src/channels/model-overrides.d.ts
+type ChannelModelOverride = {
+  channel: string;
+  model: string;
+  matchKey?: string;
+  matchSource?: ChannelMatchSource;
+};
+type ChannelModelOverrideParams = {
+  cfg: DaoCoreConfig;
+  channel?: string | null;
+  groupId?: string | null;
+  groupChatType?: string | null;
+  groupChannel?: string | null;
+  groupSubject?: string | null;
+  parentSessionKey?: string | null;
+};
+declare function resolveChannelModelOverride(params: ChannelModelOverrideParams): ChannelModelOverride | null;
+//#endregion
+//#region src/config/agent-limits.d.ts
+declare function resolveAgentMaxConcurrent(cfg?: DaoCoreConfig): number;
+//#endregion
+//#region src/sessions/model-overrides.d.ts
+type ModelOverrideSelection = {
+  provider: string;
+  model: string;
+  isDefault?: boolean;
+};
+declare function applyModelOverrideToSessionEntry(params: {
+  entry: SessionEntry;
+  selection: ModelOverrideSelection;
+  profileOverride?: string;
+  profileOverrideSource?: "auto" | "user";
+  preserveAuthProfileOverride?: boolean;
+  selectionSource?: "auto" | "user";
+  markLiveSwitchPending?: boolean;
+}): {
+  updated: boolean;
+};
+//#endregion
+export { resolveAgentMaxConcurrent as n, resolveChannelModelOverride as r, applyModelOverrideToSessionEntry as t };

package/dist/model-selection-Dbz2KV_5.d.ts

@@ -0,0 +1,193 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { t as ModelCatalogEntry } from "./model-catalog.types-BnioQy7H.js";
+import { n as ModelRef, t as ModelManifestNormalizationContext } from "./model-selection-normalize-DEN01JHt.js";
+
+//#region src/agents/model-thinking-default.d.ts
+type ThinkLevel$1 = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "adaptive" | "max";
+declare function resolveThinkingDefault(params: {
+  cfg: DaoCoreConfig;
+  provider: string;
+  model: string;
+  catalog?: ModelCatalogEntry[];
+}): ThinkLevel$1;
+declare function resolveThinkingDefaultWithRuntimeCatalog(params: {
+  cfg: DaoCoreConfig;
+  provider: string;
+  model: string;
+  loadModelCatalog: () => Promise<ModelCatalogEntry[]>;
+}): Promise<ThinkLevel$1>;
+//#endregion
+//#region src/agents/model-selection-shared.d.ts
+type ModelManifestPlugins = ModelManifestNormalizationContext["manifestPlugins"];
+type ModelAliasIndex = {
+  byAlias: Map<string, {
+    alias: string;
+    ref: ModelRef;
+  }>;
+  byKey: Map<string, string[]>;
+};
+declare function inferUniqueProviderFromConfiguredModels(params: {
+  cfg: DaoCoreConfig;
+  model: string;
+} & ModelManifestNormalizationContext): string | undefined;
+declare function inferUniqueProviderFromCatalog(params: {
+  catalog: readonly ModelCatalogEntry[];
+  model: string;
+}): string | undefined;
+declare function resolveBareModelDefaultProvider(params: {
+  cfg: DaoCoreConfig;
+  catalog: readonly ModelCatalogEntry[];
+  model: string;
+  defaultProvider: string;
+} & ModelManifestNormalizationContext): string;
+declare function buildConfiguredAllowlistKeys(params: {
+  cfg: DaoCoreConfig | undefined;
+  defaultProvider: string;
+} & ModelManifestNormalizationContext): Set<string> | null;
+declare function buildModelAliasIndex(params: {
+  cfg: DaoCoreConfig;
+  defaultProvider: string;
+  allowManifestNormalization?: boolean;
+  allowPluginNormalization?: boolean;
+} & ModelManifestNormalizationContext): ModelAliasIndex;
+declare function resolveModelRefFromString(params: {
+  cfg?: DaoCoreConfig;
+  raw: string;
+  defaultProvider: string;
+  aliasIndex?: ModelAliasIndex;
+  allowManifestNormalization?: boolean;
+  allowPluginNormalization?: boolean;
+} & ModelManifestNormalizationContext): {
+  ref: ModelRef;
+  alias?: string;
+} | null;
+declare function resolveConfiguredModelRef(params: {
+  cfg: DaoCoreConfig;
+  defaultProvider: string;
+  defaultModel: string;
+  allowManifestNormalization?: boolean;
+  allowPluginNormalization?: boolean;
+} & ModelManifestNormalizationContext): ModelRef;
+type ModelRefStatus = {
+  key: string;
+  inCatalog: boolean;
+  allowAny: boolean;
+  allowed: boolean;
+};
+declare function buildConfiguredModelCatalog(params: {
+  cfg: DaoCoreConfig;
+  workspaceDir?: string;
+  manifestPlugins?: ModelManifestPlugins;
+}): ModelCatalogEntry[];
+declare function resolveHooksGmailModel(params: {
+  cfg: DaoCoreConfig;
+  defaultProvider: string;
+} & ModelManifestNormalizationContext): ModelRef | null;
+declare function normalizeModelSelection(value: unknown): string | undefined;
+//#endregion
+//#region src/agents/model-selection-cli.d.ts
+declare function isCliProvider(provider: string, cfg?: DaoCoreConfig): boolean;
+//#endregion
+//#region src/agents/model-selection.d.ts
+type ThinkLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "adaptive" | "max";
+declare function resolvePersistedOverrideModelRef(params: {
+  defaultProvider?: unknown;
+  overrideProvider?: unknown;
+  overrideModel?: unknown;
+  allowPluginNormalization?: boolean;
+}): ModelRef | null;
+/**
+ * Runtime-first resolver for persisted model metadata.
+ * Use this when callers intentionally want the last executed model identity.
+ */
+declare function resolvePersistedModelRef(params: {
+  defaultProvider?: unknown;
+  runtimeProvider?: unknown;
+  runtimeModel?: unknown;
+  overrideProvider?: unknown;
+  overrideModel?: unknown;
+  allowPluginNormalization?: boolean;
+}): ModelRef | null;
+/**
+ * Selected-model resolver for persisted model metadata.
+ * Use this for control/status/UI surfaces that should honor explicit session
+ * overrides before falling back to runtime identity.
+ */
+declare function resolvePersistedSelectedModelRef(params: {
+  defaultProvider?: unknown;
+  runtimeProvider?: unknown;
+  runtimeModel?: unknown;
+  overrideProvider?: unknown;
+  overrideModel?: unknown;
+  allowPluginNormalization?: boolean;
+}): ModelRef | null;
+declare function normalizeStoredOverrideModel(params: {
+  providerOverride?: unknown;
+  modelOverride?: unknown;
+}): {
+  providerOverride?: string;
+  modelOverride?: string;
+};
+declare function resolveAllowlistModelKey(raw: string, defaultProvider: string, cfg?: DaoCoreConfig, manifestPlugins?: ModelManifestNormalizationContext["manifestPlugins"]): string | null;
+declare function resolveDefaultModelForAgent(params: {
+  cfg: DaoCoreConfig;
+  agentId?: string;
+  allowPluginNormalization?: boolean;
+} & ModelManifestNormalizationContext): ModelRef;
+declare function canonicalizeCaseOnlyCatalogModelRef(params: {
+  raw: string | undefined;
+  cfg?: DaoCoreConfig;
+  defaultProvider: string;
+  loadCatalog: () => Promise<ModelCatalogEntry[]>;
+  aliasIndex?: ModelAliasIndex;
+  allowManifestNormalization?: boolean;
+  allowPluginNormalization?: boolean;
+  preserveAuthProfile?: boolean;
+}): Promise<string | undefined>;
+declare function resolveSubagentConfiguredModelSelection(params: {
+  cfg: DaoCoreConfig;
+  agentId: string;
+}): string | undefined;
+declare function resolveSubagentSpawnModelSelection(params: {
+  cfg: DaoCoreConfig;
+  agentId: string;
+  modelOverride?: unknown;
+}): string;
+declare function buildAllowedModelSet(params: {
+  cfg: DaoCoreConfig;
+  catalog: ModelCatalogEntry[];
+  defaultProvider: string;
+  defaultModel?: string;
+  agentId?: string;
+} & ModelManifestNormalizationContext): {
+  allowAny: boolean;
+  allowedCatalog: ModelCatalogEntry[];
+  allowedKeys: Set<string>;
+};
+declare function getModelRefStatus(params: {
+  cfg: DaoCoreConfig;
+  catalog: ModelCatalogEntry[];
+  ref: ModelRef;
+  defaultProvider: string;
+  defaultModel?: string;
+} & ModelManifestNormalizationContext): ModelRefStatus;
+declare function resolveAllowedModelRef(params: {
+  cfg: DaoCoreConfig;
+  catalog: ModelCatalogEntry[];
+  raw: string;
+  defaultProvider: string;
+  defaultModel?: string;
+} & ModelManifestNormalizationContext): {
+  ref: ModelRef;
+  key: string;
+} | {
+  error: string;
+};
+/** Default reasoning level when session/directive do not set it: "on" if model supports reasoning, else "off". */
+declare function resolveReasoningDefault(params: {
+  provider: string;
+  model: string;
+  catalog?: ModelCatalogEntry[];
+}): "on" | "off";
+//#endregion
+export { normalizeModelSelection as C, resolveModelRefFromString as D, resolveHooksGmailModel as E, resolveThinkingDefault as O, inferUniqueProviderFromConfiguredModels as S, resolveConfiguredModelRef as T, ModelRefStatus as _, normalizeStoredOverrideModel as a, buildModelAliasIndex as b, resolveDefaultModelForAgent as c, resolvePersistedSelectedModelRef as d, resolveReasoningDefault as f, ModelAliasIndex as g, isCliProvider as h, getModelRefStatus as i, resolveThinkingDefaultWithRuntimeCatalog as k, resolvePersistedModelRef as l, resolveSubagentSpawnModelSelection as m, buildAllowedModelSet as n, resolveAllowedModelRef as o, resolveSubagentConfiguredModelSelection as p, canonicalizeCaseOnlyCatalogModelRef as r, resolveAllowlistModelKey as s, ThinkLevel as t, resolvePersistedOverrideModelRef as u, buildConfiguredAllowlistKeys as v, resolveBareModelDefaultProvider as w, inferUniqueProviderFromCatalog as x, buildConfiguredModelCatalog as y };

package/dist/model-selection-normalize-DEN01JHt.d.ts

@@ -0,0 +1,21 @@
+import { t as PluginManifestRecord } from "./manifest-registry-C-PpGA-Y.js";
+
+//#region src/agents/model-selection-normalize.d.ts
+type ModelRef = {
+  provider: string;
+  model: string;
+};
+type ModelManifestNormalizationContext = {
+  manifestPlugins?: readonly Pick<PluginManifestRecord, "modelIdNormalization">[];
+};
+declare function modelKey(provider: string, model: string): string;
+declare function legacyModelKey(provider: string, model: string): string | null;
+type ModelRefNormalizeOptions = ModelManifestNormalizationContext & {
+  allowManifestNormalization?: boolean;
+  allowPluginNormalization?: boolean;
+};
+declare function normalizeModelRef(provider: string, model: string, options?: ModelRefNormalizeOptions): ModelRef;
+type ParseModelRefOptions = ModelRefNormalizeOptions;
+declare function parseModelRef(raw: string, defaultProvider: string, options?: ParseModelRefOptions): ModelRef | null;
+//#endregion
+export { normalizeModelRef as a, modelKey as i, ModelRef as n, parseModelRef as o, legacyModelKey as r, ModelManifestNormalizationContext as t };

package/dist/models-6biHqtHa.d.ts

@@ -0,0 +1,24 @@
+import { s as ModelDefinitionConfig } from "./types.models-BXrRAuSB.js";
+import { Dn as ProviderResolveDynamicModelContext, Qn as ProviderRuntimeModel } from "./types-DEEPn4W72.js";
+//#region extensions/github-copilot/models.d.ts
+declare const PROVIDER_ID = "github-copilot";
+declare function resolveCopilotForwardCompatModel(ctx: ProviderResolveDynamicModelContext): ProviderRuntimeModel | undefined;
+type FetchCopilotModelCatalogParams = {
+  /** Short-lived Copilot API token (from `resolveCopilotApiToken`). */copilotApiToken: string; /** Resolved baseUrl from the same token-exchange response. */
+  baseUrl: string; /** Optional fetch override for testing. */
+  fetchImpl?: typeof fetch; /** Optional AbortSignal; defaults to a 10s timeout. */
+  signal?: AbortSignal;
+};
+/**
+ * Fetch the live Copilot model catalog from `${baseUrl}/models` and project it
+ * into `ModelDefinitionConfig[]`. Used by the plugin's discovery hook so the
+ * runtime catalog tracks per-account entitlements + accurate context windows
+ * without manifest churn.
+ *
+ * Filters out non-chat objects (embeddings, routers) and internal router ids.
+ * On any HTTP/parse failure the caller should fall back to the static manifest
+ * catalog; this function throws so the caller decides the recovery shape.
+ */
+declare function fetchCopilotModelCatalog(params: FetchCopilotModelCatalogParams): Promise<ModelDefinitionConfig[]>;
+//#endregion
+export { resolveCopilotForwardCompatModel as i, PROVIDER_ID as n, fetchCopilotModelCatalog as r, FetchCopilotModelCatalogParams as t };

package/dist/models-BmW-KPW72.d.ts

@@ -0,0 +1,33 @@
+import { r as CodexAppServerStartOptions } from "./client-DWZAI6aL.js";
+import { t as resolveCodexAppServerAuthProfileIdForAgent } from "./auth-bridge-BTe4K96S.js";
+
+//#region extensions/codex/src/app-server/models.d.ts
+type CodexAppServerModel = {
+  id: string;
+  model: string;
+  displayName?: string;
+  description?: string;
+  hidden?: boolean;
+  isDefault?: boolean;
+  inputModalities: string[];
+  supportedReasoningEfforts: string[];
+  defaultReasoningEffort?: string;
+};
+type CodexAppServerModelListResult = {
+  models: CodexAppServerModel[];
+  nextCursor?: string;
+  truncated?: boolean;
+};
+type CodexAppServerListModelsOptions = {
+  limit?: number;
+  cursor?: string;
+  includeHidden?: boolean;
+  timeoutMs?: number;
+  startOptions?: CodexAppServerStartOptions;
+  authProfileId?: string;
+  agentDir?: string;
+  config?: Parameters<typeof resolveCodexAppServerAuthProfileIdForAgent>[0]["config"];
+  sharedClient?: boolean;
+};
+//#endregion
+export { CodexAppServerModel as n, CodexAppServerModelListResult as r, CodexAppServerListModelsOptions as t };

package/dist/models-BrOqgEoU.d.ts

@@ -0,0 +1,10 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+//#region extensions/vllm/models.d.ts
+type ModelsConfig = NonNullable<DaoCoreConfig["models"]>;
+type ProviderConfig = NonNullable<ModelsConfig["providers"]>[string];
+declare function buildVllmProvider(params?: {
+  baseUrl?: string;
+  apiKey?: string;
+}): Promise<ProviderConfig>;
+//#endregion
+export { buildVllmProvider as t };

package/dist/models-C1tvj4Fs.d.ts

@@ -0,0 +1,10 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+//#region extensions/sglang/models.d.ts
+type ModelsConfig = NonNullable<DaoCoreConfig["models"]>;
+type ProviderConfig = NonNullable<ModelsConfig["providers"]>[string];
+declare function buildSglangProvider(params?: {
+  baseUrl?: string;
+  apiKey?: string;
+}): Promise<ProviderConfig>;
+//#endregion
+export { buildSglangProvider as t };

package/dist/music-generation-BE8CYDeD.d.ts

@@ -0,0 +1,25 @@
+import { t as GeneratedMusicAsset } from "./types-CMaxnCp0.js";
+
+//#region src/music-generation/provider-assets.d.ts
+type GeneratedMusicFileCandidate = {
+  url: string;
+  mimeType?: string;
+  fileName?: string;
+};
+declare function extractGeneratedMusicFileCandidates(payload: unknown, keys?: readonly string[]): GeneratedMusicFileCandidate[];
+declare function generatedMusicAssetFromBase64(params: {
+  base64: string;
+  mimeType: string;
+  index?: number;
+  fileName?: string;
+}): GeneratedMusicAsset;
+declare function downloadGeneratedMusicAsset(params: {
+  candidate: GeneratedMusicFileCandidate;
+  timeoutMs: number;
+  fetchFn: typeof fetch;
+  provider: string;
+  requestFailedMessage: string;
+  index?: number;
+}): Promise<GeneratedMusicAsset>;
+//#endregion
+export { generatedMusicAssetFromBase64 as i, downloadGeneratedMusicAsset as n, extractGeneratedMusicFileCandidates as r, GeneratedMusicFileCandidate as t };

package/dist/music-generation-provider-B9EGqC0r.d.ts

@@ -0,0 +1,17 @@
+import { c as MusicGenerationProvider } from "./types-CMaxnCp0.js";
+//#region extensions/openrouter/music-generation-provider.d.ts
+type OpenRouterAudioStreamResult = {
+  audioBuffer: Buffer;
+  transcript: string;
+};
+type OpenRouterStreamDeadline = {
+  deadlineAtMs: number;
+  timeoutMs: number;
+};
+declare function readOpenRouterAudioStream(response: Response, deadline: OpenRouterStreamDeadline): Promise<OpenRouterAudioStreamResult>;
+declare function buildOpenRouterMusicGenerationProvider(): MusicGenerationProvider;
+declare const openRouterMusicTestInternals: {
+  readOpenRouterAudioStream: typeof readOpenRouterAudioStream;
+};
+//#endregion
+export { openRouterMusicTestInternals as n, buildOpenRouterMusicGenerationProvider as t };

package/dist/music-generation-provider-BLKruMOr.d.ts

@@ -0,0 +1,8 @@
+import { c as MusicGenerationProvider } from "./types-CMaxnCp0.js";
+declare namespace music_generation_provider_d_exports {
+  export { buildMinimaxMusicGenerationProvider, buildMinimaxPortalMusicGenerationProvider };
+}
+declare function buildMinimaxMusicGenerationProvider(): MusicGenerationProvider;
+declare function buildMinimaxPortalMusicGenerationProvider(): MusicGenerationProvider;
+//#endregion
+export { buildMinimaxPortalMusicGenerationProvider as n, music_generation_provider_d_exports as r, buildMinimaxMusicGenerationProvider as t };

package/dist/music-generation-provider-DXn5EdA6.d.ts

@@ -0,0 +1,5 @@
+import { c as MusicGenerationProvider } from "./types-CMaxnCp0.js";
+//#region extensions/fal/music-generation-provider.d.ts
+declare function buildFalMusicGenerationProvider(): MusicGenerationProvider;
+//#endregion
+export { buildFalMusicGenerationProvider as t };