@gaodefa/daocore 2026.5.25 → 2026.5.27

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

@@ -0,0 +1,143 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.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-DHSQkzyq2.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-B6wofKVD.d.ts

@@ -0,0 +1,12 @@
+import { Dn as ProviderResolveDynamicModelContext } from "./types-DHSQkzyq2.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-policy-0JjxJfxh.d.ts

@@ -0,0 +1,30 @@
+import { u as ModelProviderConfig } from "./types.models-BXrRAuSB.js";
+import { Yn as ProviderDefaultThinkingPolicyContext, Zn as ProviderThinkingProfile } from "./types-DHSQkzyq2.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-O7mvATZX.d.ts

@@ -0,0 +1,6 @@
+import { l as DaoCorePluginApi, sn as ProviderPlugin } from "./types-DHSQkzyq2.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-CtFVQxwM.d.ts

@@ -0,0 +1,8 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { G as ImageGenerationProviderPlugin } from "./types-DHSQkzyq2.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 };

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

@@ -0,0 +1,8 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { Jn as VideoGenerationProviderPlugin } from "./types-DHSQkzyq2.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-DcUASGbX.d.ts

@@ -0,0 +1,30 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { C as SpeechProviderId, b as SpeechModelOverridePolicy, x as SpeechProviderConfig, z as TtsDirectiveParseResult } from "./tts-runtime.types-CiR5E2bC.js";
+import { Gn as SpeechProviderPlugin } from "./types-DHSQkzyq2.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-runtime-CrrstiDP.d.ts

