@gaodefa/daocore 2026.5.99 → 2026.5.100

package/dist/realtime-voice-BIVbRMKd.d.ts

@@ -0,0 +1,333 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { r as RunEmbeddedPiAgentParams } from "./params-Bpqaub6s.js";
+import { o as PluginRuntimeCore, s as RuntimeLogger } from "./types-core-C_yvb0RI.js";
+import { Br as RealtimeVoiceBridgeEvent, Fr as RealtimeVoiceAudioFormat, Gr as RealtimeVoiceProviderConfig, Ir as RealtimeVoiceBargeInOptions, Lr as RealtimeVoiceBridge, Qr as RealtimeVoiceToolResultOptions, Ur as RealtimeVoiceCloseReason, Wn as RealtimeVoiceProviderPlugin, Xr as RealtimeVoiceTool, Yr as RealtimeVoiceRole, Zr as RealtimeVoiceToolCallEvent, qr as RealtimeVoiceProviderId } from "./types-DEEPn4W72.js";
+import { Dt as TalkEventInput, Et as TalkEventContext, Ot as TalkEventSequencer, Tt as TalkEvent, r as DiagnosticEventInput } from "./diagnostic-events-B6fVt4GX.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/talk/diagnostics.d.ts
+type TalkDiagnosticEventInput = Extract<DiagnosticEventInput, {
+  type: "talk.event";
+}>;
+declare function createTalkDiagnosticEvent(event: TalkEvent): TalkDiagnosticEventInput;
+declare function recordTalkDiagnosticEvent(event: TalkEvent): void;
+//#endregion
+//#region src/talk/logging.d.ts
+type TalkLogLevel = "info" | "warn";
+type TalkLogRecord = {
+  level: TalkLogLevel;
+  message: string;
+  attributes: Record<string, string | number | boolean>;
+};
+declare function createTalkLogRecord(event: TalkEvent): TalkLogRecord | undefined;
+declare function recordTalkLogEvent(event: TalkEvent): void;
+//#endregion
+//#region src/talk/observability.d.ts
+declare function recordTalkObservabilityEvent(event: TalkEvent): void;
+//#endregion
+//#region src/talk/talk-session-controller.d.ts
+type TalkTurnFailureReason = "no_active_turn" | "stale_turn";
+type TalkTurnSuccess = {
+  event: TalkEvent;
+  ok: true;
+  turnId: string;
+};
+type TalkTurnFailure = {
+  ok: false;
+  reason: TalkTurnFailureReason;
+};
+type TalkTurnResult = TalkTurnSuccess | TalkTurnFailure;
+type TalkEnsureTurnResult = {
+  event?: TalkEvent;
+  turnId: string;
+};
+type TalkSessionController = {
+  readonly activeTurnId: string | undefined;
+  readonly context: TalkEventContext;
+  readonly outputAudioActive: boolean;
+  readonly recentEvents: readonly TalkEvent[];
+  clearActiveTurn(): void;
+  emit<TPayload>(input: TalkEventInput<TPayload>): TalkEvent<TPayload>;
+  ensureTurn(params?: {
+    payload?: unknown;
+    turnId?: string;
+  }): TalkEnsureTurnResult;
+  startTurn(params?: {
+    payload?: unknown;
+    turnId?: string;
+  }): TalkEnsureTurnResult;
+  endTurn(params?: {
+    payload?: unknown;
+    turnId?: string;
+  }): TalkTurnResult;
+  cancelTurn(params?: {
+    payload?: unknown;
+    turnId?: string;
+  }): TalkTurnResult;
+  finishOutputAudio(params?: {
+    payload?: unknown;
+    turnId?: string;
+  }): TalkEvent | undefined;
+  startOutputAudio(params?: {
+    payload?: unknown;
+    turnId?: string;
+  }): TalkEnsureTurnResult;
+};
+type TalkSessionControllerParams = TalkEventContext & {
+  maxRecentEvents?: number;
+  turnIdPrefix?: string;
+};
+type TalkSessionControllerOptions = {
+  now?: () => Date | string;
+  onEvent?: (event: TalkEvent) => void;
+  sequencer?: TalkEventSequencer;
+};
+declare function createTalkSessionController(params: TalkSessionControllerParams, options?: TalkSessionControllerOptions): TalkSessionController;
+declare function normalizeTalkTransport(value: string | undefined): string | undefined;
+//#endregion
+//#region src/talk/agent-consult-tool.d.ts
+declare const REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME = "daocore_agent_consult";
+declare const REALTIME_VOICE_AGENT_CONSULT_TOOL_POLICIES: readonly ["safe-read-only", "owner", "none"];
+type RealtimeVoiceAgentConsultToolPolicy = (typeof REALTIME_VOICE_AGENT_CONSULT_TOOL_POLICIES)[number];
+type RealtimeVoiceAgentConsultArgs = {
+  question: string;
+  context?: string;
+  responseStyle?: string;
+};
+type RealtimeVoiceAgentConsultTranscriptEntry = {
+  role: "user" | "assistant";
+  text: string;
+};
+declare const REALTIME_VOICE_AGENT_CONSULT_TOOL: RealtimeVoiceTool;
+declare function buildRealtimeVoiceAgentConsultWorkingResponse(audienceLabel?: string): Record<string, unknown>;
+declare function isRealtimeVoiceAgentConsultToolPolicy(value: unknown): value is RealtimeVoiceAgentConsultToolPolicy;
+declare function resolveRealtimeVoiceAgentConsultToolPolicy(value: unknown, fallback: RealtimeVoiceAgentConsultToolPolicy): RealtimeVoiceAgentConsultToolPolicy;
+declare function resolveRealtimeVoiceAgentConsultTools(policy: RealtimeVoiceAgentConsultToolPolicy, customTools?: RealtimeVoiceTool[]): RealtimeVoiceTool[];
+declare function resolveRealtimeVoiceAgentConsultToolsAllow(policy: RealtimeVoiceAgentConsultToolPolicy): string[] | undefined;
+declare function buildRealtimeVoiceAgentConsultPolicyInstructions(config: {
+  toolPolicy: RealtimeVoiceAgentConsultToolPolicy;
+  consultPolicy?: "auto" | "substantive" | "always";
+}): string | undefined;
+declare function parseRealtimeVoiceAgentConsultArgs(args: unknown): RealtimeVoiceAgentConsultArgs;
+declare function buildRealtimeVoiceAgentConsultChatMessage(args: unknown): string;
+declare function buildRealtimeVoiceAgentConsultPrompt(params: {
+  args: unknown;
+  transcript: RealtimeVoiceAgentConsultTranscriptEntry[];
+  surface: string;
+  userLabel: string;
+  assistantLabel?: string;
+  questionSourceLabel?: string;
+}): string;
+declare function collectRealtimeVoiceAgentConsultVisibleText(payloads: Array<{
+  text?: unknown;
+  isError?: boolean;
+  isReasoning?: boolean;
+}>): string | null;
+//#endregion
+//#region src/talk/agent-consult-runtime.d.ts
+type RealtimeVoiceAgentConsultRuntime = PluginRuntimeCore["agent"];
+type RealtimeVoiceAgentConsultResult = {
+  text: string;
+};
+type RealtimeVoiceAgentConsultContextMode = "isolated" | "fork";
+declare function consultRealtimeVoiceAgent(params: {
+  cfg: DaoCoreConfig;
+  agentRuntime: RealtimeVoiceAgentConsultRuntime;
+  logger: Pick<RuntimeLogger, "warn">;
+  sessionKey: string;
+  messageProvider: string;
+  lane: string;
+  runIdPrefix: string;
+  args: unknown;
+  transcript: RealtimeVoiceAgentConsultTranscriptEntry[];
+  surface: string;
+  userLabel: string;
+  assistantLabel?: string;
+  questionSourceLabel?: string;
+  agentId?: string;
+  spawnedBy?: string | null;
+  contextMode?: RealtimeVoiceAgentConsultContextMode;
+  provider?: RunEmbeddedPiAgentParams["provider"];
+  model?: RunEmbeddedPiAgentParams["model"];
+  thinkLevel?: RunEmbeddedPiAgentParams["thinkLevel"];
+  fastMode?: RunEmbeddedPiAgentParams["fastMode"];
+  timeoutMs?: number;
+  toolsAllow?: string[];
+  extraSystemPrompt?: string;
+  fallbackText?: string;
+}): Promise<RealtimeVoiceAgentConsultResult>;
+//#endregion
+//#region src/talk/agent-talkback-runtime.d.ts
+type RealtimeVoiceAgentTalkbackResult = {
+  text: string;
+};
+type RealtimeVoiceAgentTalkbackQueue = {
+  close(): void;
+  enqueue(question: string, metadata?: unknown): void;
+};
+type RealtimeVoiceAgentTalkbackQueueParams = {
+  debounceMs: number;
+  isStopped: () => boolean;
+  logger: Pick<RuntimeLogger, "info" | "warn">;
+  logPrefix: string;
+  responseStyle: string;
+  fallbackText: string;
+  consult: (args: {
+    question: string;
+    metadata?: unknown;
+    responseStyle: string;
+    signal: AbortSignal;
+  }) => Promise<RealtimeVoiceAgentTalkbackResult>;
+  deliver: (text: string) => void;
+};
+declare function createRealtimeVoiceAgentTalkbackQueue(params: RealtimeVoiceAgentTalkbackQueueParams): RealtimeVoiceAgentTalkbackQueue;
+//#endregion
+//#region src/talk/fast-context-runtime.d.ts
+type Logger = {
+  debug?: (message: string) => void;
+};
+type RealtimeVoiceFastContextConfig = {
+  enabled: boolean;
+  maxResults: number;
+  sources: Array<"memory" | "sessions">;
+  timeoutMs: number;
+  fallbackToConsult: boolean;
+};
+type RealtimeVoiceFastContextLabels = {
+  audienceLabel: string;
+  contextName: string;
+};
+type RealtimeVoiceFastContextConsultResult = {
+  handled: false;
+} | {
+  handled: true;
+  result: RealtimeVoiceAgentConsultResult;
+};
+declare function resolveRealtimeVoiceFastContextConsult(params: {
+  cfg: DaoCoreConfig;
+  agentId: string;
+  sessionKey: string;
+  config: RealtimeVoiceFastContextConfig;
+  args: unknown;
+  logger: Logger;
+  labels?: Partial<RealtimeVoiceFastContextLabels>;
+}): Promise<RealtimeVoiceFastContextConsultResult>;
+//#endregion
+//#region src/talk/provider-registry.d.ts
+declare function normalizeRealtimeVoiceProviderId(providerId: string | undefined): RealtimeVoiceProviderId | undefined;
+declare function listRealtimeVoiceProviders(cfg?: DaoCoreConfig): RealtimeVoiceProviderPlugin[];
+declare function getRealtimeVoiceProvider(providerId: string | undefined, cfg?: DaoCoreConfig): RealtimeVoiceProviderPlugin | undefined;
+declare function canonicalizeRealtimeVoiceProviderId(providerId: string | undefined, cfg?: DaoCoreConfig): RealtimeVoiceProviderId | undefined;
+//#endregion
+//#region src/talk/provider-resolver.d.ts
+type ResolvedRealtimeVoiceProvider = {
+  provider: RealtimeVoiceProviderPlugin;
+  providerConfig: RealtimeVoiceProviderConfig;
+};
+type ResolveConfiguredRealtimeVoiceProviderParams = {
+  configuredProviderId?: string;
+  providerConfigs?: Record<string, Record<string, unknown> | undefined>;
+  providerConfigOverrides?: Record<string, unknown>;
+  cfg?: DaoCoreConfig;
+  cfgForResolve?: DaoCoreConfig;
+  providers?: RealtimeVoiceProviderPlugin[];
+  defaultModel?: string;
+  noRegisteredProviderMessage?: string;
+};
+declare function resolveConfiguredRealtimeVoiceProvider(params: ResolveConfiguredRealtimeVoiceProviderParams): ResolvedRealtimeVoiceProvider;
+//#endregion
+//#region src/talk/session-runtime.d.ts
+type RealtimeVoiceAudioSink = {
+  isOpen?: () => boolean;
+  sendAudio: (audio: Buffer) => void;
+  clearAudio?: () => void;
+  sendMark?: (markName: string) => void;
+};
+type RealtimeVoiceMarkStrategy = "transport" | "ack-immediately" | "ignore";
+type RealtimeVoiceBridgeSession = {
+  bridge: RealtimeVoiceBridge;
+  acknowledgeMark(): void;
+  close(): void;
+  connect(): Promise<void>;
+  sendAudio(audio: Buffer): void;
+  sendUserMessage(text: string): void;
+  handleBargeIn(options?: RealtimeVoiceBargeInOptions): void;
+  setMediaTimestamp(ts: number): void;
+  submitToolResult(callId: string, result: unknown, options?: RealtimeVoiceToolResultOptions): void;
+  triggerGreeting(instructions?: string): void;
+};
+type RealtimeVoiceBridgeSessionParams = {
+  provider: RealtimeVoiceProviderPlugin;
+  cfg?: DaoCoreConfig;
+  providerConfig: RealtimeVoiceProviderConfig;
+  audioFormat?: RealtimeVoiceAudioFormat;
+  audioSink: RealtimeVoiceAudioSink;
+  instructions?: string;
+  initialGreetingInstructions?: string;
+  autoRespondToAudio?: boolean;
+  interruptResponseOnInputAudio?: boolean;
+  markStrategy?: RealtimeVoiceMarkStrategy;
+  triggerGreetingOnReady?: boolean;
+  tools?: RealtimeVoiceTool[];
+  onTranscript?: (role: RealtimeVoiceRole, text: string, isFinal: boolean) => void;
+  onEvent?: (event: RealtimeVoiceBridgeEvent) => void;
+  onToolCall?: (event: RealtimeVoiceToolCallEvent, session: RealtimeVoiceBridgeSession) => void;
+  onReady?: (session: RealtimeVoiceBridgeSession) => void;
+  onError?: (error: Error) => void;
+  onClose?: (reason: RealtimeVoiceCloseReason) => void;
+};
+declare function createRealtimeVoiceBridgeSession(params: RealtimeVoiceBridgeSessionParams): RealtimeVoiceBridgeSession;
+//#endregion
+//#region src/talk/session-log-runtime.d.ts
+type RealtimeVoiceTranscriptEntry = {
+  at: string;
+  role: RealtimeVoiceRole;
+  text: string;
+};
+type RealtimeVoiceTranscriptHealth = {
+  realtimeTranscriptLines: number;
+  lastRealtimeTranscriptAt?: string;
+  lastRealtimeTranscriptRole?: RealtimeVoiceRole;
+  lastRealtimeTranscriptText?: string;
+  recentRealtimeTranscript: RealtimeVoiceTranscriptEntry[];
+};
+type RealtimeVoiceBridgeEventLogEntry = RealtimeVoiceBridgeEvent & {
+  at: string;
+};
+type RealtimeVoiceBridgeEventHealth = {
+  lastRealtimeEventAt?: string;
+  lastRealtimeEventType?: string;
+  lastRealtimeEventDetail?: string;
+  recentRealtimeEvents: RealtimeVoiceBridgeEventLogEntry[];
+};
+declare function recordRealtimeVoiceTranscript(transcript: RealtimeVoiceTranscriptEntry[], role: RealtimeVoiceRole, text: string, maxEntries?: number): RealtimeVoiceTranscriptEntry;
+declare function getRealtimeVoiceTranscriptHealth(transcript: RealtimeVoiceTranscriptEntry[]): RealtimeVoiceTranscriptHealth;
+declare function recordRealtimeVoiceBridgeEvent(events: RealtimeVoiceBridgeEventLogEntry[], event: RealtimeVoiceBridgeEvent, maxEntries?: number): void;
+declare function getRealtimeVoiceBridgeEventHealth(events: RealtimeVoiceBridgeEventLogEntry[]): RealtimeVoiceBridgeEventHealth;
+declare function isLikelyRealtimeVoiceAssistantEchoTranscript(params: {
+  transcript: RealtimeVoiceTranscriptEntry[];
+  text: string;
+  lookbackMs: number;
+  nowMs?: number;
+}): boolean;
+declare function extendRealtimeVoiceOutputEchoSuppression(params: {
+  audio: Buffer;
+  bytesPerMs: number;
+  tailMs: number;
+  nowMs: number;
+  lastOutputPlayableUntilMs: number;
+  suppressInputUntilMs: number;
+}): {
+  lastOutputPlayableUntilMs: number;
+  suppressInputUntilMs: number;
+  durationMs: number;
+};
+//#endregion
+//#region src/talk/audio-codec.d.ts
+declare function resamplePcm(input: Buffer, inputSampleRate: number, outputSampleRate: number): Buffer;
+declare function resamplePcmTo8k(input: Buffer, inputSampleRate: number): Buffer;
+declare function pcmToMulaw(pcm: Buffer): Buffer;
+declare function mulawToPcm(mulaw: Buffer): Buffer;
+declare function convertPcmToMulaw8k(pcm: Buffer, inputSampleRate: number): Buffer;
+//#endregion
+export { resolveRealtimeVoiceAgentConsultTools as $, RealtimeVoiceFastContextLabels as A, REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME as B, resolveConfiguredRealtimeVoiceProvider as C, normalizeRealtimeVoiceProviderId as D, listRealtimeVoiceProviders as E, createRealtimeVoiceAgentTalkbackQueue as F, buildRealtimeVoiceAgentConsultChatMessage as G, RealtimeVoiceAgentConsultArgs as H, RealtimeVoiceAgentConsultResult as I, buildRealtimeVoiceAgentConsultWorkingResponse as J, buildRealtimeVoiceAgentConsultPolicyInstructions as K, RealtimeVoiceAgentConsultRuntime as L, RealtimeVoiceAgentTalkbackQueue as M, RealtimeVoiceAgentTalkbackQueueParams as N, RealtimeVoiceFastContextConfig as O, RealtimeVoiceAgentTalkbackResult as P, resolveRealtimeVoiceAgentConsultToolPolicy as Q, consultRealtimeVoiceAgent as R, ResolvedRealtimeVoiceProvider as S, getRealtimeVoiceProvider as T, RealtimeVoiceAgentConsultToolPolicy as U, REALTIME_VOICE_AGENT_CONSULT_TOOL_POLICIES as V, RealtimeVoiceAgentConsultTranscriptEntry as W, isRealtimeVoiceAgentConsultToolPolicy as X, collectRealtimeVoiceAgentConsultVisibleText as Y, parseRealtimeVoiceAgentConsultArgs as Z, RealtimeVoiceBridgeSession as _, resamplePcmTo8k as a, TalkTurnFailure as at, createRealtimeVoiceBridgeSession as b, RealtimeVoiceTranscriptEntry as c, TalkTurnSuccess as ct, getRealtimeVoiceBridgeEventHealth as d, recordTalkObservabilityEvent as dt, resolveRealtimeVoiceAgentConsultToolsAllow as et, getRealtimeVoiceTranscriptHealth as f, createTalkLogRecord as ft, RealtimeVoiceAudioSink as g, recordRealtimeVoiceTranscript as h, recordTalkDiagnosticEvent as ht, resamplePcm as i, TalkSessionControllerParams as it, resolveRealtimeVoiceFastContextConsult as j, RealtimeVoiceFastContextConsultResult as k, RealtimeVoiceTranscriptHealth as l, createTalkSessionController as lt, recordRealtimeVoiceBridgeEvent as m, createTalkDiagnosticEvent as mt, mulawToPcm as n, TalkSessionController as nt, RealtimeVoiceBridgeEventHealth as o, TalkTurnFailureReason as ot, isLikelyRealtimeVoiceAssistantEchoTranscript as p, recordTalkLogEvent as pt, buildRealtimeVoiceAgentConsultPrompt as q, pcmToMulaw as r, TalkSessionControllerOptions as rt, RealtimeVoiceBridgeEventLogEntry as s, TalkTurnResult as st, convertPcmToMulaw8k as t, TalkEnsureTurnResult as tt, extendRealtimeVoiceOutputEchoSuppression as u, normalizeTalkTransport as ut, RealtimeVoiceBridgeSessionParams as v, canonicalizeRealtimeVoiceProviderId as w, ResolveConfiguredRealtimeVoiceProviderParams as x, RealtimeVoiceMarkStrategy as y, REALTIME_VOICE_AGENT_CONSULT_TOOL as z };

