@gaodefa/daocore 2026.5.100 → 2026.5.101

package/dist/memory-core-host-engine-embeddings-PolgO8GU.d.ts

@@ -0,0 +1,324 @@
+import { r as DaoCoreConfig } from "./types.daocore-z1fablj2.js";
+import { l as SecretInput } from "./types.secrets-tbFW-hY6.js";
+import { a as fetchWithSsrFGuard } from "./fetch-guard-BgaCy73h.js";
+import { l as shouldUseEnvHttpProxyForUrl } from "./proxy-env-5M_lscz9.js";
+import { m as EmbeddingInput, t as MemoryChunk } from "./internal-B1IX4tl2.js";
+
+//#region packages/memory-host-sdk/src/host/embeddings.types.d.ts
+type EmbeddingProvider = {
+  id: string;
+  model: string;
+  maxInputTokens?: number;
+  embedQuery: (text: string, options?: EmbeddingProviderCallOptions) => Promise<number[]>;
+  embedBatch: (texts: string[], options?: EmbeddingProviderCallOptions) => Promise<number[][]>;
+  embedBatchInputs?: (inputs: EmbeddingInput[], options?: EmbeddingProviderCallOptions) => Promise<number[][]>;
+  close?: () => Promise<void> | void;
+};
+type EmbeddingProviderCallOptions = {
+  signal?: AbortSignal;
+};
+type EmbeddingProviderRequest = string;
+type EmbeddingProviderFallback = string;
+type GeminiTaskType = "RETRIEVAL_QUERY" | "RETRIEVAL_DOCUMENT" | "SEMANTIC_SIMILARITY" | "CLASSIFICATION" | "CLUSTERING" | "QUESTION_ANSWERING" | "FACT_VERIFICATION";
+type EmbeddingProviderOptions = {
+  config: DaoCoreConfig;
+  agentDir?: string;
+  provider?: EmbeddingProviderRequest;
+  remote?: {
+    baseUrl?: string;
+    apiKey?: SecretInput;
+    headers?: Record<string, string>;
+  };
+  model: string;
+  inputType?: string;
+  queryInputType?: string;
+  documentInputType?: string;
+  fallback?: EmbeddingProviderFallback;
+  local?: {
+    modelPath?: string;
+    modelCacheDir?: string;
+    /**
+     * Context size passed to node-llama-cpp `createEmbeddingContext`.
+     * Default: 4096, chosen to cover typical memory-search chunks (128–512 tokens)
+     * while keeping non-weight VRAM bounded.
+     * Set `"auto"` to let node-llama-cpp use the model's trained maximum — not
+     * recommended for 8B+ models (e.g. Qwen3-Embedding-8B: up to 40 960 tokens → ~32 GB VRAM).
+     */
+    contextSize?: number | "auto";
+  }; /** Provider-specific output vector dimensions for supported embedding families. */
+  outputDimensionality?: number; /** Gemini: override the default task type sent with embedding requests. */
+  taskType?: GeminiTaskType;
+};
+//#endregion
+//#region packages/memory-host-sdk/src/host/embedding-defaults.d.ts
+declare const DEFAULT_LOCAL_MODEL = "hf:ggml-org/embeddinggemma-300m-qat-q8_0-GGUF/embeddinggemma-300m-qat-Q8_0.gguf";
+//#endregion
+//#region packages/memory-host-sdk/src/host/embeddings.d.ts
+declare function createLocalEmbeddingProvider(options: EmbeddingProviderOptions): Promise<EmbeddingProvider>;
+//#endregion
+//#region packages/memory-host-sdk/src/host/batch-error-utils.d.ts
+type BatchOutputErrorLike = {
+  error?: {
+    message?: string;
+  };
+  response?: {
+    body?: string | {
+      error?: {
+        message?: string;
+      };
+    };
+  };
+};
+declare function extractBatchErrorMessage(lines: BatchOutputErrorLike[]): string | undefined;
+declare function formatUnavailableBatchError(err: unknown): string | undefined;
+//#endregion
+//#region packages/memory-host-sdk/src/host/retry-utils.d.ts
+type RetryConfig = {
+  attempts?: number;
+  minDelayMs?: number;
+  maxDelayMs?: number;
+  jitter?: number;
+};
+type RetryInfo = {
+  attempt: number;
+  maxAttempts: number;
+  delayMs: number;
+  err: unknown;
+  label?: string;
+};
+type RetryOptions = RetryConfig & {
+  label?: string;
+  shouldRetry?: (err: unknown, attempt: number) => boolean;
+  retryAfterMs?: (err: unknown) => number | undefined;
+  onRetry?: (info: RetryInfo) => void;
+};
+declare function retryAsync<T>(fn: () => Promise<T>, attemptsOrOptions?: number | RetryOptions, initialDelayMs?: number): Promise<T>;
+//#endregion
+//#region packages/memory-host-sdk/src/host/ssrf-policy.d.ts
+type SsrFPolicy = {
+  allowPrivateNetwork?: boolean;
+  dangerouslyAllowPrivateNetwork?: boolean;
+  allowRfc2544BenchmarkRange?: boolean;
+  allowIpv6UniqueLocalRange?: boolean;
+  allowedHostnames?: string[];
+  hostnameAllowlist?: string[];
+};
+//#endregion
+//#region packages/memory-host-sdk/src/host/batch-http.d.ts
+declare function postJsonWithRetry<T>(params: {
+  url: string;
+  headers: Record<string, string>;
+  ssrfPolicy?: SsrFPolicy;
+  fetchImpl?: typeof fetch;
+  retryImpl?: typeof retryAsync;
+  body: unknown;
+  errorPrefix: string;
+}): Promise<T>;
+//#endregion
+//#region packages/memory-host-sdk/src/host/batch-output.d.ts
+type EmbeddingBatchOutputLine = {
+  custom_id?: string;
+  error?: {
+    message?: string;
+  };
+  response?: {
+    status_code?: number;
+    body?: {
+      data?: Array<{
+        embedding?: number[];
+      }>;
+      error?: {
+        message?: string;
+      };
+    } | string;
+  };
+};
+declare function applyEmbeddingBatchOutputLine(params: {
+  line: EmbeddingBatchOutputLine;
+  remaining: Set<string>;
+  errors: string[];
+  byCustomId: Map<string, number[]>;
+}): void;
+//#endregion
+//#region packages/memory-host-sdk/src/host/batch-provider-common.d.ts
+type ProviderBatchOutputLine = EmbeddingBatchOutputLine;
+declare const EMBEDDING_BATCH_ENDPOINT = "/v1/embeddings";
+//#endregion
+//#region packages/memory-host-sdk/src/host/batch-runner.d.ts
+type EmbeddingBatchExecutionParams = {
+  wait: boolean;
+  pollIntervalMs: number;
+  timeoutMs: number;
+  concurrency: number;
+  debug?: (message: string, data?: Record<string, unknown>) => void;
+};
+declare function runEmbeddingBatchGroups<TRequest>(params: {
+  requests: TRequest[];
+  maxRequests: number;
+  wait: EmbeddingBatchExecutionParams["wait"];
+  pollIntervalMs: EmbeddingBatchExecutionParams["pollIntervalMs"];
+  timeoutMs: EmbeddingBatchExecutionParams["timeoutMs"];
+  concurrency: EmbeddingBatchExecutionParams["concurrency"];
+  debugLabel: string;
+  debug?: EmbeddingBatchExecutionParams["debug"];
+  runGroup: (args: {
+    group: TRequest[];
+    groupIndex: number;
+    groups: number;
+    byCustomId: Map<string, number[]>;
+  }) => Promise<void>;
+}): Promise<Map<string, number[]>>;
+declare function buildEmbeddingBatchGroupOptions<TRequest>(params: {
+  requests: TRequest[];
+} & EmbeddingBatchExecutionParams, options: {
+  maxRequests: number;
+  debugLabel: string;
+}): {
+  requests: TRequest[];
+  maxRequests: number;
+  wait: boolean;
+  pollIntervalMs: number;
+  timeoutMs: number;
+  concurrency: number;
+  debug: ((message: string, data?: Record<string, unknown>) => void) | undefined;
+  debugLabel: string;
+};
+//#endregion
+//#region packages/memory-host-sdk/src/host/batch-status.d.ts
+type BatchStatusLike = {
+  id?: string;
+  status?: string;
+  output_file_id?: string | null;
+  error_file_id?: string | null;
+};
+type BatchCompletionResult = {
+  outputFileId: string;
+  errorFileId?: string;
+};
+declare function resolveBatchCompletionFromStatus(params: {
+  provider: string;
+  batchId: string;
+  status: BatchStatusLike;
+}): BatchCompletionResult;
+declare function throwIfBatchTerminalFailure(params: {
+  provider: string;
+  status: BatchStatusLike;
+  readError: (errorFileId: string) => Promise<string | undefined>;
+}): Promise<void>;
+declare function resolveCompletedBatchResult(params: {
+  provider: string;
+  status: BatchStatusLike;
+  wait: boolean;
+  waitForBatch: () => Promise<BatchCompletionResult>;
+}): Promise<BatchCompletionResult>;
+//#endregion
+//#region packages/memory-host-sdk/src/host/batch-utils.d.ts
+type BatchHttpClientConfig = {
+  baseUrl?: string;
+  headers?: Record<string, string>;
+  ssrfPolicy?: SsrFPolicy;
+};
+declare function normalizeBatchBaseUrl(client: BatchHttpClientConfig): string;
+declare function buildBatchHeaders(client: Pick<BatchHttpClientConfig, "headers">, params: {
+  json: boolean;
+}): Record<string, string>;
+//#endregion
+//#region packages/memory-host-sdk/src/host/batch-upload.d.ts
+declare function uploadBatchJsonlFile(params: {
+  client: BatchHttpClientConfig;
+  requests: unknown[];
+  errorPrefix: string;
+}): Promise<string>;
+//#endregion
+//#region packages/memory-host-sdk/src/host/embedding-chunk-limits.d.ts
+declare function enforceEmbeddingMaxInputTokens(provider: EmbeddingProvider, chunks: MemoryChunk[], hardMaxInputTokens?: number): MemoryChunk[];
+//#endregion
+//#region packages/memory-host-sdk/src/host/embedding-provider-adapter-utils.d.ts
+declare function isMissingEmbeddingApiKeyError(err: unknown): boolean;
+declare function sanitizeEmbeddingCacheHeaders(headers: Record<string, string>, excludedHeaderNames: string[]): Array<[string, string]>;
+declare function mapBatchEmbeddingsByIndex(byCustomId: Map<string, number[]>, count: number): number[][];
+//#endregion
+//#region packages/memory-host-sdk/src/host/embedding-vectors.d.ts
+declare function sanitizeAndNormalizeEmbedding(vec: number[]): number[];
+//#endregion
+//#region packages/memory-host-sdk/src/host/embeddings-debug.d.ts
+declare function debugEmbeddingsLog(message: string, meta?: Record<string, unknown>): void;
+//#endregion
+//#region packages/memory-host-sdk/src/host/embeddings-model-normalize.d.ts
+declare function normalizeEmbeddingModelWithPrefixes(params: {
+  model: string;
+  defaultModel: string;
+  prefixes: string[];
+}): string;
+//#endregion
+//#region packages/memory-host-sdk/src/host/embeddings-remote-client.d.ts
+type RemoteEmbeddingProviderId = string;
+declare function resolveRemoteEmbeddingBearerClient(params: {
+  provider: RemoteEmbeddingProviderId;
+  options: EmbeddingProviderOptions;
+  defaultBaseUrl: string;
+}): Promise<{
+  baseUrl: string;
+  headers: Record<string, string>;
+  ssrfPolicy?: SsrFPolicy;
+}>;
+//#endregion
+//#region packages/memory-host-sdk/src/host/embeddings-remote-provider.d.ts
+type RemoteEmbeddingClient = {
+  baseUrl: string;
+  headers: Record<string, string>;
+  ssrfPolicy?: SsrFPolicy;
+  fetchImpl?: typeof fetch;
+  model: string;
+};
+declare function createRemoteEmbeddingProvider(params: {
+  id: string;
+  client: RemoteEmbeddingClient;
+  errorPrefix: string;
+  maxInputTokens?: number;
+}): EmbeddingProvider;
+declare function resolveRemoteEmbeddingClient(params: {
+  provider: RemoteEmbeddingProviderId;
+  options: EmbeddingProviderOptions;
+  defaultBaseUrl: string;
+  normalizeModel: (model: string) => string;
+}): Promise<RemoteEmbeddingClient>;
+//#endregion
+//#region packages/memory-host-sdk/src/host/embeddings-remote-fetch.d.ts
+declare function fetchRemoteEmbeddingVectors(params: {
+  url: string;
+  headers: Record<string, string>;
+  ssrfPolicy?: SsrFPolicy;
+  fetchImpl?: typeof fetch;
+  signal?: AbortSignal;
+  body: unknown;
+  errorPrefix: string;
+}): Promise<number[][]>;
+//#endregion
+//#region packages/memory-host-sdk/src/host/embedding-input-limits.d.ts
+declare function estimateUtf8Bytes(text: string): number;
+declare function estimateStructuredEmbeddingInputBytes(input: EmbeddingInput): number;
+//#endregion
+//#region packages/memory-host-sdk/src/host/remote-http.d.ts
+declare const buildRemoteBaseUrlPolicy: (baseUrl: string) => SsrFPolicy | undefined;
+declare function withRemoteHttpResponse<T>(params: {
+  url: string;
+  init?: RequestInit;
+  signal?: AbortSignal;
+  ssrfPolicy?: SsrFPolicy;
+  fetchImpl?: typeof fetch;
+  fetchWithSsrFGuardImpl?: typeof fetchWithSsrFGuard;
+  shouldUseEnvHttpProxyForUrlImpl?: typeof shouldUseEnvHttpProxyForUrl;
+  auditContext?: string;
+  onResponse: (response: Response) => Promise<T>;
+}): Promise<T>;
+//#endregion
+//#region src/plugin-sdk/memory-core-host-engine-embeddings.d.ts
+type EmbeddingBatchStatus = {
+  id?: string;
+  status?: string;
+  output_file_id?: string | null;
+  error_file_id?: string | null;
+};
+//#endregion
+export { EMBEDDING_BATCH_ENDPOINT as A, BatchCompletionResult as C, EmbeddingBatchExecutionParams as D, throwIfBatchTerminalFailure as E, formatUnavailableBatchError as F, createLocalEmbeddingProvider as I, DEFAULT_LOCAL_MODEL as L, applyEmbeddingBatchOutputLine as M, postJsonWithRetry as N, buildEmbeddingBatchGroupOptions as O, extractBatchErrorMessage as P, normalizeBatchBaseUrl as S, resolveCompletedBatchResult as T, sanitizeEmbeddingCacheHeaders as _, estimateUtf8Bytes as a, BatchHttpClientConfig as b, createRemoteEmbeddingProvider as c, resolveRemoteEmbeddingBearerClient as d, normalizeEmbeddingModelWithPrefixes as f, mapBatchEmbeddingsByIndex as g, isMissingEmbeddingApiKeyError as h, estimateStructuredEmbeddingInputBytes as i, ProviderBatchOutputLine as j, runEmbeddingBatchGroups as k, resolveRemoteEmbeddingClient as l, sanitizeAndNormalizeEmbedding as m, buildRemoteBaseUrlPolicy as n, fetchRemoteEmbeddingVectors as o, debugEmbeddingsLog as p, withRemoteHttpResponse as r, RemoteEmbeddingClient as s, EmbeddingBatchStatus as t, RemoteEmbeddingProviderId as u, enforceEmbeddingMaxInputTokens as v, resolveBatchCompletionFromStatus as w, buildBatchHeaders as x, uploadBatchJsonlFile as y };

