@gaodefa/daocore 2026.5.69 → 2026.5.70

package/dist/thread-bindings-runtime-EgzHrgxe.d.ts

@@ -0,0 +1,42 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { n as BindingTargetKind } from "./session-binding.types-cd2c9es6.js";
+//#region src/infra/outbound/account-scoped-conversation-bindings.d.ts
+type AccountScopedConversationBindingRecord<TKind extends string = string> = {
+  accountId: string;
+  conversationId: string;
+  targetKind: TKind;
+  targetSessionKey: string;
+  agentId?: string;
+  label?: string;
+  boundBy?: string;
+  boundAt: number;
+  lastActivityAt: number;
+};
+type AccountScopedConversationBindingManager<TKind extends string = string> = {
+  accountId: string;
+  getByConversationId: (conversationId: string) => AccountScopedConversationBindingRecord<TKind> | undefined;
+  listBySessionKey: (targetSessionKey: string) => AccountScopedConversationBindingRecord<TKind>[];
+  bindConversation: (params: {
+    conversationId: string;
+    targetKind: BindingTargetKind;
+    targetSessionKey: string;
+    metadata?: Record<string, unknown>;
+  }) => AccountScopedConversationBindingRecord<TKind> | null;
+  touchConversation: (conversationId: string, at?: number) => AccountScopedConversationBindingRecord<TKind> | null;
+  unbindConversation: (conversationId: string) => AccountScopedConversationBindingRecord<TKind> | null;
+  unbindBySessionKey: (targetSessionKey: string) => AccountScopedConversationBindingRecord<TKind>[];
+  stop: () => void;
+};
+declare function createAccountScopedConversationBindingManager<TKind extends string>(params: {
+  channel: string;
+  cfg: DaoCoreConfig;
+  stateKey: symbol;
+  accountId?: string | null;
+  toStoredTargetKind: (raw: BindingTargetKind) => TKind;
+  toSessionBindingTargetKind: (raw: TKind) => BindingTargetKind;
+}): AccountScopedConversationBindingManager<TKind>;
+declare function resetAccountScopedConversationBindingsForTests(params: {
+  stateKey: symbol;
+}): void;
+//#endregion
+export { resetAccountScopedConversationBindingsForTests as i, AccountScopedConversationBindingRecord as n, createAccountScopedConversationBindingManager as r, AccountScopedConversationBindingManager as t };

package/dist/thread-bindings-vDEvX2fx.d.ts

@@ -0,0 +1,56 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { n as PinnedDispatcherPolicy, o as SsrFPolicy } from "./ssrf-skjEI_i5.js";
+import { c as ChannelSetupWizardAdapter } from "./setup-wizard-types-CDmi5gLx.js";
+import { H as ChannelSetupAdapter } from "./types.adapters-StiSC8e-.js";
+import { t as MatrixClient } from "./sdk-Ddt9_En6.js";
+import { t as MatrixThreadBindingManager } from "./thread-bindings-shared-Ddk3opvy.js";
+
+//#region extensions/matrix/src/setup-core.d.ts
+type MatrixSetupWizardModule = {
+  matrixSetupWizard: ChannelSetupWizardAdapter;
+};
+declare function createMatrixSetupWizardProxy(loadWizardModule: () => Promise<MatrixSetupWizardModule>): ChannelSetupWizardAdapter;
+declare const matrixSetupAdapter: ChannelSetupAdapter;
+//#endregion
+//#region extensions/matrix/src/onboarding.d.ts
+declare const matrixOnboardingAdapter: ChannelSetupWizardAdapter;
+//#endregion
+//#region extensions/matrix/src/matrix/client/types.d.ts
+/**
+ * Authenticated Matrix configuration.
+ * Note: deviceId is NOT included here because it's implicit in the accessToken.
+ * Matrix storage reuses the most complete account-scoped root it can find for the
+ * same homeserver/user/account tuple so token refreshes do not strand prior state.
+ * If the device identity itself changes or crypto storage is lost, crypto state may
+ * still need to be recreated together with the new access token.
+ */
+type MatrixAuth = {
+  accountId: string;
+  homeserver: string;
+  userId: string;
+  accessToken: string;
+  password?: string;
+  deviceId?: string;
+  deviceName?: string;
+  initialSyncLimit?: number;
+  encryption?: boolean;
+  allowPrivateNetwork?: boolean;
+  ssrfPolicy?: SsrFPolicy;
+  dispatcherPolicy?: PinnedDispatcherPolicy;
+};
+//#endregion
+//#region extensions/matrix/src/matrix/thread-bindings.d.ts
+declare function createMatrixThreadBindingManager(params: {
+  cfg: DaoCoreConfig;
+  accountId: string;
+  auth: MatrixAuth;
+  client: MatrixClient;
+  env?: NodeJS.ProcessEnv;
+  stateDir?: string;
+  idleTimeoutMs: number;
+  maxAgeMs: number;
+  enableSweeper?: boolean;
+  logVerboseMessage?: (message: string) => void;
+}): Promise<MatrixThreadBindingManager>;
+//#endregion
+export { matrixSetupAdapter as i, matrixOnboardingAdapter as n, createMatrixSetupWizardProxy as r, createMatrixThreadBindingManager as t };

