fengming 0.3.8 → 0.3.10

package/dist/llm-slug-generator-Bmx0I84M.js

@@ -0,0 +1,78 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DKw2K5wM.js";
+import { t as createSubsystemLogger } from "./subsystem-B7U-DPv3.js";
+import "./agent-scope-EEbMCF2I.js";
+import { a as resolveAgentDir, c as resolveDefaultAgentId, o as resolveAgentWorkspaceDir } from "./agent-scope-config-BHdZonI2.js";
+import { s as resolveDefaultModelForAgent } from "./model-selection-C4gJ7iHA.js";
+import { r as resolveAgentTimeoutMs } from "./task-completion-contract-BqW0VJsk.js";
+import { t as runEmbeddedAgent } from "./embedded-agent-DxwzoZkp.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import os from "node:os";
+//#region src/hooks/llm-slug-generator.ts
+/**
+* LLM-based slug generator for session memory filenames
+*/
+const log = createSubsystemLogger("llm-slug-generator");
+const DEFAULT_SLUG_GENERATOR_TIMEOUT_MS = 15e3;
+function resolveSlugGeneratorTimeoutMs(cfg) {
+	const configuredTimeoutSeconds = cfg.agents?.defaults?.timeoutSeconds;
+	if (typeof configuredTimeoutSeconds !== "number" || !Number.isFinite(configuredTimeoutSeconds)) return DEFAULT_SLUG_GENERATOR_TIMEOUT_MS;
+	return resolveAgentTimeoutMs({ cfg });
+}
+/**
+* Generate a short 1-2 word filename slug from session content using LLM
+*/
+async function generateSlugViaLLM(params) {
+	let tempSessionFile = null;
+	try {
+		const agentId = resolveDefaultAgentId(params.cfg);
+		const workspaceDir = resolveAgentWorkspaceDir(params.cfg, agentId);
+		const agentDir = resolveAgentDir(params.cfg, agentId);
+		const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "fengming-slug-"));
+		tempSessionFile = path.join(tempDir, "session.jsonl");
+		const prompt = `Based on this conversation, generate a short 1-2 word filename slug (lowercase, hyphen-separated, no file extension).
+
+Conversation summary:
+${params.sessionContent.slice(0, 2e3)}
+
+Reply with ONLY the slug, nothing else. Examples: "vendor-pitch", "api-design", "bug-fix"`;
+		const { provider, model } = resolveDefaultModelForAgent({
+			cfg: params.cfg,
+			agentId
+		});
+		const timeoutMs = resolveSlugGeneratorTimeoutMs(params.cfg);
+		const result = await runEmbeddedAgent({
+			sessionId: `slug-generator-${Date.now()}`,
+			sessionKey: "temp:slug-generator",
+			agentId,
+			sessionFile: tempSessionFile,
+			workspaceDir,
+			agentDir,
+			config: params.cfg,
+			prompt,
+			provider,
+			model,
+			timeoutMs,
+			runId: `slug-gen-${Date.now()}`,
+			cleanupBundleMcpOnRunEnd: true
+		});
+		if (result.payloads && result.payloads.length > 0) {
+			const text = result.payloads[0]?.text;
+			if (text) return normalizeLowercaseStringOrEmpty(text).replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 30) || null;
+		}
+		return null;
+	} catch (err) {
+		const message = err instanceof Error ? err.stack ?? err.message : String(err);
+		log.error(`Failed to generate slug: ${message}`);
+		return null;
+	} finally {
+		if (tempSessionFile) try {
+			await fs.rm(path.dirname(tempSessionFile), {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+}
+//#endregion
+export { generateSlugViaLLM as t };

package/dist/llm-slug-generator.js

@@ -1,2 +1,2 @@
-import { t as generateSlugViaLLM } from "./llm-slug-generator-DJgq9eFd.js";
+import { t as generateSlugViaLLM } from "./llm-slug-generator-Bmx0I84M.js";
 export { generateSlugViaLLM };

package/dist/loader-BVz75gSb.d.ts

@@ -0,0 +1,142 @@
+import { p as PluginInstallRecord, r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
+import { i as PluginDiscoveryResult, n as PluginManifestRegistry } from "./manifest-registry-CszwAhh-.js";
+import { Zn as CreatePluginRuntimeOptions, g as FengMingPluginDefinition, ht as PluginLogger, l as FengMingPluginApi } from "./types-BQw1qXGl.js";
+import { n as GatewayRequestHandler } from "./types-CJ0JpFcP.js";
+import { t as PluginActivationConfigSource } from "./config-state-DW4D3MbW.js";
+import { t as NormalizedPluginsConfig } from "./config-normalization-shared-5-arMumO.js";
+import { n as PluginRegistry, r as PluginRegistryParams } from "./registry-types-Ce-n1tuw.js";
+import { S as shouldPreferNativeModuleLoad, _ as resolvePluginRuntimeModulePath, a as buildPluginLoaderJitiOptions, b as resolvePluginSdkAliasFile, c as listPluginSdkAliasCandidates, d as resolveExtensionApiAlias, i as buildPluginLoaderAliasMap, l as listPluginSdkExportedSubpaths, r as PluginSdkResolutionPreference, x as resolvePluginSdkScopedAliasMap, y as resolvePluginSdkAliasCandidateOrder } from "./sdk-alias-BR2RnJgE.js";
+
+//#region src/shared/import-specifier.d.ts
+/**
+ * On Windows, Node's ESM loader requires absolute paths to be expressed as
+ * file:// URLs. Raw drive-letter paths like C:\... are parsed as URL schemes.
+ */
+declare function toSafeImportPath(specifier: string): string;
+//#endregion
+//#region src/plugins/loader-channel-setup.d.ts
+declare function shouldLoadChannelPluginInSetupRuntime(params: {
+  manifestChannels: string[];
+  setupSource?: string;
+  startupDeferConfiguredChannelFullLoadUntilAfterListen?: boolean;
+  cfg: FengMingConfig;
+  env: NodeJS.ProcessEnv;
+  preferSetupRuntimeForChannelPlugins?: boolean;
+}): boolean;
+//#endregion
+//#region src/plugins/plugin-sdk-dist-alias.d.ts
+declare function ensureFengMingPluginSdkAlias(distRoot: string): void;
+//#endregion
+//#region src/plugins/loader-cache-state.d.ts
+declare class PluginLoadReentryError extends Error {
+  readonly cacheKey: string;
+  constructor(cacheKey: string);
+}
+//#endregion
+//#region src/plugins/loader.d.ts
+type PluginLoadResult = PluginRegistry;
+type PluginLoadOptions = {
+  config?: FengMingConfig;
+  activationSourceConfig?: FengMingConfig;
+  autoEnabledReasons?: Readonly<Record<string, string[]>>;
+  workspaceDir?: string;
+  installRecords?: Record<string, PluginInstallRecord>;
+  env?: NodeJS.ProcessEnv;
+  resolveRawConfigEnvVars?: boolean;
+  logger?: PluginLogger;
+  coreGatewayHandlers?: Record<string, GatewayRequestHandler>;
+  coreGatewayMethodNames?: readonly string[];
+  hostServices?: PluginRegistryParams["hostServices"];
+  runtimeOptions?: CreatePluginRuntimeOptions;
+  startupTrace?: {
+    detail: (name: string, metrics: ReadonlyArray<readonly [string, number | string]>) => void;
+  };
+  pluginSdkResolution?: PluginSdkResolutionPreference;
+  cache?: boolean;
+  mode?: "full" | "validate";
+  onlyPluginIds?: string[];
+  includeSetupOnlyChannelPlugins?: boolean;
+  forceSetupOnlyChannelPlugins?: boolean;
+  requireSetupEntryForSetupOnlyChannelPlugins?: boolean;
+  /**
+   * Prefer `setupEntry` for configured channel plugins that explicitly opt in
+   * via package metadata because their setup entry covers the pre-listen startup surface.
+   */
+  preferSetupRuntimeForChannelPlugins?: boolean;
+  /**
+   * For hot startup paths, prefer bundled plugin JS artifacts over source TS
+   * entrypoints when both are present in a source checkout.
+   */
+  preferBuiltPluginArtifacts?: boolean;
+  toolDiscovery?: boolean;
+  activate?: boolean;
+  loadModules?: boolean;
+  throwOnLoadError?: boolean;
+  manifestRegistry?: PluginManifestRegistry;
+  discovery?: PluginDiscoveryResult;
+};
+declare class PluginLoadFailureError extends Error {
+  readonly pluginIds: string[];
+  readonly registry: PluginRegistry;
+  constructor(registry: PluginRegistry);
+}
+declare function clearPluginLoaderCache(): void;
+declare function clearActivatedPluginRuntimeState(): void;
+declare function clearPluginRegistryLoadCache(): void;
+declare function createGuardedPluginRegistrationApi(api: FengMingPluginApi): {
+  api: FengMingPluginApi;
+  close: () => void;
+};
+declare function runPluginRegisterSync(register: NonNullable<FengMingPluginDefinition["register"]>, api: Parameters<NonNullable<FengMingPluginDefinition["register"]>>[0]): void;
+declare const testing: {
+  buildPluginLoaderJitiOptions: typeof buildPluginLoaderJitiOptions;
+  buildPluginLoaderAliasMap: typeof buildPluginLoaderAliasMap;
+  listPluginSdkAliasCandidates: typeof listPluginSdkAliasCandidates;
+  listPluginSdkExportedSubpaths: typeof listPluginSdkExportedSubpaths;
+  resolveExtensionApiAlias: typeof resolveExtensionApiAlias;
+  resolvePluginSdkScopedAliasMap: typeof resolvePluginSdkScopedAliasMap;
+  resolvePluginSdkAliasCandidateOrder: typeof resolvePluginSdkAliasCandidateOrder;
+  resolvePluginSdkAliasFile: typeof resolvePluginSdkAliasFile;
+  resolvePluginRuntimeModulePath: typeof resolvePluginRuntimeModulePath;
+  ensureFengMingPluginSdkAlias: typeof ensureFengMingPluginSdkAlias;
+  shouldLoadChannelPluginInSetupRuntime: typeof shouldLoadChannelPluginInSetupRuntime;
+  shouldPreferNativeModuleLoad: typeof shouldPreferNativeModuleLoad;
+  toSafeImportPath: typeof toSafeImportPath;
+  createGuardedPluginRegistrationApi: typeof createGuardedPluginRegistrationApi;
+  runPluginRegisterSync: typeof runPluginRegisterSync;
+  getCompatibleActivePluginRegistry: typeof getCompatibleActivePluginRegistry;
+  resolvePluginLoadCacheContext: typeof resolvePluginLoadCacheContext;
+  readonly maxPluginRegistryCacheEntries: number;
+  setMaxPluginRegistryCacheEntriesForTest(value?: number): void;
+};
+declare function resolvePluginLoadCacheContext(options?: PluginLoadOptions): {
+  env: NodeJS.ProcessEnv;
+  cfg: FengMingConfig;
+  normalized: NormalizedPluginsConfig;
+  activationSourceConfig: FengMingConfig;
+  activationSource: PluginActivationConfigSource;
+  autoEnabledReasons: Readonly<Record<string, string[]>>;
+  onlyPluginIds: string[] | undefined;
+  includeSetupOnlyChannelPlugins: boolean;
+  forceSetupOnlyChannelPlugins: boolean;
+  requireSetupEntryForSetupOnlyChannelPlugins: boolean;
+  preferSetupRuntimeForChannelPlugins: boolean;
+  preferBuiltPluginArtifacts: boolean;
+  shouldActivate: boolean;
+  shouldLoadModules: boolean;
+  runtimeSubagentMode: "default" | "explicit" | "gateway-bindable";
+  installRecords: {
+    [x: string]: PluginInstallRecord;
+  };
+  cacheKey: string;
+};
+declare function getCompatibleActivePluginRegistry(options?: PluginLoadOptions): PluginRegistry | undefined;
+declare function resolveRuntimePluginRegistry(options?: PluginLoadOptions): PluginRegistry | undefined;
+declare function getRuntimePluginRegistryForLoadOptions(options?: PluginLoadOptions): PluginRegistry | undefined;
+declare function resolvePluginRegistryLoadCacheKey(options?: PluginLoadOptions): string;
+declare function isPluginRegistryLoadInFlight(options?: PluginLoadOptions): boolean;
+declare function resolveCompatibleRuntimePluginRegistry(options?: PluginLoadOptions): PluginRegistry | undefined;
+declare function loadFengMingPlugins(options?: PluginLoadOptions): PluginRegistry;
+declare function loadFengMingPluginCliRegistry(options?: PluginLoadOptions): Promise<PluginRegistry>;
+//#endregion
+export { clearPluginLoaderCache as a, isPluginRegistryLoadInFlight as c, resolveCompatibleRuntimePluginRegistry as d, resolvePluginRegistryLoadCacheKey as f, PluginLoadReentryError as h, clearActivatedPluginRuntimeState as i, loadFengMingPluginCliRegistry as l, testing as m, PluginLoadOptions as n, clearPluginRegistryLoadCache as o, resolveRuntimePluginRegistry as p, PluginLoadResult as r, getRuntimePluginRegistryForLoadOptions as s, PluginLoadFailureError as t, loadFengMingPlugins as u };

package/dist/local-dispatch.runtime-CX3IOY1E.js

@@ -0,0 +1,10 @@
+import { t as createBrowserRouteDispatcher } from "./dispatcher-DslvaRcj.js";
+import { n as createBrowserControlContext } from "./plugin-enabled-fvhTpvYS.js";
+import { t as startBrowserControlServiceFromConfig } from "./control-service-BBsamNjq.js";
+//#region extensions/browser/src/browser/local-dispatch.runtime.ts
+async function dispatchBrowserControlRequest(req) {
+	if (!await startBrowserControlServiceFromConfig()) throw new Error("浏览器控制已禁用");
+	return await createBrowserRouteDispatcher(createBrowserControlContext()).dispatch(req);
+}
+//#endregion
+export { dispatchBrowserControlRequest };

package/dist/local-dispatch.runtime.js

@@ -1 +1 @@
-export * from "./local-dispatch.runtime-D3F4v51B.js";
+export * from "./local-dispatch.runtime-CX3IOY1E.js";

package/dist/manager-BXGg8bfG.d.ts

@@ -0,0 +1,409 @@
+import { r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
+import { aa as MemoryEmbeddingProvider, ca as MemoryEmbeddingProviderCreateOptions, ua as MemoryEmbeddingProviderRuntime } from "./types-BQw1qXGl.js";
+import { B as MemoryProviderStatus, G as MemorySyncProgressUpdate, H as MemorySearchManager, W as MemorySearchRuntimeDebug } from "./memory-state-DbN0xoij.js";
+import { m as EmbeddingInput } from "./internal-B1IX4tl2.js";
+import { u as ResolvedMemorySearchConfig } from "./fengming-runtime-CtRd5677.js";
+import { n as MemorySearchResult, r as MemorySource, t as MemoryEmbeddingProbeResult } from "./memory-core-host-engine-storage-WQfkQMer.js";
+import { FSWatcher } from "chokidar";
+import { DatabaseSync } from "node:sqlite";
+
+//#region extensions/memory-core/src/memory/embeddings.d.ts
+type EmbeddingProvider = MemoryEmbeddingProvider;
+type EmbeddingProviderId = string;
+type EmbeddingProviderRequest = string;
+type EmbeddingProviderFallback = string;
+type EmbeddingProviderRuntime = MemoryEmbeddingProviderRuntime;
+type EmbeddingProviderResult = {
+  provider: EmbeddingProvider | null;
+  requestedProvider: EmbeddingProviderRequest;
+  fallbackFrom?: string;
+  fallbackReason?: string;
+  providerUnavailableReason?: string;
+  runtime?: EmbeddingProviderRuntime;
+};
+type CreateEmbeddingProviderOptions = MemoryEmbeddingProviderCreateOptions & {
+  provider: EmbeddingProviderRequest;
+  fallback: EmbeddingProviderFallback;
+};
+declare function createEmbeddingProvider(options: CreateEmbeddingProviderOptions): Promise<EmbeddingProviderResult>;
+//#endregion
+//#region extensions/memory-core/src/memory/manager-provider-state.d.ts
+type MemoryProviderLifecycleState = {
+  mode: "pending";
+  requestedProvider: string;
+} | {
+  mode: "active";
+  providerId: string;
+} | {
+  mode: "degraded";
+  providerId: string;
+  reason: string;
+  code?: string;
+} | {
+  mode: "fallback-active";
+  providerId: string;
+  fallbackFrom: string;
+  reason: string;
+} | {
+  mode: "fts-only";
+  reason: string;
+  attemptedProviderId?: string;
+};
+//#endregion
+//#region extensions/memory-core/src/memory/manager-reindex-state.d.ts
+type MemoryIndexMeta = {
+  model: string;
+  provider: string;
+  providerKey?: string;
+  sources?: MemorySource[];
+  scopeHash?: string;
+  chunkTokens: number;
+  chunkOverlap: number;
+  vectorDims?: number;
+  ftsTokenizer?: string;
+};
+//#endregion
+//#region extensions/memory-core/src/memory/watch-settle.d.ts
+type MemoryWatchEventStats = {
+  isDirectory?: () => boolean;
+  size?: number;
+  mtimeMs?: number;
+};
+type WatchPathSnapshot = {
+  size: number;
+  mtimeMs: number;
+};
+type MemoryWatchSettleQueue = Map<string, WatchPathSnapshot | null>;
+//#endregion
+//#region extensions/memory-core/src/memory/manager-sync-ops.d.ts
+type MemorySyncProgressState = {
+  completed: number;
+  total: number;
+  label?: string;
+  report: (update: MemorySyncProgressUpdate) => void;
+};
+type MemoryIndexEntry$1 = {
+  path: string;
+  absPath: string;
+  mtimeMs: number;
+  size: number;
+  hash: string;
+  content?: string;
+};
+declare abstract class MemoryManagerSyncOps {
+  protected abstract readonly cfg: FengMingConfig;
+  protected abstract readonly agentId: string;
+  protected abstract readonly workspaceDir: string;
+  protected abstract readonly settings: ResolvedMemorySearchConfig;
+  protected provider: EmbeddingProvider | null;
+  protected fallbackFrom?: EmbeddingProviderId;
+  protected abstract providerUnavailableReason?: string;
+  protected abstract providerLifecycle: MemoryProviderLifecycleState;
+  protected providerRuntime?: EmbeddingProviderRuntime;
+  protected abstract batch: {
+    enabled: boolean;
+    wait: boolean;
+    concurrency: number;
+    pollIntervalMs: number;
+    timeoutMs: number;
+  };
+  protected readonly sources: Set<MemorySource>;
+  protected providerKey: string | null;
+  protected abstract readonly vector: {
+    enabled: boolean;
+    available: boolean | null;
+    semanticAvailable?: boolean;
+    extensionPath?: string;
+    loadError?: string;
+    dims?: number;
+  };
+  protected readonly fts: {
+    enabled: boolean;
+    available: boolean;
+    loadError?: string;
+  };
+  protected vectorReady: Promise<boolean> | null;
+  protected watcher: FSWatcher | null;
+  private nativeMemoryWatchPairs;
+  protected watchTimer: NodeJS.Timeout | null;
+  protected sessionWatchTimer: NodeJS.Timeout | null;
+  protected sessionUnsubscribe: (() => void) | null;
+  protected fallbackReason?: string;
+  protected intervalTimer: NodeJS.Timeout | null;
+  protected closed: boolean;
+  protected dirty: boolean;
+  protected pendingWatchPaths: MemoryWatchSettleQueue;
+  protected sessionsDirty: boolean;
+  protected sessionsDirtyFiles: Set<string>;
+  protected sessionPendingFiles: Set<string>;
+  protected sessionDeltas: Map<string, {
+    lastSize: number;
+    pendingBytes: number;
+    pendingMessages: number;
+  }>;
+  protected vectorDegradedWriteWarningShown: boolean;
+  private lastMetaSerialized;
+  protected abstract readonly cache: {
+    enabled: boolean;
+    maxEntries?: number;
+  };
+  protected abstract db: DatabaseSync;
+  protected abstract computeProviderKey(): string;
+  protected abstract sync(params?: {
+    reason?: string;
+    force?: boolean;
+    forceSessions?: boolean;
+    sessionFile?: string;
+    progress?: (update: MemorySyncProgressUpdate) => void;
+  }): Promise<void>;
+  protected abstract withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T>;
+  protected abstract getIndexConcurrency(): number;
+  protected abstract pruneEmbeddingCacheIfNeeded(): void;
+  protected abstract resetProviderInitializationForRetry(): void;
+  protected abstract indexFile(entry: MemoryIndexEntry$1, options: {
+    source: MemorySource;
+    content?: string;
+  }): Promise<void>;
+  protected resetVectorState(): void;
+  protected ensureVectorReady(dimensions?: number): Promise<boolean>;
+  private loadVectorExtension;
+  private ensureVectorTable;
+  private dropVectorTable;
+  protected buildSourceFilter(alias?: string, sourcesOverride?: MemorySource[]): {
+    sql: string;
+    params: MemorySource[];
+  };
+  protected openDatabase(): DatabaseSync;
+  private seedEmbeddingCache;
+  protected ensureSchema(): void;
+  protected ensureWatcher(): void;
+  protected attachNativeMemoryWatchForDir(dir: string, markDirty: (watchPath?: string, stats?: MemoryWatchEventStats) => void): boolean;
+  private closeNativeMemoryWatchPair;
+  protected closeNativeMemoryWatchPairs(): void;
+  private removeNativeMemoryParentWatch;
+  private removeNativeMemoryWatchPair;
+  protected attachMemoryChokidarFallback(dir: string, markDirty: (watchPath?: string, stats?: MemoryWatchEventStats) => void): void;
+  protected ensureSessionListener(): void;
+  protected ensureSessionStartupCatchup(): void;
+  protected markSessionStartupCatchupDirtyFiles(): Promise<string[]>;
+  protected runSessionStartupCatchup(): Promise<string[]>;
+  private scheduleSessionDirty;
+  private processSessionDeltaBatch;
+  private updateSessionDelta;
+  private countNewlines;
+  private resetSessionDelta;
+  private isSessionFileForAgent;
+  private normalizeTargetSessionFiles;
+  protected ensureIntervalSync(): void;
+  private scheduleWatchSync;
+  private shouldSyncSessions;
+  private syncMemoryFiles;
+  private syncSessionFiles;
+  private createSyncProgress;
+  private assertFtsOnlySyncAllowed;
+  protected runSync(params?: {
+    reason?: string;
+    force?: boolean;
+    sessionFiles?: string[];
+    progress?: (update: MemorySyncProgressUpdate) => void;
+  }): Promise<void>;
+  protected shouldFallbackOnError(err: unknown): boolean;
+  protected resolveBatchConfig(): {
+    enabled: boolean;
+    wait: boolean;
+    concurrency: number;
+    pollIntervalMs: number;
+    timeoutMs: number;
+  };
+  protected activateFallbackProvider(reason: string): Promise<boolean>;
+  protected runSafeReindex(params: {
+    reason?: string;
+    force?: boolean;
+    progress?: MemorySyncProgressState;
+  }): Promise<void>;
+  private runUnsafeReindex;
+  private resetIndex;
+  protected readMeta(): MemoryIndexMeta | null;
+  protected writeMeta(meta: MemoryIndexMeta): void;
+}
+//#endregion
+//#region extensions/memory-core/src/memory/manager-embedding-ops.d.ts
+type MemoryIndexEntry = {
+  path: string;
+  absPath: string;
+  mtimeMs: number;
+  size: number;
+  hash: string;
+  kind?: "markdown" | "multimodal";
+  contentText?: string;
+  lineMap?: number[];
+};
+declare abstract class MemoryManagerEmbeddingOps extends MemoryManagerSyncOps {
+  protected abstract batchFailureCount: number;
+  protected abstract batchFailureLastError?: string;
+  protected abstract batchFailureLastProvider?: string;
+  protected abstract batchFailureLock: Promise<void>;
+  protected abstract markLocalEmbeddingProviderDegraded(err: unknown): void;
+  protected pruneEmbeddingCacheIfNeeded(): void;
+  private embedChunksInBatches;
+  protected computeProviderKey(): string;
+  private buildBatchDebug;
+  private embedChunksWithBatch;
+  private collectCachedEmbeddings;
+  protected embedBatchWithRetry(texts: string[]): Promise<number[][]>;
+  protected embedBatchInputsWithRetry(inputs: EmbeddingInput[]): Promise<number[][]>;
+  private waitForEmbeddingRetry;
+  private resolveEmbeddingTimeout;
+  protected embedQueryWithTimeout(text: string): Promise<number[]>;
+  protected withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T>;
+  private withBatchFailureLock;
+  private resetBatchFailureCount;
+  private recordBatchFailure;
+  private isBatchTimeoutError;
+  private runBatchWithTimeoutRetry;
+  private runBatchWithFallback;
+  protected getIndexConcurrency(): number;
+  private clearIndexedFileData;
+  private upsertFileRecord;
+  private deleteFileRecord;
+  /**
+   * Write chunks (and optional embeddings) for a file into the index.
+   * Handles both the chunks table, the vector table, and the FTS table.
+   * Pass an empty embeddings array to skip vector writes (FTS-only mode).
+   */
+  private writeChunks;
+  protected indexFile(entry: MemoryIndexEntry, options: {
+    source: MemorySource;
+    content?: string;
+  }): Promise<void>;
+}
+//#endregion
+//#region extensions/memory-core/src/memory/manager.d.ts
+type MemoryIndexManagerPurpose = "default" | "status" | "cli";
+declare function closeAllMemoryIndexManagers(): Promise<void>;
+declare function closeMemoryIndexManagersForAgent(params: {
+  cfg: FengMingConfig;
+  agentId: string;
+}): Promise<void>;
+declare class MemoryIndexManager extends MemoryManagerEmbeddingOps implements MemorySearchManager {
+  private readonly cacheKey;
+  protected readonly cfg: FengMingConfig;
+  protected readonly agentId: string;
+  protected readonly workspaceDir: string;
+  protected readonly settings: ResolvedMemorySearchConfig;
+  protected provider: EmbeddingProvider | null;
+  private readonly requestedProvider;
+  private providerInitPromise;
+  private providerInitialized;
+  protected fallbackFrom?: EmbeddingProviderId;
+  protected fallbackReason?: string;
+  protected providerUnavailableReason?: string;
+  protected providerLifecycle: MemoryProviderLifecycleState;
+  protected providerRuntime?: EmbeddingProviderRuntime;
+  protected batch: {
+    enabled: boolean;
+    wait: boolean;
+    concurrency: number;
+    pollIntervalMs: number;
+    timeoutMs: number;
+  };
+  protected batchFailureCount: number;
+  protected batchFailureLastError?: string;
+  protected batchFailureLastProvider?: string;
+  protected batchFailureLock: Promise<void>;
+  protected db: DatabaseSync;
+  protected readonly sources: Set<MemorySource>;
+  protected providerKey: string;
+  protected readonly cache: {
+    enabled: boolean;
+    maxEntries?: number;
+  };
+  protected readonly vector: {
+    enabled: boolean;
+    available: boolean | null;
+    semanticAvailable?: boolean;
+    extensionPath?: string;
+    loadError?: string;
+    dims?: number;
+  };
+  protected readonly fts: {
+    enabled: boolean;
+    available: boolean;
+    loadError?: string;
+  };
+  protected vectorReady: Promise<boolean> | null;
+  protected watcher: FSWatcher | null;
+  protected watchTimer: NodeJS.Timeout | null;
+  protected sessionWatchTimer: NodeJS.Timeout | null;
+  protected sessionUnsubscribe: (() => void) | null;
+  protected intervalTimer: NodeJS.Timeout | null;
+  protected closed: boolean;
+  protected dirty: boolean;
+  protected sessionsDirty: boolean;
+  protected sessionsDirtyFiles: Set<string>;
+  protected sessionPendingFiles: Set<string>;
+  protected sessionDeltas: Map<string, {
+    lastSize: number;
+    pendingBytes: number;
+    pendingMessages: number;
+  }>;
+  private sessionWarm;
+  private syncing;
+  private queuedSessionFiles;
+  private queuedSessionSync;
+  private readonlyRecoveryAttempts;
+  private readonlyRecoverySuccesses;
+  private readonlyRecoveryFailures;
+  private readonlyRecoveryLastError?;
+  private static loadProviderResult;
+  static get(params: {
+    cfg: FengMingConfig;
+    agentId: string;
+    purpose?: MemoryIndexManagerPurpose;
+  }): Promise<MemoryIndexManager | null>;
+  private constructor();
+  private applyProviderResult;
+  private ensureProviderInitialized;
+  protected resetProviderInitializationForRetry(): void;
+  protected markLocalEmbeddingProviderDegraded(err: unknown): void;
+  warmSession(sessionKey?: string): Promise<void>;
+  search(query: string, opts?: {
+    maxResults?: number;
+    minScore?: number;
+    sessionKey?: string;
+    qmdSearchModeOverride?: "query" | "search" | "vsearch";
+    onDebug?: (debug: MemorySearchRuntimeDebug) => void; /** When set, only these chunk sources are considered (must be enabled for this manager). */
+    sources?: MemorySource[];
+  }): Promise<MemorySearchResult[]>;
+  private selectScoredResults;
+  private hasIndexedContent;
+  private searchVector;
+  private buildFtsQuery;
+  private searchKeyword;
+  private mergeHybridResults;
+  sync(params?: {
+    reason?: string;
+    force?: boolean;
+    sessionFiles?: string[];
+    progress?: (update: MemorySyncProgressUpdate) => void;
+  }): Promise<void>;
+  private enqueueTargetedSessionSync;
+  private runSyncWithReadonlyRecovery;
+  readFile(params: {
+    relPath: string;
+    from?: number;
+    lines?: number;
+  }): Promise<{
+    text: string;
+    path: string;
+  }>;
+  status(): MemoryProviderStatus;
+  probeVectorAvailability(): Promise<boolean>;
+  probeVectorStoreAvailability(): Promise<boolean>;
+  private cacheProbeResult;
+  getCachedEmbeddingAvailability(): MemoryEmbeddingProbeResult | null;
+  probeEmbeddingAvailability(): Promise<MemoryEmbeddingProbeResult>;
+  close(): Promise<void>;
+}
+//#endregion
+export { createEmbeddingProvider as i, closeAllMemoryIndexManagers as n, closeMemoryIndexManagersForAgent as r, MemoryIndexManager as t };

package/dist/mcp-http-B1lnh67s.js

@@ -0,0 +1,2 @@
+import { t as closeMcpLoopbackServer } from "./mcp-http-CamghE-W.js";
+export { closeMcpLoopbackServer };