package/dist/realtime-voice-provider-D3jgKIsl.d.ts

@@ -0,0 +1,5 @@
+import { Wn as RealtimeVoiceProviderPlugin } from "./types-DEEPn4W72.js";
+//#region extensions/openai/realtime-voice-provider.d.ts
+declare function buildOpenAIRealtimeVoiceProvider(): RealtimeVoiceProviderPlugin;
+//#endregion
+export { buildOpenAIRealtimeVoiceProvider as t };

package/dist/redact-VIk1TlaT.d.ts

@@ -0,0 +1,27 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+
+//#region src/logging/redact.d.ts
+type RedactSensitiveMode = "off" | "tools";
+type RedactPattern = string | RegExp;
+type LoggingConfig = DaoCoreConfig["logging"];
+type RedactOptions = {
+  mode?: RedactSensitiveMode;
+  patterns?: RedactPattern[];
+};
+type ResolvedRedactOptions = {
+  mode: RedactSensitiveMode;
+  patterns: RegExp[];
+};
+declare function resolveRedactOptions(options?: RedactOptions): ResolvedRedactOptions;
+declare function redactSensitiveText(text: string, options?: RedactOptions): string;
+declare function redactToolDetail(detail: string): string;
+declare function redactToolPayloadText(text: string): string;
+declare function redactToolPayloadTextWithConfig(text: string, loggingConfig?: LoggingConfig): string;
+declare function isSensitiveFieldKey(key: string): boolean;
+declare function redactSensitiveFieldValue(key: string, value: string, options?: RedactOptions): string;
+declare function redactSensitiveFieldValueWithConfig(key: string, value: string, loggingConfig?: LoggingConfig): string;
+declare function redactSecrets<T>(value: T): T;
+declare function getDefaultRedactPatterns(): string[];
+declare function redactSensitiveLines(lines: string[], resolved: ResolvedRedactOptions): string[];
+//#endregion
+export { getDefaultRedactPatterns as a, redactSensitiveFieldValue as c, redactSensitiveText as d, redactToolDetail as f, resolveRedactOptions as h, ResolvedRedactOptions as i, redactSensitiveFieldValueWithConfig as l, redactToolPayloadTextWithConfig as m, RedactPattern as n, isSensitiveFieldKey as o, redactToolPayloadText as p, RedactSensitiveMode as r, redactSecrets as s, RedactOptions as t, redactSensitiveLines as u };