package/dist/thread-bindings.manager-D0W3axXV.d.ts

@@ -0,0 +1,111 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { o as resolveThreadBindingThreadName } from "./thread-binding-lifecycle-BzpPZ9dy.js";
+
+//#region extensions/discord/src/monitor/thread-bindings.types.d.ts
+type ThreadBindingTargetKind = "subagent" | "acp";
+type ThreadBindingRecord = {
+  accountId: string;
+  channelId: string;
+  threadId: string;
+  targetKind: ThreadBindingTargetKind;
+  targetSessionKey: string;
+  agentId: string;
+  label?: string;
+  webhookId?: string;
+  webhookToken?: string;
+  boundBy: string;
+  boundAt: number;
+  lastActivityAt: number; /** Inactivity timeout window in milliseconds (0 disables inactivity auto-unfocus). */
+  idleTimeoutMs?: number; /** Hard max-age window in milliseconds from bind time (0 disables hard cap). */
+  maxAgeMs?: number;
+  metadata?: Record<string, unknown>;
+};
+type ThreadBindingManager = {
+  accountId: string;
+  getIdleTimeoutMs: () => number;
+  getMaxAgeMs: () => number;
+  getByThreadId: (threadId: string) => ThreadBindingRecord | undefined;
+  getBySessionKey: (targetSessionKey: string) => ThreadBindingRecord | undefined;
+  listBySessionKey: (targetSessionKey: string) => ThreadBindingRecord[];
+  listBindings: () => ThreadBindingRecord[];
+  touchThread: (params: {
+    threadId: string;
+    at?: number;
+    persist?: boolean;
+  }) => ThreadBindingRecord | null;
+  bindTarget: (params: {
+    threadId?: string | number;
+    channelId?: string;
+    createThread?: boolean;
+    threadName?: string;
+    targetKind: ThreadBindingTargetKind;
+    targetSessionKey: string;
+    agentId?: string;
+    label?: string;
+    boundBy?: string;
+    introText?: string;
+    webhookId?: string;
+    webhookToken?: string;
+    metadata?: Record<string, unknown>;
+  }) => Promise<ThreadBindingRecord | null>;
+  unbindThread: (params: {
+    threadId: string;
+    reason?: string;
+    sendFarewell?: boolean;
+    farewellText?: string;
+  }) => ThreadBindingRecord | null;
+  unbindBySessionKey: (params: {
+    targetSessionKey: string;
+    targetKind?: ThreadBindingTargetKind;
+    reason?: string;
+    sendFarewell?: boolean;
+    farewellText?: string;
+  }) => ThreadBindingRecord[];
+  stop: () => void;
+};
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.state.d.ts
+declare function resolveThreadBindingsPath(): string;
+declare function resolveThreadBindingIdleTimeoutMs(params: {
+  record: Pick<ThreadBindingRecord, "idleTimeoutMs">;
+  defaultIdleTimeoutMs: number;
+}): number;
+declare function resolveThreadBindingMaxAgeMs(params: {
+  record: Pick<ThreadBindingRecord, "maxAgeMs">;
+  defaultMaxAgeMs: number;
+}): number;
+declare function resolveThreadBindingInactivityExpiresAt(params: {
+  record: Pick<ThreadBindingRecord, "lastActivityAt" | "idleTimeoutMs">;
+  defaultIdleTimeoutMs: number;
+}): number | undefined;
+declare function resolveThreadBindingMaxAgeExpiresAt(params: {
+  record: Pick<ThreadBindingRecord, "boundAt" | "maxAgeMs">;
+  defaultMaxAgeMs: number;
+}): number | undefined;
+declare function isRecentlyUnboundThreadWebhookMessage(params: {
+  accountId?: string;
+  threadId: string;
+  webhookId?: string | null;
+}): boolean;
+declare function resetThreadBindingsForTests(): void;
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.manager.d.ts
+declare function createThreadBindingManager(params: {
+  accountId?: string;
+  token?: string;
+  cfg: DaoCoreConfig;
+  persist?: boolean;
+  enableSweeper?: boolean;
+  idleTimeoutMs?: number;
+  maxAgeMs?: number;
+}): ThreadBindingManager;
+declare function createNoopThreadBindingManager(accountId?: string): ThreadBindingManager;
+declare function getThreadBindingManager(accountId?: string): ThreadBindingManager | null;
+declare const testing: {
+  resolveThreadBindingsPath: typeof resolveThreadBindingsPath;
+  resolveThreadBindingThreadName: typeof resolveThreadBindingThreadName;
+  resetThreadBindingsForTests: typeof resetThreadBindingsForTests;
+  runThreadBindingSweepForAccount: (accountId?: string) => Promise<void>;
+};
+//#endregion
+export { isRecentlyUnboundThreadWebhookMessage as a, resolveThreadBindingMaxAgeExpiresAt as c, ThreadBindingRecord as d, ThreadBindingTargetKind as f, testing as i, resolveThreadBindingMaxAgeMs as l, createThreadBindingManager as n, resolveThreadBindingIdleTimeoutMs as o, getThreadBindingManager as r, resolveThreadBindingInactivityExpiresAt as s, createNoopThreadBindingManager as t, ThreadBindingManager as u };