package/dist/memory-core-host-engine-storage-Cq883pVN.d.ts

@@ -0,0 +1,54 @@
+import { a as SqliteWalMaintenance, o as SqliteWalMaintenanceOptions } from "./daocore-runtime-J-ELfByH.js";
+import { DatabaseSync } from "node:sqlite";
+
+//#region packages/memory-host-sdk/src/host/memory-schema.d.ts
+declare function ensureMemoryIndexSchema(params: {
+  db: DatabaseSync;
+  embeddingCacheTable: string;
+  cacheEnabled: boolean;
+  ftsTable: string;
+  ftsEnabled: boolean;
+  ftsTokenizer?: "unicode61" | "trigram";
+}): {
+  ftsAvailable: boolean;
+  ftsError?: string;
+};
+//#endregion
+//#region packages/memory-host-sdk/src/host/sqlite-vec.d.ts
+declare function loadSqliteVecExtension(params: {
+  db: DatabaseSync;
+  extensionPath?: string;
+}): Promise<{
+  ok: boolean;
+  extensionPath?: string;
+  error?: string;
+}>;
+//#endregion
+//#region packages/memory-host-sdk/src/host/sqlite.d.ts
+declare function requireNodeSqlite(): typeof import("node:sqlite");
+declare function configureMemorySqliteWalMaintenance(db: DatabaseSync, options?: SqliteWalMaintenanceOptions): SqliteWalMaintenance;
+declare function closeMemorySqliteWalMaintenance(db: DatabaseSync): boolean;
+//#endregion
+//#region src/plugin-sdk/memory-core-host-engine-storage.d.ts
+type MemorySource = "memory" | "sessions";
+type MemorySearchResult = {
+  path: string;
+  startLine: number;
+  endLine: number;
+  score: number;
+  vectorScore?: number;
+  textScore?: number;
+  snippet: string;
+  source: MemorySource;
+  citation?: string;
+};
+type MemoryEmbeddingProbeResult = {
+  ok: boolean;
+  error?: string;
+  checked?: boolean;
+  cached?: boolean;
+  checkedAtMs?: number;
+  cacheExpiresAtMs?: number;
+};
+//#endregion
+export { configureMemorySqliteWalMaintenance as a, ensureMemoryIndexSchema as c, closeMemorySqliteWalMaintenance as i, MemorySearchResult as n, requireNodeSqlite as o, MemorySource as r, loadSqliteVecExtension as s, MemoryEmbeddingProbeResult as t };