@@ -0,0 +1,359 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { u as ModelProviderConfig } from "./types.models-BXrRAuSB.js";
+import { n as FailoverReason } from "./types-DKoVBm0H.js";
+import { t as ModelCatalogEntry } from "./model-catalog.types-BnioQy7H.js";
+import { c as OAuthCredential, i as AuthProfileCredential } from "./types-dSHooml1.js";
+import { r as AnyAgentTool } from "./common-BDN0bXby.js";
+import { $n as ProviderExternalAuthProfile, $t as ProviderModernModelPolicyContext, An as ProviderResolveTransportTurnStateContext, Bn as ProviderValidateReplayTurnsContext, Bt as ProviderCreateEmbeddingProviderContext, Ct as ProviderAugmentModelCatalogContext, Dn as ProviderResolveDynamicModelContext, Fn as ProviderSanitizeReplayHistoryContext, Ft as ProviderCacheTtlEligibilityContext, Ht as ProviderDeferSyntheticProfileAuthContext, In as ProviderSystemPromptContributionContext, Jt as ProviderFailoverErrorContext, Ln as ProviderToolSchemaDiagnostic, Mn as ProviderResolveWebSocketSessionPolicyContext, Mt as ProviderBuildUnknownModelHintContext, Nn as ProviderResolvedUsageAuth, Qn as ProviderRuntimeModel, Rn as ProviderTransformSystemPromptContext, Tt as ProviderAuthDoctorHintContext, Vn as ProviderWebSocketSessionPolicy, Vt as ProviderCreateStreamFnContext, Xn as ProviderThinkingPolicyContext, Yn as ProviderDefaultThinkingPolicyContext, Yt as ProviderFetchUsageSnapshotContext, Zn as ProviderThinkingProfile, _n as ProviderPreparedRuntimeAuth, an as ProviderNormalizeTransportContext, ar as ProviderApplyConfigDefaultsContext, bn as ProviderReplayPolicy, dt as PluginEmbeddingProvider, gn as ProviderPrepareRuntimeAuthContext, in as ProviderNormalizeToolSchemasContext, ir as ProviderSyntheticAuthResult, jn as ProviderResolveUsageAuthContext, jt as ProviderBuildMissingAuthMessageContext, mn as ProviderPrepareDynamicModelContext, nn as ProviderNormalizeModelIdContext, nr as ProviderResolveExternalOAuthProfilesContext, oi as ProviderSystemPromptContribution, or as ProviderNormalizeConfigContext, pn as ProviderPreferRuntimeResolvedModelContext, rn as ProviderNormalizeResolvedModelContext, rr as ProviderResolveSyntheticAuthContext, sr as ProviderResolveConfigApiKeyContext, tr as ProviderResolveExternalAuthProfilesContext, vn as ProviderReasoningOutputMode, wr as PluginTextTransforms, xn as ProviderReplayPolicyContext, yn as ProviderReasoningOutputModeContext, zn as ProviderTransportTurnState } from "./types-DHSQkzyq2.js";
+import { t as ProviderUsageSnapshot } from "./provider-usage.types-BGbkzahX.js";
+import { a as resolveProviderFollowupFallbackRoute, i as resolveProviderExtraParamsForTransport, n as prepareProviderExtraParams, o as resolveProviderRuntimePlugin, r as resolveProviderAuthProfileId, s as wrapProviderStreamFn, t as ProviderRuntimePluginHandle } from "./provider-hook-runtime-CrtHxgL6.js";
+
+//#region src/plugins/provider-runtime.d.ts
+declare namespace provider_runtime_d_exports {
+  export { testing as __testing, applyProviderConfigDefaultsWithPlugin, applyProviderNativeStreamingUsageCompatWithPlugin, applyProviderResolvedModelCompatWithPlugins, applyProviderResolvedTransportWithPlugin, augmentModelCatalogWithProviderPlugins, buildProviderAuthDoctorHintWithPlugin, buildProviderMissingAuthMessageWithPlugin, buildProviderUnknownModelHintWithPlugin, classifyProviderFailoverReasonWithPlugin, createProviderEmbeddingProvider, formatProviderAuthProfileApiKeyWithPlugin, inspectProviderToolSchemasWithPlugin, matchesProviderContextOverflowWithPlugin, normalizeProviderConfigWithPlugin, normalizeProviderModelIdWithPlugin, normalizeProviderResolvedModelWithPlugin, normalizeProviderToolSchemasWithPlugin, normalizeProviderTransportWithPlugin, prepareProviderDynamicModel, prepareProviderExtraParams, prepareProviderRuntimeAuth, refreshProviderOAuthCredentialWithPlugin, resolveExternalAuthProfilesWithPlugins, resolveExternalOAuthProfilesWithPlugins, resolveProviderAuthProfileId, resolveProviderBinaryThinking, resolveProviderCacheTtlEligibility, resolveProviderConfigApiKeyWithPlugin, resolveProviderDefaultThinkingLevel, resolveProviderExtraParamsForTransport, resolveProviderFollowupFallbackRoute, resolveProviderModernModelRef, resolveProviderReasoningOutputModeWithPlugin, resolveProviderReplayPolicyWithPlugin, resolveProviderRuntimePlugin, resolveProviderStreamFn, resolveProviderSyntheticAuthWithPlugin, resolveProviderSystemPromptContribution, resolveProviderTextTransforms, resolveProviderThinkingProfile, resolveProviderTransportTurnStateWithPlugin, resolveProviderUsageAuthWithPlugin, resolveProviderUsageSnapshotWithPlugin, resolveProviderWebSocketSessionPolicyWithPlugin, resolveProviderXHighThinking, runProviderDynamicModel, sanitizeProviderReplayHistoryWithPlugin, shouldDeferProviderSyntheticProfileAuthWithPlugin, shouldPreferProviderRuntimeResolvedModel, testing, transformProviderSystemPrompt, validateProviderReplayTurnsWithPlugin, wrapProviderStreamFn };
+}
+declare function resetExternalAuthFallbackWarningCacheForTest(): void;
+declare const testing: {
+  readonly resetExternalAuthFallbackWarningCacheForTest: typeof resetExternalAuthFallbackWarningCacheForTest;
+};
+declare function runProviderDynamicModel(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderResolveDynamicModelContext;
+}): ProviderRuntimeModel | undefined;
+declare function resolveProviderSystemPromptContribution(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  runtimeHandle?: ProviderRuntimePluginHandle;
+  context: ProviderSystemPromptContributionContext;
+}): ProviderSystemPromptContribution | undefined;
+declare function transformProviderSystemPrompt(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  runtimeHandle?: ProviderRuntimePluginHandle;
+  context: ProviderTransformSystemPromptContext;
+}): string;
+declare function resolveProviderTextTransforms(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  runtimeHandle?: ProviderRuntimePluginHandle;
+}): PluginTextTransforms | undefined;
+declare function prepareProviderDynamicModel(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderPrepareDynamicModelContext;
+}): Promise<void>;
+declare function shouldPreferProviderRuntimeResolvedModel(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderPreferRuntimeResolvedModelContext;
+}): boolean;
+declare function normalizeProviderResolvedModelWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: {
+    config?: DaoCoreConfig;
+    agentDir?: string;
+    workspaceDir?: string;
+    provider: string;
+    modelId: string;
+    model: ProviderRuntimeModel;
+  };
+}): ProviderRuntimeModel | undefined;
+declare function applyProviderResolvedModelCompatWithPlugins(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderNormalizeResolvedModelContext;
+}): ProviderRuntimeModel | undefined;
+declare function applyProviderResolvedTransportWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderNormalizeResolvedModelContext;
+}): ProviderRuntimeModel | undefined;
+declare function normalizeProviderModelIdWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderNormalizeModelIdContext;
+}): string | undefined;
+declare function normalizeProviderTransportWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderNormalizeTransportContext;
+}): {
+  api?: string | null;
+  baseUrl?: string;
+} | undefined;
+declare function normalizeProviderConfigWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderNormalizeConfigContext;
+  allowRuntimePluginLoad?: boolean;
+}): ModelProviderConfig | undefined;
+declare function applyProviderNativeStreamingUsageCompatWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderNormalizeConfigContext;
+  allowRuntimePluginLoad?: boolean;
+}): ModelProviderConfig | undefined;
+declare function resolveProviderConfigApiKeyWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderResolveConfigApiKeyContext;
+  allowRuntimePluginLoad?: boolean;
+}): string | undefined;
+declare function resolveProviderReplayPolicyWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderReplayPolicyContext;
+}): ProviderReplayPolicy | undefined;
+declare function sanitizeProviderReplayHistoryWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderSanitizeReplayHistoryContext;
+}): Promise<import("@earendil-works/pi-agent-core").AgentMessage[] | null | undefined>;
+declare function validateProviderReplayTurnsWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderValidateReplayTurnsContext;
+}): Promise<import("@earendil-works/pi-agent-core").AgentMessage[] | null | undefined>;
+declare function normalizeProviderToolSchemasWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  runtimeHandle?: ProviderRuntimePluginHandle;
+  context: ProviderNormalizeToolSchemasContext;
+}): AnyAgentTool[] | undefined;
+declare function inspectProviderToolSchemasWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  runtimeHandle?: ProviderRuntimePluginHandle;
+  context: ProviderNormalizeToolSchemasContext;
+}): ProviderToolSchemaDiagnostic[] | undefined;
+declare function resolveProviderReasoningOutputModeWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderReasoningOutputModeContext;
+}): ProviderReasoningOutputMode | undefined;
+declare function resolveProviderStreamFn(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  allowRuntimePluginLoad?: boolean;
+  context: ProviderCreateStreamFnContext;
+}): import("@earendil-works/pi-agent-core").StreamFn | undefined;
+declare function resolveProviderTransportTurnStateWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderResolveTransportTurnStateContext;
+}): ProviderTransportTurnState | undefined;
+declare function resolveProviderWebSocketSessionPolicyWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderResolveWebSocketSessionPolicyContext;
+}): ProviderWebSocketSessionPolicy | undefined;
+declare function createProviderEmbeddingProvider(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderCreateEmbeddingProviderContext;
+}): Promise<PluginEmbeddingProvider | null | undefined>;
+declare function prepareProviderRuntimeAuth(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderPrepareRuntimeAuthContext;
+}): Promise<ProviderPreparedRuntimeAuth | null | undefined>;
+declare function resolveProviderUsageAuthWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderResolveUsageAuthContext;
+}): Promise<ProviderResolvedUsageAuth | null | undefined>;
+declare function resolveProviderUsageSnapshotWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderFetchUsageSnapshotContext;
+}): Promise<ProviderUsageSnapshot | null | undefined>;
+declare function matchesProviderContextOverflowWithPlugin(params: {
+  provider?: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderFailoverErrorContext;
+}): boolean;
+declare function classifyProviderFailoverReasonWithPlugin(params: {
+  provider?: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderFailoverErrorContext;
+}): FailoverReason | undefined;
+declare function formatProviderAuthProfileApiKeyWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: AuthProfileCredential;
+}): string | undefined;
+declare function refreshProviderOAuthCredentialWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: OAuthCredential;
+}): Promise<OAuthCredential | undefined>;
+declare function buildProviderAuthDoctorHintWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderAuthDoctorHintContext;
+}): Promise<string | null | undefined>;
+declare function resolveProviderCacheTtlEligibility(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderCacheTtlEligibilityContext;
+}): boolean | undefined;
+declare function resolveProviderBinaryThinking(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderThinkingPolicyContext;
+}): boolean | undefined;
+declare function resolveProviderXHighThinking(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderThinkingPolicyContext;
+}): boolean | undefined;
+declare function resolveProviderThinkingProfile(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderDefaultThinkingPolicyContext;
+}): ProviderThinkingProfile | null | undefined;
+declare function resolveProviderDefaultThinkingLevel(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderDefaultThinkingPolicyContext;
+}): "off" | "minimal" | "high" | "low" | "medium" | "xhigh" | "adaptive" | null | undefined;
+declare function applyProviderConfigDefaultsWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderApplyConfigDefaultsContext;
+}): DaoCoreConfig | undefined;
+declare function resolveProviderModernModelRef(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderModernModelPolicyContext;
+}): boolean | undefined;
+declare function buildProviderMissingAuthMessageWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderBuildMissingAuthMessageContext;
+}): string | undefined;
+declare function buildProviderUnknownModelHintWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderBuildUnknownModelHintContext;
+}): string | undefined;
+declare function resolveProviderSyntheticAuthWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderResolveSyntheticAuthContext;
+  modelApi?: string;
+}): ProviderSyntheticAuthResult | null | undefined;
+declare function resolveExternalAuthProfilesWithPlugins(params: {
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderResolveExternalAuthProfilesContext;
+}): ProviderExternalAuthProfile[];
+declare function resolveExternalOAuthProfilesWithPlugins(params: {
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderResolveExternalOAuthProfilesContext;
+}): ProviderExternalAuthProfile[];
+declare function shouldDeferProviderSyntheticProfileAuthWithPlugin(params: {
+  provider: string;
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderDeferSyntheticProfileAuthContext;
+  modelApi?: string;
+}): boolean | undefined;
+declare function augmentModelCatalogWithProviderPlugins(params: {
+  config?: DaoCoreConfig;
+  workspaceDir?: string;
+  env?: NodeJS.ProcessEnv;
+  context: ProviderAugmentModelCatalogContext;
+}): Promise<ModelCatalogEntry[]>;
+//#endregion
+export { normalizeProviderResolvedModelWithPlugin as a, provider_runtime_d_exports as c, buildProviderUnknownModelHintWithPlugin as i, runProviderDynamicModel as l, applyProviderResolvedTransportWithPlugin as n, normalizeProviderTransportWithPlugin as o, augmentModelCatalogWithProviderPlugins as r, prepareProviderDynamicModel as s, applyProviderResolvedModelCompatWithPlugins as t, shouldPreferProviderRuntimeResolvedModel as u };