package/dist/token-BhuDclvy.d.ts

@@ -0,0 +1,10 @@
+import { n as BaseTokenResolution } from "./types.core-DpVp9PoP.js";
+//#region extensions/discord/src/token.d.ts
+type DiscordTokenSource = "env" | "config" | "none";
+type DiscordCredentialStatus = "available" | "configured_unavailable" | "missing";
+type DiscordTokenResolution = BaseTokenResolution & {
+  source: DiscordTokenSource;
+  tokenStatus: DiscordCredentialStatus;
+};
+//#endregion
+export { DiscordTokenResolution as n, DiscordCredentialStatus as t };

package/dist/token-Bo7BLKZl.d.ts

@@ -0,0 +1,15 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { n as BaseTokenResolution } from "./types.core-DpVp9PoP.js";
+//#region extensions/telegram/src/token.d.ts
+type TelegramTokenSource = "env" | "tokenFile" | "config" | "none";
+type TelegramTokenResolution = BaseTokenResolution & {
+  source: TelegramTokenSource;
+};
+type ResolveTelegramTokenOpts = {
+  envToken?: string | null;
+  accountId?: string | null;
+  logMissingFile?: (message: string) => void;
+};
+declare function resolveTelegramToken(cfg?: DaoCoreConfig, opts?: ResolveTelegramTokenOpts): TelegramTokenResolution;
+//#endregion
+export { resolveTelegramToken as n, TelegramTokenResolution as t };