package/dist/redact-identifier-Dz0LM8AR.d.ts

@@ -0,0 +1,253 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { n as RuntimeEnv } from "./runtime-Bxifh4bY.js";
+import { t as SubsystemLogger } from "./subsystem-Ce5qcC5n.js";
+import { H as DiagnosticSessionActiveWorkKind, Y as DiagnosticSessionState, _ as DiagnosticLivenessWarningReason, x as DiagnosticMemoryUsage } from "./diagnostic-events-B6fVt4GX.js";
+
+//#region src/logger.d.ts
+declare function logInfo(message: string, runtime?: RuntimeEnv): void;
+declare function logWarn(message: string, runtime?: RuntimeEnv): void;
+declare function logSuccess(message: string, runtime?: RuntimeEnv): void;
+declare function logError(message: string, runtime?: RuntimeEnv): void;
+declare function logDebug(message: string): void;
+//#endregion
+//#region src/logging/diagnostic-memory.d.ts
+type DiagnosticMemoryThresholds = {
+  rssWarningBytes?: number;
+  rssCriticalBytes?: number;
+  heapUsedWarningBytes?: number;
+  heapUsedCriticalBytes?: number;
+  rssGrowthWarningBytes?: number;
+  rssGrowthCriticalBytes?: number;
+  growthWindowMs?: number;
+  pressureRepeatMs?: number;
+};
+declare function emitDiagnosticMemorySample(options?: {
+  now?: number;
+  memoryUsage?: NodeJS.MemoryUsage;
+  uptimeMs?: number;
+  thresholds?: DiagnosticMemoryThresholds;
+  emitSample?: boolean;
+  writeCriticalBundle?: boolean;
+  stateDir?: string;
+  sessionStorePaths?: string[];
+  resolveSessionStorePaths?: () => string[] | undefined;
+}): DiagnosticMemoryUsage;
+//#endregion
+//#region src/logging/diagnostic-session-attention.d.ts
+type SessionAttentionClassification = {
+  eventType: "session.long_running";
+  reason: string;
+  classification: "long_running";
+  activeWorkKind?: DiagnosticSessionActiveWorkKind;
+  recoveryEligible: false;
+} | {
+  eventType: "session.stalled";
+  reason: string;
+  classification: "blocked_tool_call" | "stalled_agent_run";
+  activeWorkKind?: DiagnosticSessionActiveWorkKind;
+  recoveryEligible: false;
+} | {
+  eventType: "session.stuck";
+  reason: string;
+  classification: "stale_session_state";
+  activeWorkKind?: undefined;
+  recoveryEligible: true;
+};
+//#endregion
+//#region src/logging/diagnostic-session-recovery.d.ts
+type DiagnosticSessionRecoverySkipReason = "active_embedded_run" | "active_reply_work" | "active_lane_task" | "already_in_flight" | "missing_session_ref" | "stale_session_state";
+type DiagnosticSessionRecoveryNoopReason = "no_active_work";
+type StuckSessionRecoveryRequest = {
+  sessionId?: string;
+  sessionKey?: string;
+  ageMs: number;
+  queueDepth?: number;
+  allowActiveAbort?: boolean;
+  expectedState?: DiagnosticSessionState;
+  stateGeneration?: number;
+};
+type DiagnosticSessionRecoveryBaseOutcome = {
+  sessionId?: string;
+  sessionKey?: string;
+  activeSessionId?: string;
+  lane?: string;
+  activeWorkKind?: DiagnosticSessionActiveWorkKind;
+};
+type StuckSessionRecoveryOutcome = (DiagnosticSessionRecoveryBaseOutcome & {
+  status: "aborted";
+  action: "abort_embedded_run";
+  aborted: boolean;
+  drained: boolean;
+  forceCleared: boolean;
+  released: number;
+  queuedCount?: number;
+}) | (DiagnosticSessionRecoveryBaseOutcome & {
+  status: "released";
+  action: "release_lane";
+  released: number;
+}) | (DiagnosticSessionRecoveryBaseOutcome & {
+  status: "skipped";
+  action: "observe_only" | "keep_lane";
+  reason: DiagnosticSessionRecoverySkipReason;
+  activeCount?: number;
+  queuedCount?: number;
+}) | (DiagnosticSessionRecoveryBaseOutcome & {
+  status: "noop";
+  action: "none";
+  reason: DiagnosticSessionRecoveryNoopReason;
+}) | (DiagnosticSessionRecoveryBaseOutcome & {
+  status: "failed";
+  action: "none";
+  reason: "exception";
+  error: string;
+});
+//#endregion
+//#region src/logging/diagnostic-session-recovery-coordinator.d.ts
+type RecoverStuckSession = (params: StuckSessionRecoveryRequest) => void | StuckSessionRecoveryOutcome | Promise<void | StuckSessionRecoveryOutcome>;
+//#endregion
+//#region src/logging/diagnostic-session-state.d.ts
+type SessionStateValue = "idle" | "processing" | "waiting";
+type SessionRef = {
+  sessionId?: string;
+  sessionKey?: string;
+};
+//#endregion
+//#region src/logging/diagnostic-runtime.d.ts
+declare const diagnosticLogger: SubsystemLogger;
+declare function logLaneEnqueue(lane: string, queueSize: number): void;
+declare function logLaneDequeue(lane: string, waitMs: number, queueSize: number): void;
+//#endregion
+//#region src/logging/diagnostic.d.ts
+type EmitDiagnosticMemorySample = typeof emitDiagnosticMemorySample;
+type DiagnosticWorkSnapshot = {
+  activeCount: number;
+  waitingCount: number;
+  queuedCount: number;
+  activeLabels: string[];
+  waitingLabels: string[];
+  queuedLabels: string[];
+};
+type DiagnosticLivenessSample = {
+  reasons: DiagnosticLivenessWarningReason[];
+  intervalMs: number;
+  eventLoopDelayP99Ms?: number;
+  eventLoopDelayMaxMs?: number;
+  eventLoopUtilization?: number;
+  cpuUserMs?: number;
+  cpuSystemMs?: number;
+  cpuTotalMs?: number;
+  cpuCoreRatio?: number;
+};
+type SampleDiagnosticLiveness = (now: number, work: DiagnosticWorkSnapshot) => DiagnosticLivenessSample | null;
+type StartDiagnosticHeartbeatOptions = {
+  getConfig?: () => DaoCoreConfig;
+  emitMemorySample?: EmitDiagnosticMemorySample;
+  sampleLiveness?: SampleDiagnosticLiveness;
+  recoverStuckSession?: RecoverStuckSession;
+  startupGraceMs?: number;
+};
+declare function resolveStuckSessionWarnMs(config?: DaoCoreConfig): number;
+declare function resolveStuckSessionAbortMs(config: DaoCoreConfig | undefined, stuckSessionWarnMs: number): number;
+declare function logWebhookReceived(params: {
+  channel: string;
+  updateType?: string;
+  chatId?: number | string;
+}): void;
+declare function logWebhookProcessed(params: {
+  channel: string;
+  updateType?: string;
+  chatId?: number | string;
+  durationMs?: number;
+}): void;
+declare function logWebhookError(params: {
+  channel: string;
+  updateType?: string;
+  chatId?: number | string;
+  error: string;
+}): void;
+declare function logMessageQueued(params: {
+  sessionId?: string;
+  sessionKey?: string;
+  channel?: string;
+  source: string;
+}): void;
+declare function logMessageReceived(params: {
+  sessionId?: string;
+  sessionKey?: string;
+  channel?: string;
+  messageId?: number | string;
+  chatId?: number | string;
+  source: string;
+}): void;
+declare function logMessageDispatchStarted(params: {
+  sessionId?: string;
+  sessionKey?: string;
+  channel?: string;
+  source: string;
+}): void;
+declare function logMessageDispatchCompleted(params: {
+  sessionId?: string;
+  sessionKey?: string;
+  channel?: string;
+  source: string;
+  durationMs: number;
+  outcome: "completed" | "skipped" | "error";
+  reason?: string;
+  error?: string;
+}): void;
+declare function logMessageProcessed(params: {
+  channel: string;
+  messageId?: number | string;
+  chatId?: number | string;
+  sessionId?: string;
+  sessionKey?: string;
+  durationMs?: number;
+  outcome: "completed" | "skipped" | "error";
+  reason?: string;
+  error?: string;
+}): void;
+declare function logSessionTurnCreated(params: {
+  runId: string;
+  sessionId?: string;
+  sessionKey?: string;
+  agentId?: string;
+  channel?: string;
+  trigger: "user" | "heartbeat";
+}): void;
+declare function logSessionStateChange(params: SessionRef & {
+  state: SessionStateValue;
+  reason?: string;
+}): void;
+declare function markDiagnosticSessionProgress(params: SessionRef): void;
+declare function logSessionAttention(params: SessionRef & {
+  state: SessionStateValue;
+  ageMs: number;
+  thresholdMs: number;
+  abortThresholdMs?: number;
+}): SessionAttentionClassification | undefined;
+declare function logRunAttempt(params: SessionRef & {
+  runId: string;
+  attempt: number;
+}): void;
+declare function logToolLoopAction(params: SessionRef & {
+  toolName: string;
+  level: "warning" | "critical";
+  action: "warn" | "block";
+  detector: "generic_repeat" | "unknown_tool_repeat" | "known_poll_no_progress" | "global_circuit_breaker" | "ping_pong";
+  count: number;
+  message: string;
+  pairedToolName?: string;
+}): void;
+declare function logActiveRuns(): void;
+declare function startDiagnosticHeartbeat(config?: DaoCoreConfig, opts?: StartDiagnosticHeartbeatOptions): void;
+declare function stopDiagnosticHeartbeat(): void;
+declare function getDiagnosticSessionStateCountForTest(): number;
+declare function resetDiagnosticStateForTest(): void;
+//#endregion
+//#region src/logging/redact-identifier.d.ts
+declare function sha256HexPrefix(value: string, len?: number): string;
+declare function redactIdentifier(value: string | undefined, opts?: {
+  len?: number;
+}): string;
+//#endregion
+export { logSuccess as A, stopDiagnosticHeartbeat as C, logDebug as D, logLaneEnqueue as E, logError as O, startDiagnosticHeartbeat as S, logLaneDequeue as T, logWebhookReceived as _, logMessageDispatchCompleted as a, resolveStuckSessionAbortMs as b, logMessageQueued as c, logSessionAttention as d, logSessionStateChange as f, logWebhookProcessed as g, logWebhookError as h, logActiveRuns as i, logWarn as j, logInfo as k, logMessageReceived as l, logToolLoopAction as m, sha256HexPrefix as n, logMessageDispatchStarted as o, logSessionTurnCreated as p, getDiagnosticSessionStateCountForTest as r, logMessageProcessed as s, redactIdentifier as t, logRunAttempt as u, markDiagnosticSessionProgress as v, diagnosticLogger as w, resolveStuckSessionWarnMs as x, resetDiagnosticStateForTest as y };

package/dist/register.runtime-Csi7ot09.d.ts

@@ -0,0 +1,6 @@
+import { l as DaoCorePluginApi, sn as ProviderPlugin } from "./types-DEEPn4W72.js";
+//#region extensions/anthropic/register.runtime.d.ts
+declare function buildAnthropicProvider(): ProviderPlugin;
+declare function registerAnthropicPlugin(api: DaoCorePluginApi): void;
+//#endregion
+export { registerAnthropicPlugin as n, buildAnthropicProvider as t };