package/dist/memory-embedding-adapter-3e_lq-rm.d.ts

@@ -0,0 +1,5 @@
+import { zi as MemoryEmbeddingProviderAdapter } from "./types-DnrQyzr_2.js";
+//#region extensions/deepinfra/memory-embedding-adapter.d.ts
+declare const deepinfraMemoryEmbeddingProviderAdapter: MemoryEmbeddingProviderAdapter;
+//#endregion
+export { deepinfraMemoryEmbeddingProviderAdapter as t };

package/dist/memory-state-CSwvwxEx.d.ts

@@ -0,0 +1,287 @@
+import { r as DaoCoreConfig } from "./types.daocore-z1fablj2.js";
+import { j as MemoryCitationsMode } from "./types.tools-nWzVz5Fw.js";
+
+//#region packages/memory-host-sdk/src/host/types.d.ts
+type MemorySource = "memory" | "sessions";
+type MemorySearchResult = {
+  path: string;
+  startLine: number;
+  endLine: number;
+  score: number;
+  vectorScore?: number;
+  textScore?: number;
+  snippet: string;
+  source: MemorySource;
+  citation?: string;
+};
+type MemoryEmbeddingProbeResult = {
+  ok: boolean;
+  error?: string;
+  checked?: boolean;
+  cached?: boolean;
+  checkedAtMs?: number;
+  cacheExpiresAtMs?: number;
+};
+type MemorySyncProgressUpdate = {
+  completed: number;
+  total: number;
+  label?: string;
+};
+type MemorySearchRuntimeDebug = {
+  backend: "builtin" | "qmd";
+  configuredMode?: string;
+  effectiveMode?: string;
+  fallback?: string;
+};
+type MemoryReadResult = {
+  text: string;
+  path: string;
+  truncated?: boolean;
+  from?: number;
+  lines?: number;
+  nextFrom?: number;
+};
+type MemoryProviderStatus = {
+  backend: "builtin" | "qmd";
+  provider: string;
+  model?: string;
+  requestedProvider?: string;
+  files?: number;
+  chunks?: number;
+  dirty?: boolean;
+  workspaceDir?: string;
+  dbPath?: string;
+  extraPaths?: string[];
+  sources?: MemorySource[];
+  sourceCounts?: Array<{
+    source: MemorySource;
+    files: number;
+    chunks: number;
+  }>;
+  cache?: {
+    enabled: boolean;
+    entries?: number;
+    maxEntries?: number;
+  };
+  fts?: {
+    enabled: boolean;
+    available: boolean;
+    error?: string;
+  };
+  fallback?: {
+    from: string;
+    reason?: string;
+  };
+  vector?: {
+    enabled: boolean;
+    storeAvailable?: boolean;
+    semanticAvailable?: boolean;
+    available?: boolean;
+    extensionPath?: string;
+    loadError?: string;
+    dims?: number;
+  };
+  batch?: {
+    enabled: boolean;
+    failures: number;
+    limit: number;
+    wait: boolean;
+    concurrency: number;
+    pollIntervalMs: number;
+    timeoutMs: number;
+    lastError?: string;
+    lastProvider?: string;
+  };
+  custom?: Record<string, unknown>;
+};
+interface MemorySearchManager {
+  search(query: string, opts?: {
+    maxResults?: number;
+    minScore?: number;
+    sessionKey?: string;
+    qmdSearchModeOverride?: "query" | "search" | "vsearch";
+    onDebug?: (debug: MemorySearchRuntimeDebug) => void;
+    sources?: MemorySource[];
+  }): Promise<MemorySearchResult[]>;
+  readFile(params: {
+    relPath: string;
+    from?: number;
+    lines?: number;
+  }): Promise<MemoryReadResult>;
+  status(): MemoryProviderStatus;
+  sync?(params?: {
+    reason?: string;
+    force?: boolean;
+    sessionFiles?: string[];
+    progress?: (update: MemorySyncProgressUpdate) => void;
+  }): Promise<void>;
+  getCachedEmbeddingAvailability?(): MemoryEmbeddingProbeResult | null;
+  probeEmbeddingAvailability(): Promise<MemoryEmbeddingProbeResult>;
+  probeVectorStoreAvailability?(): Promise<boolean>;
+  probeVectorAvailability(): Promise<boolean>;
+  close?(): Promise<void>;
+}
+//#endregion
+//#region src/plugins/memory-state.d.ts
+type MemoryPromptSectionBuilder = (params: {
+  availableTools: Set<string>;
+  citationsMode?: MemoryCitationsMode;
+}) => string[];
+type MemoryCorpusSearchResult = {
+  corpus: string;
+  path: string;
+  title?: string;
+  kind?: string;
+  score: number;
+  snippet: string;
+  id?: string;
+  startLine?: number;
+  endLine?: number;
+  citation?: string;
+  source?: string;
+  provenanceLabel?: string;
+  sourceType?: string;
+  sourcePath?: string;
+  updatedAt?: string;
+};
+type MemoryCorpusGetResult = {
+  corpus: string;
+  path: string;
+  title?: string;
+  kind?: string;
+  content: string;
+  fromLine: number;
+  lineCount: number;
+  id?: string;
+  provenanceLabel?: string;
+  sourceType?: string;
+  sourcePath?: string;
+  updatedAt?: string;
+};
+type MemoryCorpusSupplement = {
+  search(params: {
+    query: string;
+    maxResults?: number;
+    agentSessionKey?: string;
+  }): Promise<MemoryCorpusSearchResult[]>;
+  get(params: {
+    lookup: string;
+    fromLine?: number;
+    lineCount?: number;
+    agentSessionKey?: string;
+  }): Promise<MemoryCorpusGetResult | null>;
+};
+type MemoryCorpusSupplementRegistration = {
+  pluginId: string;
+  supplement: MemoryCorpusSupplement;
+};
+type MemoryPromptSupplementRegistration = {
+  pluginId: string;
+  builder: MemoryPromptSectionBuilder;
+};
+type MemoryFlushPlan = {
+  softThresholdTokens: number;
+  forceFlushTranscriptBytes: number;
+  reserveTokensFloor: number;
+  model?: string;
+  prompt: string;
+  systemPrompt: string;
+  relativePath: string;
+};
+type MemoryFlushPlanResolver = (params: {
+  cfg?: DaoCoreConfig;
+  nowMs?: number;
+}) => MemoryFlushPlan | null;
+type RegisteredMemorySearchManager = MemorySearchManager;
+type MemoryRuntimeQmdConfig = {
+  command?: string;
+};
+type MemoryRuntimeBackendConfig = {
+  backend: "builtin";
+} | {
+  backend: "qmd";
+  qmd?: MemoryRuntimeQmdConfig;
+};
+type MemoryPluginRuntime = {
+  getMemorySearchManager(params: {
+    cfg: DaoCoreConfig;
+    agentId: string;
+    purpose?: "default" | "status" | "cli";
+  }): Promise<{
+    manager: RegisteredMemorySearchManager | null;
+    error?: string;
+  }>;
+  resolveMemoryBackendConfig(params: {
+    cfg: DaoCoreConfig;
+    agentId: string;
+  }): MemoryRuntimeBackendConfig;
+  closeMemorySearchManager?(params: {
+    cfg: DaoCoreConfig;
+    agentId: string;
+  }): Promise<void>;
+  closeAllMemorySearchManagers?(): Promise<void>;
+};
+type MemoryPluginPublicArtifactContentType = "markdown" | "json" | "text";
+type MemoryPluginPublicArtifact = {
+  kind: string;
+  workspaceDir: string;
+  relativePath: string;
+  absolutePath: string;
+  agentIds: string[];
+  contentType: MemoryPluginPublicArtifactContentType;
+};
+type MemoryPluginPublicArtifactsProvider = {
+  listArtifacts(params: {
+    cfg: DaoCoreConfig;
+  }): Promise<MemoryPluginPublicArtifact[]>;
+};
+type MemoryPluginCapability = {
+  promptBuilder?: MemoryPromptSectionBuilder;
+  flushPlanResolver?: MemoryFlushPlanResolver;
+  runtime?: MemoryPluginRuntime;
+  publicArtifacts?: MemoryPluginPublicArtifactsProvider;
+};
+type MemoryPluginCapabilityRegistration = {
+  pluginId: string;
+  capability: MemoryPluginCapability;
+};
+type MemoryPluginState = {
+  capability?: MemoryPluginCapabilityRegistration;
+  corpusSupplements: MemoryCorpusSupplementRegistration[];
+  promptSupplements: MemoryPromptSupplementRegistration[];
+};
+declare function registerMemoryCorpusSupplement(pluginId: string, supplement: MemoryCorpusSupplement): void;
+declare function registerMemoryCapability(pluginId: string, capability: MemoryPluginCapability): void;
+declare function getMemoryCapabilityRegistration(): MemoryPluginCapabilityRegistration | undefined;
+declare function listMemoryCorpusSupplements(): MemoryCorpusSupplementRegistration[];
+/** @deprecated Use registerMemoryCapability(pluginId, { promptBuilder }) instead. */
+declare function registerMemoryPromptSection(builder: MemoryPromptSectionBuilder): void;
+declare function registerMemoryPromptSectionForPlugin(pluginId: string, builder: MemoryPromptSectionBuilder): void;
+declare function registerMemoryPromptSupplement(pluginId: string, builder: MemoryPromptSectionBuilder): void;
+declare function buildMemoryPromptSection(params: {
+  availableTools: Set<string>;
+  citationsMode?: MemoryCitationsMode;
+}): string[];
+declare function getMemoryPromptSectionBuilder(): MemoryPromptSectionBuilder | undefined;
+declare function listMemoryPromptSupplements(): MemoryPromptSupplementRegistration[];
+/** @deprecated Use registerMemoryCapability(pluginId, { flushPlanResolver }) instead. */
+declare function registerMemoryFlushPlanResolver(resolver: MemoryFlushPlanResolver): void;
+declare function registerMemoryFlushPlanResolverForPlugin(pluginId: string, resolver: MemoryFlushPlanResolver): void;
+declare function resolveMemoryFlushPlan(params: {
+  cfg?: DaoCoreConfig;
+  nowMs?: number;
+}): MemoryFlushPlan | null;
+declare function getMemoryFlushPlanResolver(): MemoryFlushPlanResolver | undefined;
+/** @deprecated Use registerMemoryCapability(pluginId, { runtime }) instead. */
+declare function registerMemoryRuntime(runtime: MemoryPluginRuntime): void;
+declare function registerMemoryRuntimeForPlugin(pluginId: string, runtime: MemoryPluginRuntime): void;
+declare function getMemoryRuntime(): MemoryPluginRuntime | undefined;
+declare function hasMemoryRuntime(): boolean;
+declare function listActiveMemoryPublicArtifacts(params: {
+  cfg: DaoCoreConfig;
+}): Promise<MemoryPluginPublicArtifact[]>;
+declare function restoreMemoryPluginState(state: MemoryPluginState): void;
+declare function clearMemoryPluginState(): void;
+declare const resetMemoryPluginState: typeof clearMemoryPluginState;
+//#endregion
+export { registerMemoryFlushPlanResolver as A, MemoryProviderStatus as B, getMemoryRuntime as C, listMemoryPromptSupplements as D, listMemoryCorpusSupplements as E, registerMemoryRuntime as F, MemorySyncProgressUpdate as G, MemorySearchManager as H, registerMemoryRuntimeForPlugin as I, resetMemoryPluginState as L, registerMemoryPromptSection as M, registerMemoryPromptSectionForPlugin as N, registerMemoryCapability as O, registerMemoryPromptSupplement as P, resolveMemoryFlushPlan as R, getMemoryPromptSectionBuilder as S, listActiveMemoryPublicArtifacts as T, MemorySearchResult as U, MemoryReadResult as V, MemorySearchRuntimeDebug as W, RegisteredMemorySearchManager as _, MemoryFlushPlan as a, getMemoryCapabilityRegistration as b, MemoryPluginCapabilityRegistration as c, MemoryPluginPublicArtifactsProvider as d, MemoryPluginRuntime as f, MemoryRuntimeQmdConfig as g, MemoryRuntimeBackendConfig as h, MemoryCorpusSupplementRegistration as i, registerMemoryFlushPlanResolverForPlugin as j, registerMemoryCorpusSupplement as k, MemoryPluginPublicArtifact as l, MemoryPromptSupplementRegistration as m, MemoryCorpusSearchResult as n, MemoryFlushPlanResolver as o, MemoryPromptSectionBuilder as p, MemoryCorpusSupplement as r, MemoryPluginCapability as s, MemoryCorpusGetResult as t, MemoryPluginPublicArtifactContentType as u, buildMemoryPromptSection as v, hasMemoryRuntime as w, getMemoryFlushPlanResolver as x, clearMemoryPluginState as y, restoreMemoryPluginState as z };

package/dist/mentions-d04dA_x6.d.ts

@@ -0,0 +1,16 @@
+import { r as DaoCoreConfig } from "./types.daocore-z1fablj2.js";
+import { n as ExplicitMentionSignal } from "./mentions.types-De3DGEt5.js";
+
+//#region src/auto-reply/reply/mentions.d.ts
+declare const CURRENT_MESSAGE_MARKER = "[Current message - respond to this]";
+declare function buildMentionRegexes(cfg: DaoCoreConfig | undefined, agentId?: string): RegExp[];
+declare function normalizeMentionText(text: string): string;
+declare function matchesMentionPatterns(text: string, mentionRegexes: RegExp[]): boolean;
+declare function matchesMentionWithExplicit(params: {
+  text: string;
+  mentionRegexes: RegExp[];
+  explicit?: ExplicitMentionSignal;
+  transcript?: string;
+}): boolean;
+//#endregion
+export { normalizeMentionText as a, matchesMentionWithExplicit as i, buildMentionRegexes as n, matchesMentionPatterns as r, CURRENT_MESSAGE_MARKER as t };