package/dist/tool-plugin-DGUqdEcE.d.ts

@@ -0,0 +1,77 @@
+import { t as JsonSchemaObject } from "./json-schema.types-fpZiub1R.js";
+import { s as PluginManifestActivation } from "./manifest-registry-BytIqZ_A.js";
+import { D as DaoCorePluginToolContext } from "./types-core-C88zUmhD.js";
+import { r as AnyAgentTool } from "./common-BDN0bXby.js";
+import { l as DaoCorePluginApi } from "./types-M3Y2bFvZ2.js";
+import { t as definePluginEntry } from "./plugin-entry-BxGTO4F2.js";
+import { Static, TSchema } from "typebox";
+import { AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
+
+//#region src/plugin-sdk/tool-plugin.d.ts
+declare const toolPluginMetadataSymbol: unique symbol;
+type ToolPluginExecutionContext = {
+  api: DaoCorePluginApi;
+  signal?: AbortSignal;
+  toolCallId: string;
+  onUpdate?: AgentToolUpdateCallback<unknown>;
+};
+type ToolPluginConfig<TConfigSchema extends TSchema | undefined> = TConfigSchema extends TSchema ? Static<TConfigSchema> : Record<string, never>;
+type ToolPluginToolFactory<TConfig> = <TParamsSchema extends TSchema>(definition: ToolPluginToolDefinition<TConfig, TParamsSchema>) => DefinedToolPluginTool;
+type ToolPluginFactoryContext<TConfig> = {
+  api: DaoCorePluginApi;
+  config: TConfig;
+  toolContext: DaoCorePluginToolContext;
+};
+type ToolPluginToolDefinitionBase<TParamsSchema extends TSchema> = {
+  name: string;
+  label?: string;
+  description: string;
+  parameters: TParamsSchema;
+  optional?: boolean;
+};
+type ToolPluginToolDefinition<TConfig, TParamsSchema extends TSchema> = ToolPluginToolDefinitionBase<TParamsSchema> & ({
+  execute: (params: Static<TParamsSchema>, config: TConfig, context: ToolPluginExecutionContext) => unknown;
+  factory?: never;
+} | {
+  factory: (context: ToolPluginFactoryContext<TConfig>) => AnyAgentTool | AnyAgentTool[] | null | undefined;
+  execute?: never;
+});
+type DefinedToolPluginTool = {
+  name: string;
+  label: string;
+  description: string;
+  parameters: TSchema;
+  optional: boolean;
+  execute?: (params: unknown, config: unknown, context: ToolPluginExecutionContext) => unknown;
+  factory?: (context: ToolPluginFactoryContext<unknown>) => AnyAgentTool | AnyAgentTool[] | null | undefined;
+};
+type ToolPluginStaticToolMetadata = {
+  name: string;
+  label: string;
+  description: string;
+  parameters: JsonSchemaObject;
+  optional?: boolean;
+};
+type ToolPluginMetadata = {
+  id: string;
+  name: string;
+  description: string;
+  activation: PluginManifestActivation;
+  configSchema: JsonSchemaObject;
+  tools: ToolPluginStaticToolMetadata[];
+};
+type DefineToolPluginOptions<TConfigSchema extends TSchema | undefined = undefined> = {
+  id: string;
+  name: string;
+  description: string;
+  activation?: PluginManifestActivation;
+  configSchema?: TConfigSchema;
+  tools: (tool: ToolPluginToolFactory<ToolPluginConfig<TConfigSchema>>) => readonly DefinedToolPluginTool[];
+};
+type DefinedToolPluginEntry = ReturnType<typeof definePluginEntry> & {
+  [toolPluginMetadataSymbol]: ToolPluginMetadata;
+};
+declare function defineToolPlugin<TConfigSchema extends TSchema | undefined = undefined>(definition: DefineToolPluginOptions<TConfigSchema>): DefinedToolPluginEntry;
+declare function getToolPluginMetadata(entry: unknown): ToolPluginMetadata | undefined;
+//#endregion
+export { ToolPluginMetadata as a, defineToolPlugin as c, ToolPluginFactoryContext as i, getToolPluginMetadata as l, DefinedToolPluginEntry as n, ToolPluginStaticToolMetadata as o, ToolPluginExecutionContext as r, ToolPluginToolDefinition as s, DefineToolPluginOptions as t, toolPluginMetadataSymbol as u };

package/dist/tool-split-HsRCRrII.d.ts

@@ -0,0 +1,19 @@
+import { Di as HookContext } from "./types-M3Y2bFvZ2.js";
+import { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { AgentTool } from "@earendil-works/pi-agent-core";
+
+//#region src/agents/pi-tool-definition-adapter.d.ts
+type AnyAgentTool$1 = AgentTool;
+declare function toToolDefinitions(tools: AnyAgentTool$1[], hookContext?: HookContext): ToolDefinition[];
+//#endregion
+//#region src/agents/pi-embedded-runner/tool-split.d.ts
+type AnyAgentTool = AgentTool;
+declare function splitSdkTools(options: {
+  tools: AnyAgentTool[];
+  sandboxEnabled: boolean;
+  toolHookContext?: HookContext;
+}): {
+  customTools: ReturnType<typeof toToolDefinitions>;
+};
+//#endregion
+export { splitSdkTools as t };

package/dist/transport-stream-CN6cbG2f.d.ts

@@ -0,0 +1,42 @@
+import { i as GoogleThinkingLevel } from "./provider-stream-shared-B_bcbUS7.js";
+import { Context, Model, SimpleStreamOptions } from "@earendil-works/pi-ai";
+import { StreamFn } from "@earendil-works/pi-agent-core";
+
+//#region extensions/google/transport-stream.d.ts
+type CanonicalGoogleTransportApi = "google-generative-ai" | "google-vertex";
+type GoogleTransportApi = CanonicalGoogleTransportApi | "daocore-google-generative-ai-transport";
+type GoogleTransportModel = Model<GoogleTransportApi> & {
+  headers?: Record<string, string>;
+  provider: string;
+};
+type GoogleTransportOptions = SimpleStreamOptions & {
+  cachedContent?: string;
+  toolChoice?: "auto" | "none" | "any" | "required" | {
+    type: "function";
+    function: {
+      name: string;
+    };
+  };
+  thinking?: {
+    enabled: boolean;
+    budgetTokens?: number;
+    level?: GoogleThinkingLevel;
+  };
+};
+type GoogleGenerateContentRequest = {
+  cachedContent?: string;
+  contents: Array<Record<string, unknown>>;
+  generationConfig?: Record<string, unknown>;
+  systemInstruction?: Record<string, unknown>;
+  tools?: Array<Record<string, unknown>>;
+  toolConfig?: Record<string, unknown>;
+};
+declare function buildGoogleGenerativeAiParams(model: GoogleTransportModel, context: Context, options?: GoogleTransportOptions): GoogleGenerateContentRequest;
+declare function buildGoogleGemini3FirstResponseRetryParams(params: {
+  model: GoogleTransportModel;
+  request: GoogleGenerateContentRequest;
+}): GoogleGenerateContentRequest | undefined;
+declare function createGoogleGenerativeAiTransportStreamFn(): StreamFn;
+declare function createGoogleVertexTransportStreamFn(): StreamFn;
+//#endregion
+export { createGoogleVertexTransportStreamFn as i, buildGoogleGenerativeAiParams as n, createGoogleGenerativeAiTransportStreamFn as r, buildGoogleGemini3FirstResponseRetryParams as t };

package/dist/tts-runtime-Dke0TQge.d.ts

@@ -0,0 +1,36 @@
+import { o as TtsRuntimeFacade } from "./tts-runtime.types-CiR5E2bC.js";
+//#region src/plugin-sdk/tts-runtime.d.ts
+type FacadeModule = TtsRuntimeFacade;
+declare function prewarmTtsRuntimeFacade(): void;
+declare const testApi: FacadeModule["testApi"];
+declare const buildTtsSystemPromptHint: FacadeModule["buildTtsSystemPromptHint"];
+declare const getLastTtsAttempt: FacadeModule["getLastTtsAttempt"];
+declare const getResolvedSpeechProviderConfig: FacadeModule["getResolvedSpeechProviderConfig"];
+declare const getTtsMaxLength: FacadeModule["getTtsMaxLength"];
+declare const getTtsPersona: FacadeModule["getTtsPersona"];
+declare const getTtsProvider: FacadeModule["getTtsProvider"];
+declare const isSummarizationEnabled: FacadeModule["isSummarizationEnabled"];
+declare const isTtsEnabled: FacadeModule["isTtsEnabled"];
+declare const isTtsProviderConfigured: FacadeModule["isTtsProviderConfigured"];
+declare const listSpeechVoices: FacadeModule["listSpeechVoices"];
+declare const listTtsPersonas: FacadeModule["listTtsPersonas"];
+declare const maybeApplyTtsToPayload: FacadeModule["maybeApplyTtsToPayload"];
+declare const resolveExplicitTtsOverrides: FacadeModule["resolveExplicitTtsOverrides"];
+declare const resolveTtsAutoMode: FacadeModule["resolveTtsAutoMode"];
+declare const resolveTtsConfig: FacadeModule["resolveTtsConfig"];
+declare const resolveTtsPrefsPath: FacadeModule["resolveTtsPrefsPath"];
+declare const resolveTtsProviderOrder: FacadeModule["resolveTtsProviderOrder"];
+declare const setLastTtsAttempt: FacadeModule["setLastTtsAttempt"];
+declare const setSummarizationEnabled: FacadeModule["setSummarizationEnabled"];
+declare const setTtsAutoMode: FacadeModule["setTtsAutoMode"];
+declare const setTtsEnabled: FacadeModule["setTtsEnabled"];
+declare const setTtsMaxLength: FacadeModule["setTtsMaxLength"];
+declare const setTtsPersona: FacadeModule["setTtsPersona"];
+declare const setTtsProvider: FacadeModule["setTtsProvider"];
+declare const synthesizeSpeech: FacadeModule["synthesizeSpeech"];
+declare const streamSpeech: FacadeModule["streamSpeech"];
+declare const textToSpeech: FacadeModule["textToSpeech"];
+declare const textToSpeechStream: FacadeModule["textToSpeechStream"];
+declare const textToSpeechTelephony: FacadeModule["textToSpeechTelephony"];
+//#endregion
+export { textToSpeechStream as A, setTtsMaxLength as C, synthesizeSpeech as D, streamSpeech as E, testApi as O, setTtsEnabled as S, setTtsProvider as T, resolveTtsPrefsPath as _, getTtsPersona as a, setSummarizationEnabled as b, isTtsEnabled as c, listTtsPersonas as d, maybeApplyTtsToPayload as f, resolveTtsConfig as g, resolveTtsAutoMode as h, getTtsMaxLength as i, textToSpeechTelephony as j, textToSpeech as k, isTtsProviderConfigured as l, resolveExplicitTtsOverrides as m, getLastTtsAttempt as n, getTtsProvider as o, prewarmTtsRuntimeFacade as p, getResolvedSpeechProviderConfig as r, isSummarizationEnabled as s, buildTtsSystemPromptHint as t, listSpeechVoices as u, resolveTtsProviderOrder as v, setTtsPersona as w, setTtsAutoMode as x, setLastTtsAttempt as y };