fengming 0.3.7 → 0.3.9

package/dist/media-runtime-DpykroJR.d.ts

@@ -0,0 +1,261 @@
+import { r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
+import { f as MediaUnderstandingConfig } from "./types.tools-CNVUa3Mn.js";
+import { o as SsrFPolicy } from "./ssrf-skjEI_i5.js";
+import { n as MsgContext } from "./templating-suu09Bb-.js";
+import { c as MediaAttachment, d as MediaUnderstandingOutput, f as MediaUnderstandingProvider, l as MediaUnderstandingCapability, u as MediaUnderstandingDecision } from "./types-CIzdKL5V.js";
+import { t as ActiveMediaModel } from "./active-model.types-DCiq_ik4.js";
+import { t as OutboundSendDeps } from "./send-deps-BaEC80iY.js";
+import { t as OutboundMediaAccess } from "./load-options-CTuppEe4.js";
+import { n as ChannelOutboundAdapter } from "./outbound.types-DVkbsxo8.js";
+//#region src/media/base64.d.ts
+declare function estimateBase64DecodedBytes(base64: string): number;
+/**
+ * Normalize and validate a base64 string.
+ * Returns canonical base64 (no whitespace) or undefined when invalid.
+ */
+declare function canonicalizeBase64(base64: string): string | undefined;
+//#endregion
+//#region src/media/content-length.d.ts
+declare function parseMediaContentLength(raw: string | null): number | null;
+//#endregion
+//#region src/media/ffmpeg-limits.d.ts
+declare const MEDIA_FFMPEG_MAX_BUFFER_BYTES: number;
+declare const MEDIA_FFPROBE_TIMEOUT_MS = 10000;
+declare const MEDIA_FFMPEG_TIMEOUT_MS = 45000;
+declare const MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS: number;
+//#endregion
+//#region src/media/outbound-attachment.d.ts
+declare function resolveOutboundAttachmentFromUrl(mediaUrl: string, maxBytes: number, options?: {
+  mediaAccess?: OutboundMediaAccess;
+  localRoots?: readonly string[];
+  readFile?: (filePath: string) => Promise<Buffer>;
+}): Promise<{
+  path: string;
+  contentType?: string;
+}>;
+//#endregion
+//#region src/media/png-encode.d.ts
+/** Write a pixel to an RGBA buffer. Ignores out-of-bounds writes. */
+declare function fillPixel(buf: Buffer, x: number, y: number, width: number, r: number, g: number, b: number, a?: number): void;
+/** Encode an RGB buffer as a PNG image. */
+declare function encodePngRgb(buffer: Buffer, width: number, height: number): Buffer;
+/** Encode an RGBA buffer as a PNG image. */
+declare function encodePngRgba(buffer: Buffer, width: number, height: number): Buffer;
+//#endregion
+//#region src/media/qr-image.d.ts
+type QrPngRenderOptions = {
+  scale?: number;
+  marginModules?: number;
+};
+type QrPngTempFileOptions = QrPngRenderOptions & {
+  tmpRoot: string;
+  dirPrefix: string;
+  fileName?: string;
+};
+type QrPngTempFile = {
+  filePath: string;
+  dirPath: string;
+  mediaLocalRoots: string[];
+};
+declare function renderQrPngBase64(input: string, opts?: QrPngRenderOptions): Promise<string>;
+declare function formatQrPngDataUrl(base64: string): string;
+declare function renderQrPngDataUrl(input: string, opts?: QrPngRenderOptions): Promise<string>;
+declare function writeQrPngTempFile(input: string, opts: QrPngTempFileOptions): Promise<QrPngTempFile>;
+//#endregion
+//#region src/media/qr-terminal.d.ts
+declare function renderQrTerminal(input: string, opts?: {
+  small?: boolean;
+}): Promise<string>;
+//#endregion
+//#region src/media/temp-files.d.ts
+declare function unlinkIfExists(filePath: string | null | undefined): Promise<void>;
+//#endregion
+//#region src/channels/plugins/media-limits.d.ts
+declare function resolveChannelMediaMaxBytes(params: {
+  cfg: FengMingConfig;
+  resolveChannelLimitMb: (params: {
+    cfg: FengMingConfig;
+    accountId: string;
+  }) => number | undefined;
+  accountId?: string | null;
+}): number | undefined;
+//#endregion
+//#region src/media-understanding/audio-preflight.d.ts
+/**
+ * Transcribes the first audio attachment BEFORE mention checking.
+ * This allows voice notes to be processed in group chats with requireMention: true.
+ * Returns the transcript or undefined if transcription fails or no audio is found.
+ */
+declare function transcribeFirstAudio(params: {
+  ctx: MsgContext;
+  cfg: FengMingConfig;
+  agentDir?: string;
+  providers?: Record<string, MediaUnderstandingProvider>;
+  activeModel?: ActiveMediaModel;
+}): Promise<string | undefined>;
+//#endregion
+//#region src/media-understanding/defaults.constants.d.ts
+declare const DEFAULT_MAX_CHARS = 500;
+declare const DEFAULT_MAX_CHARS_BY_CAPABILITY: Record<MediaUnderstandingCapability, number | undefined>;
+declare const DEFAULT_MAX_BYTES: Record<MediaUnderstandingCapability, number>;
+declare const DEFAULT_TIMEOUT_SECONDS: Record<MediaUnderstandingCapability, number>;
+declare const DEFAULT_PROMPT: Record<MediaUnderstandingCapability, string>;
+declare const DEFAULT_VIDEO_MAX_BASE64_BYTES: number;
+declare const CLI_OUTPUT_MAX_BUFFER: number;
+declare const DEFAULT_MEDIA_CONCURRENCY = 2;
+declare const MIN_AUDIO_FILE_BYTES = 1024;
+//#endregion
+//#region src/media-understanding/defaults.d.ts
+declare function resolveDefaultMediaModel(params: {
+  providerId: string;
+  capability: MediaUnderstandingCapability;
+  cfg?: FengMingConfig;
+  workspaceDir?: string;
+  providerRegistry?: Map<string, MediaUnderstandingProvider>;
+  includeConfiguredImageModels?: boolean;
+}): string | undefined;
+declare function resolveAutoMediaKeyProviders(params: {
+  capability: MediaUnderstandingCapability;
+  cfg?: FengMingConfig;
+  workspaceDir?: string;
+  providerRegistry?: Map<string, MediaUnderstandingProvider>;
+}): string[];
+declare function providerSupportsNativePdfDocument(params: {
+  providerId: string;
+  cfg?: FengMingConfig;
+  workspaceDir?: string;
+  providerRegistry?: Map<string, MediaUnderstandingProvider>;
+}): boolean;
+declare function resolveDocumentMediaModel(params: {
+  providerId: string;
+  document: "pdf";
+  mode: "textExtraction" | "image";
+  cfg?: FengMingConfig;
+  workspaceDir?: string;
+  providerRegistry?: Map<string, MediaUnderstandingProvider>;
+}): string | false | undefined;
+//#endregion
+//#region src/media-understanding/attachments.cache.d.ts
+type MediaBufferResult = {
+  buffer: Buffer;
+  mime?: string;
+  fileName: string;
+  size: number;
+};
+type MediaPathResult = {
+  path: string;
+  cleanup?: () => Promise<void> | void;
+};
+type MediaAttachmentCacheOptions = {
+  localPathRoots?: readonly string[];
+  includeDefaultLocalPathRoots?: boolean;
+  ssrfPolicy?: SsrFPolicy;
+  workspaceDir?: string;
+};
+declare class MediaAttachmentCache {
+  private readonly entries;
+  private readonly attachments;
+  private readonly localPathRoots;
+  private readonly ssrfPolicy;
+  private readonly workspaceDir?;
+  private canonicalLocalPathRoots?;
+  constructor(attachments: MediaAttachment[], options?: MediaAttachmentCacheOptions);
+  getBuffer(params: {
+    attachmentIndex: number;
+    maxBytes: number;
+    timeoutMs: number;
+  }): Promise<MediaBufferResult>;
+  getPath(params: {
+    attachmentIndex: number;
+    maxBytes?: number;
+    timeoutMs: number;
+  }): Promise<MediaPathResult>;
+  cleanup(): Promise<void>;
+  private ensureEntry;
+  private resolveLocalPath;
+  private ensureLocalStat;
+  private getCanonicalLocalPathRoots;
+  private readLocalBuffer;
+}
+//#endregion
+//#region src/media-understanding/runner.attachments.d.ts
+declare function normalizeMediaAttachments(ctx: MsgContext): MediaAttachment[];
+declare function createMediaAttachmentCache(attachments: MediaAttachment[], options?: MediaAttachmentCacheOptions): MediaAttachmentCache;
+//#endregion
+//#region src/media-understanding/runner.d.ts
+type ProviderRegistry = Map<string, MediaUnderstandingProvider>;
+type RunCapabilityResult = {
+  outputs: MediaUnderstandingOutput[];
+  decision: MediaUnderstandingDecision;
+};
+declare function buildProviderRegistry(overrides?: Record<string, MediaUnderstandingProvider>, cfg?: FengMingConfig): ProviderRegistry;
+declare function resolveMediaAttachmentLocalRoots(params: {
+  cfg: FengMingConfig;
+  ctx: MsgContext;
+  workspaceDir?: string;
+}): readonly string[];
+declare function clearMediaUnderstandingBinaryCacheForTests(): void;
+declare function resolveAutoImageModel(params: {
+  cfg: FengMingConfig;
+  agentId?: string;
+  agentDir?: string;
+  workspaceDir?: string;
+  activeModel?: ActiveMediaModel;
+}): Promise<ActiveMediaModel | null>;
+declare function runCapability(params: {
+  capability: MediaUnderstandingCapability;
+  cfg: FengMingConfig;
+  ctx: MsgContext;
+  attachments: MediaAttachmentCache;
+  media: MediaAttachment[];
+  agentId?: string;
+  agentDir?: string;
+  workspaceDir?: string;
+  providerRegistry: ProviderRegistry;
+  config?: MediaUnderstandingConfig;
+  activeModel?: ActiveMediaModel;
+}): Promise<RunCapabilityResult>;
+//#endregion
+//#region src/media-understanding/provider-id.d.ts
+declare function normalizeMediaProviderId(id: string): string;
+//#endregion
+//#region src/channels/plugins/outbound/direct-text-media.d.ts
+type DirectSendOptions = {
+  cfg: FengMingConfig;
+  accountId?: string | null;
+  replyToId?: string | null;
+  mediaUrl?: string;
+  mediaAccess?: OutboundMediaAccess;
+  mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
+  maxBytes?: number;
+};
+type DirectSendResult = {
+  messageId: string;
+  [key: string]: unknown;
+};
+type DirectSendFn<TOpts extends Record<string, unknown>, TResult extends DirectSendResult> = (to: string, text: string, opts: TOpts) => Promise<TResult>;
+declare function resolveScopedChannelMediaMaxBytes(params: {
+  cfg: FengMingConfig;
+  accountId?: string | null;
+  resolveChannelLimitMb: (params: {
+    cfg: FengMingConfig;
+    accountId: string;
+  }) => number | undefined;
+}): number | undefined;
+declare function createScopedChannelMediaMaxBytesResolver(channel: string): (params: {
+  cfg: FengMingConfig;
+  accountId?: string | null;
+}) => number | undefined;
+declare function createDirectTextMediaOutbound<TOpts extends Record<string, unknown>, TResult extends DirectSendResult>(params: {
+  channel: string;
+  resolveSender: (deps: OutboundSendDeps | undefined) => DirectSendFn<TOpts, TResult>;
+  resolveMaxBytes: (params: {
+    cfg: FengMingConfig;
+    accountId?: string | null;
+  }) => number | undefined;
+  buildTextOptions: (params: DirectSendOptions) => TOpts;
+  buildMediaOptions: (params: DirectSendOptions) => TOpts;
+}): ChannelOutboundAdapter;
+//#endregion
+export { formatQrPngDataUrl as A, MEDIA_FFMPEG_TIMEOUT_MS as B, DEFAULT_TIMEOUT_SECONDS as C, resolveChannelMediaMaxBytes as D, transcribeFirstAudio as E, encodePngRgba as F, parseMediaContentLength as H, fillPixel as I, resolveOutboundAttachmentFromUrl as L, renderQrPngDataUrl as M, writeQrPngTempFile as N, unlinkIfExists as O, encodePngRgb as P, MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS as R, DEFAULT_PROMPT as S, MIN_AUDIO_FILE_BYTES as T, canonicalizeBase64 as U, MEDIA_FFPROBE_TIMEOUT_MS as V, estimateBase64DecodedBytes as W, CLI_OUTPUT_MAX_BUFFER as _, RunCapabilityResult as a, DEFAULT_MAX_CHARS_BY_CAPABILITY as b, resolveAutoImageModel as c, createMediaAttachmentCache as d, normalizeMediaAttachments as f, resolveDocumentMediaModel as g, resolveDefaultMediaModel as h, normalizeMediaProviderId as i, renderQrPngBase64 as j, renderQrTerminal as k, resolveMediaAttachmentLocalRoots as l, resolveAutoMediaKeyProviders as m, createScopedChannelMediaMaxBytesResolver as n, buildProviderRegistry as o, providerSupportsNativePdfDocument as p, resolveScopedChannelMediaMaxBytes as r, clearMediaUnderstandingBinaryCacheForTests as s, createDirectTextMediaOutbound as t, runCapability as u, DEFAULT_MAX_BYTES as v, DEFAULT_VIDEO_MAX_BASE64_BYTES as w, DEFAULT_MEDIA_CONCURRENCY as x, DEFAULT_MAX_CHARS as y, MEDIA_FFMPEG_MAX_BUFFER_BYTES as z };

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

@@ -0,0 +1,324 @@
+import { r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
+import { d as SecretInput } from "./types.secrets-BKPYDrKY.js";
+import { l as shouldUseEnvHttpProxyForUrl } from "./proxy-env-ISZvc7mK.js";
+import { m as EmbeddingInput, t as MemoryChunk } from "./internal-B1IX4tl2.js";
+import { a as fetchWithSsrFGuard } from "./fetch-guard-BKvfwdRa.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: FengMingConfig;
+  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;
+  maxResponseBytes?: number;
+}): 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-WQfkQMer.d.ts

@@ -0,0 +1,54 @@
+import { a as SqliteWalMaintenance, o as SqliteWalMaintenanceOptions } from "./fengming-runtime-CtRd5677.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 };