@snoai/memory 0.0.0-stage → 1.0.0

package/dist/plugin-config-schema-C0UUbOmG.d.ts

@@ -0,0 +1,413 @@
+import { Tn as recallLifecycleSchema } from "./index-DL8AVj0Z.js";
+import { n as Locale, r as SUPPORTED_LOCALES } from "./locales-JxGmkG6t.js";
+import { c as FIXED_PROTOCOL_VALUE_72, i as FIXED_MEMORY_SNO_EXTRACT_PROFILE, l as PERSISTED_PROVIDER_SYSTEM, n as FIXED_MEMORY_SNO_CONFLICT_VERDICT, o as FIXED_PROTOCOL_VALUE_70, r as FIXED_MEMORY_SNO_EXTRACT_CHAT, s as FIXED_PROTOCOL_VALUE_71, t as FIXED_MEMORY_SNO_AI_EXTRACT } from "./signed-registry-constants-Bv0fgZ8Q.js";
+import { n as AgentLlmPort } from "./agent-llm-port-5oXgBpzJ.js";
+import { z } from "zod";
+import { LLMConfig } from "@snoai/llmix";
+//#region config/session-strategy.d.ts
+/** @file session-strategy.ts
+ * @purpose Defines session-memory strategy constants without importing plugin config schemas.
+ * @boundary Shared literal values only; no schema or runtime registration dependencies.
+ */
+declare const SESSION_STRATEGIES: readonly ["memoryReflection", "systemSessionMemory", "none"];
+type SessionStrategy = (typeof SESSION_STRATEGIES)[number];
+//#endregion
+//#region config/plugin-config-embedding-schema.d.ts
+declare const embeddingConfigSchema: z.ZodType<{
+  provider: "local-onnx";
+  model?: string | undefined;
+  dimensions: number;
+  nativeDim?: number | undefined;
+  revision?: string | undefined;
+  pooling?: "last_token" | "mean" | "cls" | undefined;
+  normalized?: boolean | undefined;
+  cacheDir?: string | undefined;
+  offline?: boolean | undefined;
+  mirror?: string | undefined;
+  dtype: "q4" | "q8" | "fp16" | "fp32";
+  sessionOptions: {
+    graphOptimizationLevel: "disabled" | "basic" | "extended" | "all";
+    enableMemPattern: boolean;
+    enableCpuMemArena: boolean;
+    executionMode?: "sequential" | "parallel" | undefined;
+    interOpNumThreads?: number | undefined;
+    intraOpNumThreads?: number | undefined;
+  };
+  chunking: boolean;
+}, unknown>;
+//#endregion
+//#region config/settings.d.ts
+type Settings = {
+  mode: ProductMode;
+  modelCalls: Record<keyof typeof MODEL_CALLS, Record<ProductMode, ModelDestination>>;
+  user: {
+    id: string;
+    language: Locale;
+  };
+  snoGpu: {
+    baseUrl: string;
+    apiKey: string;
+  };
+  rerank: {
+    mode: "lightweight" | "cross-encoder" | "none";
+    provider: "jina" | "siliconflow" | "pinecone" | "voyage" | "dashscope" | "tei" | "custom";
+    endpoint: string;
+    model: string;
+    apiKey: string;
+    timeoutMs: number;
+    maxCandidates: number;
+  };
+  store: {
+    path: string;
+    encryptionKey: string;
+  };
+  embedding: {
+    model: string;
+    revision: string;
+    dtype: "q4" | "q8" | "fp16" | "fp32";
+    threads: number;
+    cacheDir: string;
+    offline: boolean;
+    mirror: string;
+  };
+  recall: {
+    auto: boolean;
+    sessionStart: {
+      limit: number;
+      maxChars: number;
+      timeoutMs: number;
+    };
+    prompt: {
+      limit: number;
+      maxChars: number;
+      timeoutMs: number;
+      minChars: number;
+      minScore: number;
+    };
+    explicitLimit: number;
+  };
+  capture: {
+    assistant: boolean;
+    ambient: boolean;
+    sessionMemory: {
+      enabled: boolean;
+      messageCount: number;
+    };
+    sessionStrategy: (typeof SESSION_STRATEGIES)[number];
+  };
+  rem: {
+    tick: boolean;
+    operations: ("rem-replace" | "rem-update")[];
+  };
+  telemetry: {
+    memoryUsage: {
+      enabled: boolean;
+      key: string;
+      historicKeys: string[];
+    };
+    observe: {
+      enabled: boolean;
+      baseUrl: string;
+    };
+    redactionRules: string[];
+  };
+  logging: {
+    level: "debug" | "info" | "warn" | "error";
+    file: string;
+    debugContent: boolean;
+  };
+  memoryPackage: {
+    path: string;
+    node: string;
+  };
+};
+declare const settingsSchema: z.ZodType<Settings>;
+declare function defaultSettings(): Settings;
+declare function settingsToPluginConfig(settings: Settings): PluginConfig;
+//#endregion
+//#region config/plugin-config-mode-schema.d.ts
+/**
+ * Product LLM modes, tier-ordered: Local First (selected calls on host) → Agent
+ * Native (every call borrows the host agent's model) → REM Enhanced (top
+ * tier: SNO-REM-MEM serves the LoRA-covered calls, the host model covers
+ * the rest).
+ */
+declare const PRODUCT_MODES: readonly ["local-first", "agent-native", "rem-enhanced"];
+type ProductMode = (typeof PRODUCT_MODES)[number];
+declare const DEFAULT_MODEL_MODE: ProductMode;
+/** Occasions select system messages; call ids select destinations. */
+declare const LLM_OCCASIONS: readonly ["memoryExtract", "profileSectionMerge", "profileActiveTaskClassify", "conflictAdjudication", "summaryBuild", "dateResolution"];
+type LlmOccasion = (typeof LLM_OCCASIONS)[number];
+declare const remEnhancedConfigSchema: z.ZodType<{
+  trigger: {
+    tick: boolean;
+  };
+}, unknown>;
+/** The schema-defaulted config slice the request-time route resolver consumes. */
+type LlmRoutingConfig = {
+  mode: ProductMode;
+  language: Locale;
+  modelCalls?: Settings["modelCalls"];
+};
+declare const llmRoutingConfigSchema: z.ZodType<LlmRoutingConfig, unknown>;
+type LlmRoutingConfigInput = {
+  mode: ProductMode;
+  language?: unknown;
+  modelCalls?: Settings["modelCalls"];
+};
+//#endregion
+//#region src/model/model-call-table.d.ts
+type ModelDestination = "off" | "host" | "sno-gpu";
+type ModelCallId = "E1" | "E2" | "E3" | "E4" | "E5" | "E6" | "E7" | "E8" | "E9" | "E10" | "E11" | "E12" | "P1" | "P2" | "P3" | "P4" | "P5" | "P6" | "T1" | "R1" | "REM1" | "REM2" | "REM3" | "REM4" | "REM5" | "REM6" | "REM7" | "REM8";
+type RsiModelCallId = "R2" | "R3" | "R4";
+type ModelCall = {
+  description: string;
+  occasion: LlmOccasion;
+  destinations: Record<ProductMode, ModelDestination>;
+  snoPreset: LlmPreset;
+  transport: {
+    host: "agent-host-seam";
+    snoGpu: "chat-completions" | "raw-completions";
+  };
+  promptVariant: {
+    host: "standard" | "adapter-a-chat";
+    snoGpu: "standard" | "adapter-a-raw";
+  };
+  replyParser: {
+    host: "json" | "text" | "json-or-single-token-verdict";
+    snoGpu: "json" | "text" | "single-token-verdict";
+  };
+};
+declare const MODEL_CALLS: Record<ModelCallId, ModelCall> & Record<RsiModelCallId, {
+  description: string;
+  calledBy: "RSI skill";
+  destinations: Record<ProductMode, ModelDestination>;
+}>;
+//#endregion
+//#region src/model/llm-client-types.d.ts
+declare const LLM_PRESETS: readonly [typeof FIXED_MEMORY_SNO_AI_EXTRACT, typeof FIXED_MEMORY_SNO_EXTRACT_CHAT, typeof FIXED_MEMORY_SNO_EXTRACT_PROFILE, typeof FIXED_MEMORY_SNO_CONFLICT_VERDICT];
+type LlmPreset = (typeof LLM_PRESETS)[number];
+type LlmProvider = "openai" | "openrouter" | "sno-gpu";
+type MemoryLlmRequest = {
+  prompt: string;
+  hostPrompt?: string;
+  callId: ModelCallId;
+  /** Content-free correlation token forwarded as X-Request-ID when present. */
+  requestId?: string;
+  /** Hash of the static prompt asset, never the rendered user prompt. */
+  promptTemplateHash?: string;
+  extractionSkillHash?: string;
+  maxTokens?: number;
+  /** Per-request empty-body attempts. Defaults to the shared bounded retry policy. */
+  emptyReplyAttempts?: number;
+  timeoutMs?: number;
+  enableThinking?: boolean;
+  signal?: AbortSignal;
+  /**
+   * completeJson only: the caller's own shape check, run on each payload candidate in order.
+   *
+   * Without it the first syntactically valid object wins and a caller whose schema rejects it
+   * never sees the correct payload sitting behind it — measured on the live route, the subject
+   * guard returned null that way and parked a whole batch.
+   */
+  accept?: (value: unknown) => boolean;
+};
+interface LlmClientConfig {
+  /** Signed LLMIx preset id. */
+  preset: LlmPreset;
+  /** API key from settings. */
+  apiKey?: string;
+  /** Full base URL including /v1 suffix. */
+  baseURL?: string;
+  timeoutMs?: number;
+  agentPort?: AgentLlmPort;
+  operationId?: string;
+  onTransportAttempt?: (attempt: {
+    callId: ModelCallId;
+    destination: "host" | "sno-gpu";
+    transport: "chat-completions" | "raw-completions" | "agent-host-seam";
+  }) => void;
+  onProviderResponse?: (response: ProviderResponseTrace) => void;
+  /**
+   * Product-mode routing slice. When present, every request is resolved
+   * through resolveLlmRoute first; a routed-OFF request returns null without
+   * touching the network (callers' deterministic fallbacks take over).
+   */
+  routing?: LlmRoutingConfig;
+}
+type ResolvedLlmConfig = {
+  preset: LlmPreset;
+  provider: LlmProvider;
+  model: string;
+  providerOptions?: LLMConfig["providerOptions"];
+  baseURL?: string;
+  timeoutMs?: number;
+};
+interface LlmClient {
+  /** Send a prompt and parse the JSON response. Degradable failures return null; host cancellation and authentication rejection throw. */
+  completeJson<T>(request: MemoryLlmRequest): Promise<T | null>;
+  /** Send a prompt and return raw text. Degradable failures return null; host cancellation and authentication rejection throw. */
+  completeText(request: MemoryLlmRequest): Promise<string | null>;
+  /** Signed preset resolved through the bundled LLMIx registry. */
+  getResolvedConfig(): Promise<ResolvedLlmConfig>;
+  /** Best-effort diagnostics for the most recent failure, if any. */
+  getLastError(): string | null;
+  /** Provider-reported usage from the most recent successful response, if available. */
+  getLastUsage(): TokenUsage | null;
+}
+type TokenUsage = {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  estimated?: boolean;
+};
+type ProviderResponseTrace = {
+  durationMs?: number;
+  callId: ModelCallId;
+  destination: "host" | "sno-gpu";
+  provider: LlmProvider;
+  requestId?: string;
+  model?: string;
+  usage?: Omit<TokenUsage, "estimated">;
+  /** Set when the call produced no answer; the value is the failure category. */
+  failure?: string;
+};
+//#endregion
+//#region config/plugin-config-feature-schema.d.ts
+declare const sessionMemoryConfigSchema: z.ZodType<{
+  enabled: boolean;
+  messageCount: number;
+}, unknown>;
+declare const selfImprovementConfigSchema: z.ZodType<{
+  enabled: boolean;
+  beforeResetNote: boolean;
+  skipSubagentBootstrap: boolean;
+  ensureLearningFiles: boolean;
+}, unknown>;
+declare const extractionConfigSchema: z.ZodType<{
+  llm: {
+    preset: (typeof LLM_PRESETS)[number];
+    baseURL?: string | undefined;
+    apiKey?: string | undefined;
+    timeoutMs: number;
+  };
+}, unknown>;
+declare const memoryReflectionConfigSchema: z.ZodType<{
+  messageCount: number;
+  maxInputChars: number;
+  timeoutMs: number;
+  errorReminderMaxEntries: number;
+  dedupeErrorSignals: boolean;
+  injectMode: "inheritance+derived" | "inheritance-only" | "none";
+  storeToDb: boolean;
+  injectIntoPrompt: boolean;
+  agentId?: string | undefined;
+}, unknown>;
+//#endregion
+//#region config/plugin-config-observe-schema.d.ts
+declare const AGENT_IDS: readonly [typeof PERSISTED_PROVIDER_SYSTEM, typeof FIXED_PROTOCOL_VALUE_70, typeof FIXED_PROTOCOL_VALUE_71, typeof FIXED_PROTOCOL_VALUE_72];
+declare const observeConfigSchema: z.ZodType<{
+  enabled: boolean;
+  baseUrl: string;
+  agentId: (typeof AGENT_IDS)[number];
+}, unknown>;
+//#endregion
+//#region config/plugin-config-retrieval-schema.d.ts
+declare const retrievalConfigSchema: z.ZodType<{
+  mode: "precision-recall" | "vector";
+  recallTopK: number;
+  vectorWeight: number;
+  bm25Weight: number;
+  minScore: number;
+  rerank: "cross-encoder" | "lightweight" | "none";
+  candidatePoolSize: number;
+  rerankApiKey?: string | undefined;
+  rerankModel: string;
+  rerankTimeoutMs: number;
+  recencyHalfLifeDays: number;
+  recencyWeight: number;
+  temporalWeighting: boolean;
+  mmrWindowOnly: boolean;
+  temporalExpiry: boolean;
+  temporalDecay: boolean;
+  lengthNormAnchor: number;
+  hardMinScore: number;
+  timeDecayHalfLifeDays: number;
+  rerankBlendVector?: number | undefined;
+  rerankBlendCross?: number | undefined;
+  lightweightFusionWeight?: number | undefined;
+  lightweightCosineWeight?: number | undefined;
+  importanceWeightBase?: number | undefined;
+  timeDecayFloor?: number | undefined;
+  mmrLambda?: number | undefined;
+  rerankEndpoint?: string | undefined;
+  rerankProvider?: "jina" | "siliconflow" | "pinecone" | "voyage" | "dashscope" | "tei" | "custom" | undefined;
+  rerankMaxCandidates?: number | undefined;
+  reinforcementFactor: number;
+  maxHalfLifeMultiplier: number;
+}, unknown>;
+//#endregion
+//#region config/plugin-config-schema.d.ts
+declare const ONBOARDING_PROFILES: readonly ["local-active", "capture-only", "manual-only", "custom"];
+declare const REM_OPERATIONS: readonly ["rem-replace", "rem-update"];
+type PluginConfigOutput = {
+  embedding: z.output<typeof embeddingConfigSchema>;
+  observe: z.output<typeof observeConfigSchema>;
+  dbPath?: string | undefined;
+  provider: {
+    userId?: string | undefined;
+  };
+  ambientLearning: boolean;
+  autoRecall: boolean;
+  autoRecallMinLength: number;
+  autoRecallMinRepeated: number;
+  autoRecallMaxQueryLength: number;
+  autoRecallTimeoutMs: number;
+  autoRecallIncludeAgents: string[];
+  autoRecallExcludeAgents: string[];
+  captureAssistant: boolean;
+  retrieval: z.output<typeof retrievalConfigSchema>;
+  scopes: {
+    default: string;
+    definitions: Record<string, {
+      description?: string | undefined;
+      metadata?: Record<string, unknown> | undefined;
+    }>;
+    agentAccess: Record<string, string[]>;
+  };
+  enableManagementTools: boolean;
+  language?: (typeof SUPPORTED_LOCALES)[number] | undefined;
+  sessionStrategy: (typeof SESSION_STRATEGIES)[number];
+  sessionMemory: z.output<typeof sessionMemoryConfigSchema>;
+  compression?: {
+    enabled: boolean;
+  } | undefined;
+  selfImprovement: z.output<typeof selfImprovementConfigSchema>;
+  extraction: z.output<typeof extractionConfigSchema>;
+  memoryReflection: z.output<typeof memoryReflectionConfigSchema>;
+  recallLifecycle: z.output<typeof recallLifecycleSchema>;
+  memoryTelemetry: {
+    enabled: boolean;
+    currentKeyVersion: number;
+    key: string;
+    historicKeys: string[];
+  };
+  debugContent: boolean;
+  mode: (typeof PRODUCT_MODES)[number];
+  modelCalls?: Settings["modelCalls"];
+  remOperations: (typeof REM_OPERATIONS)[number][];
+  remEnhanced?: {
+    trigger: {
+      tick: boolean;
+    };
+  };
+  onboarding?: {
+    version: number;
+    completedAt: string;
+    profile: (typeof ONBOARDING_PROFILES)[number];
+  } | undefined;
+};
+declare const pluginConfigSchema: z.ZodType<PluginConfigOutput, unknown>;
+type PluginConfig = z.output<typeof pluginConfigSchema>;
+//#endregion
+export { SESSION_STRATEGIES as C, settingsToPluginConfig as S, llmRoutingConfigSchema as _, LlmPreset as a, defaultSettings as b, ResolvedLlmConfig as c, LLM_OCCASIONS as d, LlmOccasion as f, ProductMode as g, PRODUCT_MODES as h, LlmClientConfig as i, ModelCallId as l, LlmRoutingConfigInput as m, pluginConfigSchema as n, LlmProvider as o, LlmRoutingConfig as p, LlmClient as r, MemoryLlmRequest as s, PluginConfig as t, DEFAULT_MODEL_MODE as u, remEnhancedConfigSchema as v, SessionStrategy as w, settingsSchema as x, Settings as y };