@gaodefa/daocore 2026.5.99 → 2026.5.100

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

@@ -0,0 +1,62 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { f as ModelProviderDeclarationConfig, u as ModelProviderConfig } from "./types.models-BXrRAuSB.js";
+import { Lt as ProviderCatalogContext, zt as ProviderCatalogResult } from "./types-DEEPn4W72.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-BNcOgMVp.d.ts

@@ -0,0 +1,7 @@
+import { n as DispatchReplyWithDispatcher, t as DispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher.types-4jJAfyq8.js";
+
+//#region src/auto-reply/reply/provider-dispatcher.d.ts
+declare const dispatchReplyWithBufferedBlockDispatcher: DispatchReplyWithBufferedBlockDispatcher;
+declare const dispatchReplyWithDispatcher: DispatchReplyWithDispatcher;
+//#endregion
+export { dispatchReplyWithDispatcher as n, dispatchReplyWithBufferedBlockDispatcher as t };

package/dist/provider-dispatcher.runtime.d.ts

@@ -1,3 +1,3 @@
-import { n as DispatchReplyWithDispatcher, t as DispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher.types-CiIZSB4-.js";
-import { n as dispatchReplyWithDispatcher, t as dispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher-BBFyufcu.js";
+import { n as DispatchReplyWithDispatcher, t as DispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher.types-4jJAfyq8.js";
+import { n as dispatchReplyWithDispatcher, t as dispatchReplyWithBufferedBlockDispatcher } from "./provider-dispatcher-BNcOgMVp.js";
 export { type DispatchReplyWithBufferedBlockDispatcher, type DispatchReplyWithDispatcher, dispatchReplyWithBufferedBlockDispatcher, dispatchReplyWithDispatcher };

package/dist/provider-dispatcher.types-4jJAfyq8.d.ts

@@ -0,0 +1,80 @@
+import { Pn as SilentReplyConversationType, r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { v as HumanDelayConfig } from "./types.base-tQh4FMBR.js";
+import { n as GetReplyOptions, s as ReplyPayload } from "./get-reply-options.types-BXrapyJ-.js";
+import { n as MsgContext, t as FinalizedMsgContext } from "./templating-Bw49ZLzH.js";
+import { n as ReplyDispatcher, t as ReplyDispatchKind } from "./reply-dispatcher.types-DxImExDW.js";
+import { r as GetReplyFromConfig, t as DispatchFromConfigResult } from "./dispatch-from-config.types-D_d1xz7D.js";
+import { i as ResponsePrefixContext, n as TypingCallbacks } from "./typing-Bihu7fKL.js";
+
+//#region src/auto-reply/reply/normalize-reply.d.ts
+type NormalizeReplySkipReason = "empty" | "silent" | "heartbeat";
+//#endregion
+//#region src/auto-reply/reply/reply-dispatcher.d.ts
+type ReplyDispatchErrorHandler = (err: unknown, info: {
+  kind: ReplyDispatchKind;
+}) => void;
+type ReplyDispatchSkipHandler = (payload: ReplyPayload, info: {
+  kind: ReplyDispatchKind;
+  reason: NormalizeReplySkipReason;
+}) => void;
+type ReplyDispatchDeliverer = (payload: ReplyPayload, info: {
+  kind: ReplyDispatchKind;
+}) => Promise<unknown>;
+type ReplyDispatchBeforeDeliver = (payload: ReplyPayload, info: {
+  kind: ReplyDispatchKind;
+}) => Promise<ReplyPayload | null> | ReplyPayload | null;
+type ReplyDispatcherOptions = {
+  deliver: ReplyDispatchDeliverer;
+  silentReplyContext?: {
+    cfg?: DaoCoreConfig;
+    sessionKey?: string;
+    surface?: string;
+    conversationType?: SilentReplyConversationType;
+  };
+  responsePrefix?: string;
+  transformReplyPayload?: (payload: ReplyPayload) => ReplyPayload | null; /** Static context for response prefix template interpolation. */
+  responsePrefixContext?: ResponsePrefixContext;
+  /** Dynamic context provider for response prefix template interpolation.
+   * Called at normalization time, after model selection is complete. */
+  responsePrefixContextProvider?: () => ResponsePrefixContext;
+  onHeartbeatStrip?: () => void;
+  onIdle?: () => void;
+  onError?: ReplyDispatchErrorHandler;
+  onSkip?: ReplyDispatchSkipHandler; /** Human-like delay between block replies for natural rhythm. */
+  humanDelay?: HumanDelayConfig;
+  beforeDeliver?: ReplyDispatchBeforeDeliver;
+};
+type ReplyDispatcherWithTypingOptions = Omit<ReplyDispatcherOptions, "onIdle"> & {
+  typingCallbacks?: TypingCallbacks;
+  onReplyStart?: () => Promise<void> | void;
+  onIdle?: () => void; /** Called when the typing controller is cleaned up (e.g., on NO_REPLY). */
+  onCleanup?: () => void;
+};
+type ReplyDispatcherWithTypingResult = {
+  dispatcher: ReplyDispatcher;
+  replyOptions: Pick<GetReplyOptions, "onReplyStart" | "onTypingController" | "onTypingCleanup">;
+  markDispatchIdle: () => void; /** Signal that the model run is complete so the typing controller can stop. */
+  markRunComplete: () => void;
+};
+declare function createReplyDispatcher(options: ReplyDispatcherOptions): ReplyDispatcher;
+declare function createReplyDispatcherWithTyping(options: ReplyDispatcherWithTypingOptions): ReplyDispatcherWithTypingResult;
+//#endregion
+//#region src/auto-reply/reply/provider-dispatcher.types.d.ts
+type DispatchReplyContext = MsgContext | FinalizedMsgContext;
+type DispatchReplyOptions = Omit<GetReplyOptions, "onBlockReply">;
+type DispatchReplyWithBufferedBlockDispatcher = (params: {
+  ctx: DispatchReplyContext;
+  cfg: DaoCoreConfig;
+  dispatcherOptions: ReplyDispatcherWithTypingOptions;
+  replyOptions?: DispatchReplyOptions;
+  replyResolver?: GetReplyFromConfig;
+}) => Promise<DispatchFromConfigResult>;
+type DispatchReplyWithDispatcher = (params: {
+  ctx: DispatchReplyContext;
+  cfg: DaoCoreConfig;
+  dispatcherOptions: ReplyDispatcherOptions;
+  replyOptions?: DispatchReplyOptions;
+  replyResolver?: GetReplyFromConfig;
+}) => Promise<DispatchFromConfigResult>;
+//#endregion
+export { createReplyDispatcher as a, ReplyDispatcherWithTypingOptions as i, DispatchReplyWithDispatcher as n, createReplyDispatcherWithTyping as o, ReplyDispatcherOptions as r, DispatchReplyWithBufferedBlockDispatcher as t };

package/dist/provider-env-vars-CpPLRUjN.d.ts

@@ -0,0 +1,25 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { n as PluginMetadataSnapshot } from "./plugin-metadata-snapshot.types-CFcWzFfQ.js";
+//#region src/secrets/provider-env-vars.d.ts
+type ProviderEnvVarLookupParams = {
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  includeUntrustedWorkspacePlugins?: boolean;
+  metadataSnapshot?: PluginMetadataSnapshot;
+};
+type ProviderAuthEvidence = {
+  type: "local-file-with-env";
+  fileEnvVar?: string;
+  fallbackPaths?: readonly string[];
+  requiresAnyEnv?: readonly string[];
+  requiresAllEnv?: readonly string[];
+  credentialMarker: string;
+  source?: string;
+};
+declare function resolveProviderAuthEnvVarCandidates(params?: ProviderEnvVarLookupParams): Record<string, readonly string[]>;
+declare function getProviderEnvVars(providerId: string, params?: ProviderEnvVarLookupParams): string[];
+declare function listKnownProviderAuthEnvVarNames(params?: ProviderEnvVarLookupParams): string[];
+declare function omitEnvKeysCaseInsensitive(baseEnv: NodeJS.ProcessEnv, keys: Iterable<string>): NodeJS.ProcessEnv;
+//#endregion
+export { resolveProviderAuthEnvVarCandidates as a, omitEnvKeysCaseInsensitive as i, getProviderEnvVars as n, listKnownProviderAuthEnvVarNames as r, ProviderAuthEvidence as t };

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

@@ -0,0 +1,61 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.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-DEEPn4W72.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 };

package/dist/provider-model-shared-DE_pdwra.d.ts

@@ -0,0 +1,143 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { o as ModelCompatConfig } from "./types.models-BXrRAuSB.js";
+import { Dn as ProviderResolveDynamicModelContext, Fn as ProviderSanitizeReplayHistoryContext, Qn as ProviderRuntimeModel, Zn as ProviderThinkingProfile, bn as ProviderReplayPolicy, oi as ProviderSystemPromptContribution, sn as ProviderPlugin, vn as ProviderReasoningOutputMode, xn as ProviderReplayPolicyContext } from "./types-DEEPn4W72.js";
+import { Api, Model } from "@earendil-works/pi-ai";
+import { AgentMessage } from "@earendil-works/pi-agent-core";
+
+//#region src/plugins/provider-replay-helpers.d.ts
+/** @deprecated Provider replay helper; prefer provider-local replay hooks. */
+declare function buildOpenAICompatibleReplayPolicy(modelApi: string | null | undefined, options?: {
+  sanitizeToolCallIds?: boolean;
+  modelId?: string | null;
+  dropReasoningFromHistory?: boolean;
+}): ProviderReplayPolicy | undefined;
+/** @deprecated Anthropic-family provider replay helper; prefer provider-local replay hooks. */
+declare function buildStrictAnthropicReplayPolicy(options?: {
+  dropThinkingBlocks?: boolean;
+  sanitizeToolCallIds?: boolean;
+  preserveNativeAnthropicToolUseIds?: boolean;
+}): ProviderReplayPolicy;
+/** @deprecated Anthropic-family provider replay helper; prefer provider-local replay hooks. */
+declare function buildAnthropicReplayPolicyForModel(modelId?: string): ProviderReplayPolicy;
+/** @deprecated Anthropic-family provider replay helper; prefer provider-local replay hooks. */
+declare function buildNativeAnthropicReplayPolicyForModel(modelId?: string): ProviderReplayPolicy;
+/** @deprecated Provider replay helper; prefer provider-local replay hooks. */
+declare function buildHybridAnthropicOrOpenAIReplayPolicy(ctx: ProviderReplayPolicyContext, options?: {
+  anthropicModelDropThinkingBlocks?: boolean;
+}): ProviderReplayPolicy | undefined;
+/** @deprecated Google provider replay helper; prefer provider-local replay hooks. */
+declare function buildGoogleGeminiReplayPolicy(): ProviderReplayPolicy;
+/** @deprecated Google provider replay helper; prefer provider-local replay hooks. */
+declare function buildPassthroughGeminiSanitizingReplayPolicy(modelId?: string): ProviderReplayPolicy;
+/** @deprecated Google provider replay helper; prefer provider-local replay hooks. */
+declare function sanitizeGoogleGeminiReplayHistory(ctx: ProviderSanitizeReplayHistoryContext): AgentMessage[];
+/** @deprecated Provider replay helper; prefer provider-local replay hooks. */
+declare function resolveTaggedReasoningOutputMode(): ProviderReasoningOutputMode;
+//#endregion
+//#region src/plugin-sdk/provider-model-id-normalize.d.ts
+declare function normalizeGooglePreviewModelId(id: string): string;
+declare function normalizeAntigravityPreviewModelId(id: string): string;
+//#endregion
+//#region src/agents/gpt5-prompt-overlay.d.ts
+/** @deprecated OpenAI/Codex provider-owned prompt overlay helper; do not use from third-party plugins. */
+declare const GPT5_FRIENDLY_CHAT_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.";
+/** @deprecated OpenAI/Codex provider-owned prompt overlay helper; do not use from third-party plugins. */
+declare const GPT5_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.";
+/** @deprecated OpenAI/Codex provider-owned prompt overlay helper; do not use from third-party plugins. */
+declare const GPT5_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.\n\n### 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.";
+/** @deprecated OpenAI/Codex provider-owned prompt overlay helper; do not use from third-party plugins. */
+declare const 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>";
+/** @deprecated OpenAI/Codex provider-owned prompt overlay helper; do not use from third-party plugins. */
+type Gpt5PromptOverlayMode = "friendly" | "off";
+/** @deprecated OpenAI/Codex provider-owned prompt overlay helper; do not use from third-party plugins. */
+declare function normalizeGpt5PromptOverlayMode(value: unknown): Gpt5PromptOverlayMode | undefined;
+/** @deprecated OpenAI/Codex provider-owned prompt overlay helper; do not use from third-party plugins. */
+declare function resolveGpt5PromptOverlayMode(config?: DaoCoreConfig, legacyPluginConfig?: Record<string, unknown>, params?: {
+  providerId?: string;
+}): Gpt5PromptOverlayMode;
+/** @deprecated OpenAI/Codex provider-owned prompt overlay helper; do not use from third-party plugins. */
+declare function isGpt5ModelId(modelId?: string): boolean;
+/** @deprecated OpenAI/Codex provider-owned prompt overlay helper; do not use from third-party plugins. */
+declare function resolveGpt5SystemPromptContribution(params: {
+  config?: DaoCoreConfig;
+  providerId?: string;
+  modelId?: string;
+  legacyPluginConfig?: Record<string, unknown>;
+  enabled?: boolean;
+  trigger?: "cron" | "heartbeat" | "manual" | "memory" | "overflow" | "user";
+  includeHeartbeatGuidance?: boolean;
+}): ProviderSystemPromptContribution | undefined;
+/** @deprecated OpenAI/Codex provider-owned prompt overlay helper; do not use from third-party plugins. */
+declare function renderGpt5PromptOverlay(params: {
+  config?: DaoCoreConfig;
+  providerId?: string;
+  modelId?: string;
+  legacyPluginConfig?: Record<string, unknown>;
+  enabled?: boolean;
+}): string | undefined;
+//#endregion
+//#region src/plugins/provider-model-compat.d.ts
+/** @deprecated Provider-owned model compat helper; do not use from third-party plugins. */
+declare function applyModelCompatPatch<T extends {
+  compat?: ModelCompatConfig;
+}>(model: T, patch: Partial<ModelCompatConfig> & Record<string, unknown>): T;
+declare function hasToolSchemaProfile(modelOrCompat: {
+  compat?: unknown;
+} | ModelCompatConfig | undefined, profile: string): boolean;
+declare function hasNativeWebSearchTool(modelOrCompat: {
+  compat?: unknown;
+} | ModelCompatConfig | undefined): boolean;
+declare function resolveToolCallArgumentsEncoding(modelOrCompat: {
+  compat?: unknown;
+} | ModelCompatConfig | undefined): ModelCompatConfig["toolCallArgumentsEncoding"] | undefined;
+declare function resolveUnsupportedToolSchemaKeywords(modelOrCompat: {
+  compat?: unknown;
+} | ModelCompatConfig | undefined): ReadonlySet<string>;
+declare function normalizeModelCompat(model: Model<Api>): Model<Api>;
+//#endregion
+//#region src/plugins/provider-model-helpers.d.ts
+declare function matchesExactOrPrefix(id: string, values: readonly string[]): boolean;
+declare function cloneFirstTemplateModel(params: {
+  providerId: string;
+  modelId: string;
+  templateIds: readonly string[];
+  ctx: ProviderResolveDynamicModelContext;
+  patch?: Partial<ProviderRuntimeModel>;
+}): ProviderRuntimeModel | undefined;
+//#endregion
+//#region src/plugin-sdk/provider-model-shared.d.ts
+/** @deprecated Proxy provider-owned model helper; do not use from third-party plugins. */
+declare function isProxyReasoningUnsupportedModelHint(modelId: string): boolean;
+/** @deprecated Anthropic provider-owned model helper; do not use from third-party plugins. */
+declare function isClaudeAdaptiveThinkingDefaultModelId(modelId: string): boolean;
+/** @deprecated Anthropic provider-owned model helper; do not use from third-party plugins. */
+declare function resolveClaudeThinkingProfile(modelId: string): ProviderThinkingProfile;
+type ProviderReplayFamily = "openai-compatible" | "anthropic-by-model" | "native-anthropic-by-model" | "google-gemini" | "passthrough-gemini" | "hybrid-anthropic-openai";
+type ProviderReplayFamilyHooks = Pick<ProviderPlugin, "buildReplayPolicy" | "sanitizeReplayHistory" | "resolveReasoningOutputMode">;
+type BuildProviderReplayFamilyHooksOptions = {
+  family: "openai-compatible";
+  sanitizeToolCallIds?: boolean;
+  dropReasoningFromHistory?: boolean;
+} | {
+  family: "anthropic-by-model";
+} | {
+  family: "native-anthropic-by-model";
+} | {
+  family: "google-gemini";
+} | {
+  family: "passthrough-gemini";
+} | {
+  family: "hybrid-anthropic-openai";
+  anthropicModelDropThinkingBlocks?: boolean;
+};
+declare function buildProviderReplayFamilyHooks(options: BuildProviderReplayFamilyHooksOptions): ProviderReplayFamilyHooks;
+/** @deprecated Provider-owned replay hook shortcut; use local provider hooks instead. */
+declare const OPENAI_COMPATIBLE_REPLAY_HOOKS: ProviderReplayFamilyHooks;
+/** @deprecated Anthropic provider-owned replay hook shortcut; use local provider hooks instead. */
+declare const ANTHROPIC_BY_MODEL_REPLAY_HOOKS: ProviderReplayFamilyHooks;
+/** @deprecated Anthropic provider-owned replay hook shortcut; use local provider hooks instead. */
+declare const NATIVE_ANTHROPIC_REPLAY_HOOKS: ProviderReplayFamilyHooks;
+/** @deprecated Google provider-owned replay hook shortcut; use local provider hooks instead. */
+declare const PASSTHROUGH_GEMINI_REPLAY_HOOKS: ProviderReplayFamilyHooks;
+//#endregion
+export { buildAnthropicReplayPolicyForModel as A, isGpt5ModelId as C, resolveGpt5SystemPromptContribution as D, resolveGpt5PromptOverlayMode as E, buildPassthroughGeminiSanitizingReplayPolicy as F, buildStrictAnthropicReplayPolicy as I, resolveTaggedReasoningOutputMode as L, buildHybridAnthropicOrOpenAIReplayPolicy as M, buildNativeAnthropicReplayPolicyForModel as N, normalizeAntigravityPreviewModelId as O, buildOpenAICompatibleReplayPolicy as P, sanitizeGoogleGeminiReplayHistory as R, Gpt5PromptOverlayMode as S, renderGpt5PromptOverlay as T, resolveUnsupportedToolSchemaKeywords as _, ProviderReplayFamily as a, GPT5_FRIENDLY_PROMPT_OVERLAY as b, isProxyReasoningUnsupportedModelHint as c, matchesExactOrPrefix as d, applyModelCompatPatch as f, resolveToolCallArgumentsEncoding as g, normalizeModelCompat as h, PASSTHROUGH_GEMINI_REPLAY_HOOKS as i, buildGoogleGeminiReplayPolicy as j, normalizeGooglePreviewModelId as k, resolveClaudeThinkingProfile as l, hasToolSchemaProfile as m, NATIVE_ANTHROPIC_REPLAY_HOOKS as n, buildProviderReplayFamilyHooks as o, hasNativeWebSearchTool as p, OPENAI_COMPATIBLE_REPLAY_HOOKS as r, isClaudeAdaptiveThinkingDefaultModelId as s, ANTHROPIC_BY_MODEL_REPLAY_HOOKS as t, cloneFirstTemplateModel as u, GPT5_BEHAVIOR_CONTRACT as v, normalizeGpt5PromptOverlayMode as w, GPT5_HEARTBEAT_PROMPT_OVERLAY as x, GPT5_FRIENDLY_CHAT_PROMPT_OVERLAY as y };

package/dist/provider-models-BHHX3Y_p.d.ts

@@ -0,0 +1,12 @@
+import { Dn as ProviderResolveDynamicModelContext } from "./types-DEEPn4W72.js";
+//#region extensions/xai/provider-models.d.ts
+declare function isModernXaiModel(modelId: string): boolean;
+declare function resolveXaiForwardCompatModel(params: {
+  providerId: string;
+  ctx: ProviderResolveDynamicModelContext;
+}): (import("@earendil-works/pi-ai").Model<import("@earendil-works/pi-ai").Api> & {
+  compat: Record<string, unknown>;
+  thinkingLevelMap: Partial<Record<"off" | "minimal" | "high" | "low" | "medium" | "xhigh", string | null>>;
+}) | undefined;
+//#endregion
+export { resolveXaiForwardCompatModel as n, isModernXaiModel as t };

package/dist/provider-onboard-ClQrWEfH.d.ts

@@ -0,0 +1,91 @@
+import { r as DaoCoreConfig, wn as AgentModelEntryConfig } from "./types.daocore-CNMq809i.js";
+import { a as ModelApi, s as ModelDefinitionConfig, u as ModelProviderConfig } from "./types.models-BXrRAuSB.js";
+
+//#region src/plugin-sdk/provider-onboard.d.ts
+type AgentModelAliasEntry = string | {
+  modelRef: string;
+  alias?: string;
+};
+declare const OPENCODE_ZEN_DEFAULT_MODEL = "opencode/claude-opus-4-6";
+type ProviderOnboardPresetAppliers<TArgs extends unknown[]> = {
+  applyProviderConfig: (cfg: DaoCoreConfig, ...args: TArgs) => DaoCoreConfig;
+  applyConfig: (cfg: DaoCoreConfig, ...args: TArgs) => DaoCoreConfig;
+};
+declare function withAgentModelAliases(existing: Record<string, AgentModelEntryConfig> | undefined, aliases: readonly AgentModelAliasEntry[]): Record<string, AgentModelEntryConfig>;
+declare function applyOnboardAuthAgentModelsAndProviders(cfg: DaoCoreConfig, params: {
+  agentModels: Record<string, AgentModelEntryConfig>;
+  providers: Record<string, ModelProviderConfig>;
+}): DaoCoreConfig;
+declare function applyAgentDefaultModelPrimary(cfg: DaoCoreConfig, primary: string): DaoCoreConfig;
+declare function applyOpencodeZenModelDefault(cfg: DaoCoreConfig): {
+  next: DaoCoreConfig;
+  changed: boolean;
+};
+declare function applyProviderConfigWithDefaultModels(cfg: DaoCoreConfig, params: {
+  agentModels: Record<string, AgentModelEntryConfig>;
+  providerId: string;
+  api: ModelApi;
+  baseUrl: string;
+  defaultModels: ModelDefinitionConfig[];
+  defaultModelId?: string;
+}): DaoCoreConfig;
+declare function applyProviderConfigWithDefaultModel(cfg: DaoCoreConfig, params: {
+  agentModels: Record<string, AgentModelEntryConfig>;
+  providerId: string;
+  api: ModelApi;
+  baseUrl: string;
+  defaultModel: ModelDefinitionConfig;
+  defaultModelId?: string;
+}): DaoCoreConfig;
+declare function applyProviderConfigWithDefaultModelPreset(cfg: DaoCoreConfig, params: {
+  providerId: string;
+  api: ModelApi;
+  baseUrl: string;
+  defaultModel: ModelDefinitionConfig;
+  defaultModelId?: string;
+  aliases?: readonly AgentModelAliasEntry[];
+  primaryModelRef?: string;
+}): DaoCoreConfig;
+declare function createDefaultModelPresetAppliers<TArgs extends unknown[]>(params: {
+  resolveParams: (cfg: DaoCoreConfig, ...args: TArgs) => Omit<Parameters<typeof applyProviderConfigWithDefaultModelPreset>[1], "primaryModelRef"> | null | undefined;
+  primaryModelRef: string;
+}): ProviderOnboardPresetAppliers<TArgs>;
+declare function applyProviderConfigWithDefaultModelsPreset(cfg: DaoCoreConfig, params: {
+  providerId: string;
+  api: ModelApi;
+  baseUrl: string;
+  defaultModels: ModelDefinitionConfig[];
+  defaultModelId?: string;
+  aliases?: readonly AgentModelAliasEntry[];
+  primaryModelRef?: string;
+}): DaoCoreConfig;
+declare function createDefaultModelsPresetAppliers<TArgs extends unknown[]>(params: {
+  resolveParams: (cfg: DaoCoreConfig, ...args: TArgs) => Omit<Parameters<typeof applyProviderConfigWithDefaultModelsPreset>[1], "primaryModelRef"> | null | undefined;
+  primaryModelRef: string;
+}): ProviderOnboardPresetAppliers<TArgs>;
+declare function applyProviderConfigWithModelCatalog(cfg: DaoCoreConfig, params: {
+  agentModels: Record<string, AgentModelEntryConfig>;
+  providerId: string;
+  api: ModelApi;
+  baseUrl: string;
+  catalogModels: ModelDefinitionConfig[];
+}): DaoCoreConfig;
+declare function applyProviderConfigWithModelCatalogPreset(cfg: DaoCoreConfig, params: {
+  providerId: string;
+  api: ModelApi;
+  baseUrl: string;
+  catalogModels: ModelDefinitionConfig[];
+  aliases?: readonly AgentModelAliasEntry[];
+  primaryModelRef?: string;
+}): DaoCoreConfig;
+declare function createModelCatalogPresetAppliers<TArgs extends unknown[]>(params: {
+  resolveParams: (cfg: DaoCoreConfig, ...args: TArgs) => Omit<Parameters<typeof applyProviderConfigWithModelCatalogPreset>[1], "primaryModelRef"> | null | undefined;
+  primaryModelRef: string;
+}): ProviderOnboardPresetAppliers<TArgs>;
+declare function ensureModelAllowlistEntry(params: {
+  cfg: DaoCoreConfig;
+  modelRef: string;
+  defaultProvider?: string;
+}): DaoCoreConfig;
+//#endregion
+export { withAgentModelAliases as _, applyOnboardAuthAgentModelsAndProviders as a, applyProviderConfigWithDefaultModelPreset as c, applyProviderConfigWithModelCatalog as d, applyProviderConfigWithModelCatalogPreset as f, ensureModelAllowlistEntry as g, createModelCatalogPresetAppliers as h, applyAgentDefaultModelPrimary as i, applyProviderConfigWithDefaultModels as l, createDefaultModelsPresetAppliers as m, OPENCODE_ZEN_DEFAULT_MODEL as n, applyOpencodeZenModelDefault as o, createDefaultModelPresetAppliers as p, ProviderOnboardPresetAppliers as r, applyProviderConfigWithDefaultModel as s, AgentModelAliasEntry as t, applyProviderConfigWithDefaultModelsPreset as u };

package/dist/provider-policy-ATLHkg5C.d.ts

@@ -0,0 +1,30 @@
+import { u as ModelProviderConfig } from "./types.models-BXrRAuSB.js";
+import { Yn as ProviderDefaultThinkingPolicyContext, Zn as ProviderThinkingProfile } from "./types-DEEPn4W72.js";
+//#region extensions/google/provider-policy.d.ts
+type GoogleApiCarrier = {
+  api?: string | null;
+};
+type GoogleProviderConfigLike = GoogleApiCarrier & {
+  models?: ReadonlyArray<GoogleApiCarrier | null | undefined> | null;
+};
+declare const DEFAULT_GOOGLE_API_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+declare function normalizeGoogleApiBaseUrl(baseUrl?: string): string;
+declare function isGoogleGenerativeAiApi(api?: string | null): boolean;
+declare function normalizeGoogleGenerativeAiBaseUrl(baseUrl?: string): string | undefined;
+declare function resolveGoogleGenerativeAiTransport<TApi extends string | null | undefined>(params: {
+  api: TApi;
+  baseUrl?: string;
+}): {
+  api: TApi;
+  baseUrl?: string;
+};
+declare function resolveGoogleGenerativeAiApiOrigin(baseUrl?: string): string;
+declare function shouldNormalizeGoogleGenerativeAiProviderConfig(providerKey: string, provider: GoogleProviderConfigLike): boolean;
+declare function shouldNormalizeGoogleProviderConfig(providerKey: string, provider: GoogleProviderConfigLike): boolean;
+declare function normalizeGoogleProviderConfig(providerKey: string, provider: ModelProviderConfig): ModelProviderConfig;
+declare function resolveGoogleThinkingProfile({
+  modelId,
+  reasoning
+}: ProviderDefaultThinkingPolicyContext): ProviderThinkingProfile | undefined;
+//#endregion
+export { normalizeGoogleProviderConfig as a, resolveGoogleThinkingProfile as c, normalizeGoogleGenerativeAiBaseUrl as i, shouldNormalizeGoogleGenerativeAiProviderConfig as l, isGoogleGenerativeAiApi as n, resolveGoogleGenerativeAiApiOrigin as o, normalizeGoogleApiBaseUrl as r, resolveGoogleGenerativeAiTransport as s, DEFAULT_GOOGLE_API_BASE_URL as t, shouldNormalizeGoogleProviderConfig as u };

package/dist/provider-registration-Z_xJg7Pi.d.ts

@@ -0,0 +1,6 @@
+import { l as DaoCorePluginApi, sn as ProviderPlugin } from "./types-DEEPn4W72.js";
+//#region extensions/google/provider-registration.d.ts
+declare function buildGoogleProvider(): ProviderPlugin;
+declare function registerGoogleProvider(api: DaoCorePluginApi): void;
+//#endregion
+export { registerGoogleProvider as n, buildGoogleProvider as t };

package/dist/provider-registry-B5RvlFrG.d.ts

@@ -0,0 +1,30 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { C as SpeechProviderId, b as SpeechModelOverridePolicy, x as SpeechProviderConfig, z as TtsDirectiveParseResult } from "./tts-runtime.types-DCcDeY50.js";
+import { Gn as SpeechProviderPlugin } from "./types-DEEPn4W72.js";
+
+//#region src/tts/tts-provider-helpers.d.ts
+declare function requireInRange(value: number, min: number, max: number, label: string): void;
+declare function normalizeLanguageCode(code?: string): string | undefined;
+declare function normalizeApplyTextNormalization(mode?: string): "auto" | "on" | "off" | undefined;
+declare function normalizeSeed(seed?: number): number | undefined;
+declare function scheduleCleanup(tempDir: string, delayMs?: number): void;
+//#endregion
+//#region src/tts/directives.d.ts
+type ParseTtsDirectiveOptions = {
+  cfg?: DaoCoreConfig;
+  providers?: readonly SpeechProviderPlugin[];
+  providerConfigs?: Record<string, SpeechProviderConfig>;
+  preferredProviderId?: string;
+};
+declare function parseTtsDirectives(text: string, policy: SpeechModelOverridePolicy, options?: ParseTtsDirectiveOptions): TtsDirectiveParseResult;
+//#endregion
+//#region src/tts/provider-registry-core.d.ts
+declare function normalizeSpeechProviderId(providerId: string | undefined): SpeechProviderId | undefined;
+//#endregion
+//#region src/tts/provider-registry.d.ts
+declare const listSpeechProviders: (cfg?: DaoCoreConfig) => SpeechProviderPlugin[];
+declare const listLoadedSpeechProviders: (cfg?: DaoCoreConfig) => SpeechProviderPlugin[];
+declare const getSpeechProvider: (providerId: string | undefined, cfg?: DaoCoreConfig) => SpeechProviderPlugin | undefined;
+declare const canonicalizeSpeechProviderId: (providerId: string | undefined, cfg?: DaoCoreConfig) => SpeechProviderId | undefined;
+//#endregion
+export { normalizeSpeechProviderId as a, normalizeLanguageCode as c, scheduleCleanup as d, listSpeechProviders as i, normalizeSeed as l, getSpeechProvider as n, parseTtsDirectives as o, listLoadedSpeechProviders as r, normalizeApplyTextNormalization as s, canonicalizeSpeechProviderId as t, requireInRange as u };

package/dist/provider-registry-DVYpBr9U.d.ts

@@ -0,0 +1,8 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { Jn as VideoGenerationProviderPlugin } from "./types-DEEPn4W72.js";
+
+//#region src/video-generation/provider-registry.d.ts
+declare function listVideoGenerationProviders(cfg?: DaoCoreConfig): VideoGenerationProviderPlugin[];
+declare function getVideoGenerationProvider(providerId: string | undefined, cfg?: DaoCoreConfig): VideoGenerationProviderPlugin | undefined;
+//#endregion
+export { listVideoGenerationProviders as n, getVideoGenerationProvider as t };

package/dist/provider-registry-DXnWu33V.d.ts

@@ -0,0 +1,8 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { G as ImageGenerationProviderPlugin } from "./types-DEEPn4W72.js";
+
+//#region src/image-generation/provider-registry.d.ts
+declare function listImageGenerationProviders(cfg?: DaoCoreConfig): ImageGenerationProviderPlugin[];
+declare function getImageGenerationProvider(providerId: string | undefined, cfg?: DaoCoreConfig): ImageGenerationProviderPlugin | undefined;
+//#endregion
+export { listImageGenerationProviders as n, getImageGenerationProvider as t };