qlogicagent 2.9.0 → 2.10.1

package/dist/types/runtime/pet/pet-consistency.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Pet Consistency Scorer — Vision model evaluation for character consistency (design §14.4).
+ *
+ * After generating SVGs (via skeleton or direct LLM), this module:
+ *   1. Renders each SVG state to compare against the reference/base
+ *   2. Uses Vision model to score visual consistency (0-10)
+ *   3. Retries generation if score < threshold
+ *
+ * Strategies used:
+ *   - Structured Prompt: fixed character description + only vary action
+ *   - Post-processing validation: Vision model scores after generation
+ *   - Part presence check: verify required DOM structure exists
+ */
+export interface ConsistencyResult {
+    state: string;
+    score: number;
+    passed: boolean;
+    feedback?: string;
+}
+export interface ConsistencyReport {
+    overallScore: number;
+    results: ConsistencyResult[];
+    passedAll: boolean;
+    retryStates: string[];
+}
+export interface ConsistencyOptions {
+    /** Minimum score to pass (0-10). Default: 6 */
+    threshold?: number;
+    /** Max retries per state. Default: 2 */
+    maxRetries?: number;
+    /** Reference SVG (base/idle state) to compare against */
+    referenceSvg: string;
+    /** Character description for context */
+    characterDesc: string;
+}
+declare const DEFAULT_THRESHOLD = 6;
+declare const DEFAULT_MAX_RETRIES = 2;
+/**
+ * Quick structural check: verify the SVG has consistent DOM structure.
+ * Returns a score 0-10 based on structural similarity to reference.
+ */
+export declare function structuralConsistencyScore(referenceSvg: string, candidateSvg: string): number;
+/**
+ * Build the Vision model prompt for consistency scoring.
+ */
+export declare function buildConsistencyPrompt(characterDesc: string, stateName: string): string;
+/**
+ * Parse Vision model response to extract score and feedback.
+ */
+export declare function parseConsistencyResponse(response: string): {
+    score: number;
+    feedback: string;
+};
+/**
+ * Run the full consistency check pipeline.
+ * Takes generated SVGs, scores each against reference, returns report.
+ *
+ * The `visionScore` callback is optional — if not provided, only structural
+ * scoring is used (faster, no LLM cost, but less accurate).
+ */
+export declare function evaluateConsistency(referenceSvg: string, stateSvgs: Record<string, string>, options?: {
+    threshold?: number;
+}): ConsistencyReport;
+/**
+ * Async consistency evaluation using Vision model for high-accuracy scoring.
+ * Falls back to structural scoring if Vision call fails.
+ */
+export declare function evaluateConsistencyWithVision(referenceSvg: string, stateSvgs: Record<string, string>, visionScore: (referenceSvg: string, candidateSvg: string, state: string) => Promise<{
+    score: number;
+    feedback: string;
+}>, options?: {
+    threshold?: number;
+}): Promise<ConsistencyReport>;
+/**
+ * Retry strategy: regenerate failed states with enhanced prompt.
+ * Returns a prompt modifier string that emphasizes consistency.
+ */
+export declare function buildRetryPrompt(characterDesc: string, state: string, feedback: string, attempt: number): string;
+export { DEFAULT_THRESHOLD, DEFAULT_MAX_RETRIES };

package/dist/types/runtime/pet/pet-skeleton.d.ts

@@ -0,0 +1,70 @@
+/**
+ * PetSkeleton — SVG skeleton parameterization system (design §14.3 Plan A).
+ *
+ * Core idea: generate ONE base skeleton via LLM, then render each state by
+ * only varying animation parameters (pose, expression, effects).
+ * This ensures visual consistency across states without repeated LLM calls.
+ *
+ * Pipeline:
+ *   1. LLM generates a base SVG skeleton with labeled parts
+ *   2. We parse and decompose it into movable parts
+ *   3. Each state applies different CSS @keyframes to the same skeleton
+ */
+export interface PetSkeleton {
+    /** Raw SVG of the base pose (idle-like neutral pose) */
+    baseSvg: string;
+    /** Extracted part IDs found in the SVG */
+    parts: SkeletonPart[];
+    /** Color palette extracted from the base SVG */
+    colors: {
+        primary: string;
+        secondary: string;
+        accent?: string;
+    };
+    /** Character description used to generate this skeleton */
+    characterDesc: string;
+}
+export interface SkeletonPart {
+    id: string;
+    type: "body" | "head" | "left-eye" | "right-eye" | "left-arm" | "right-arm" | "accessory" | "effect";
+    /** CSS selector for this part within the SVG */
+    selector: string;
+}
+export interface StateAnimationParams {
+    body: BodyAnimation;
+    eyes: EyeExpression;
+    arms: ArmPose;
+    effects?: EffectOverlay[];
+}
+export type BodyAnimation = "breathe" | "sway" | "lean" | "tilt" | "shrink" | "bounce" | "still" | "float";
+export type EyeExpression = "blink" | "lookup" | "focus" | "closed" | "wide" | "sparkle" | "dizzy" | "sleepy";
+export type ArmPose = "sway" | "still" | "hammer" | "wave" | "raised" | "covering" | "hold" | "eat";
+export type EffectOverlay = "zzz" | "sparkle" | "sweat" | "question" | "ellipsis" | "heart" | "exclaim" | "music";
+export declare const STATE_ANIMATION_MAP: Record<string, StateAnimationParams>;
+/**
+ * Generate the base skeleton prompt for LLM.
+ * The LLM generates ONE SVG with labeled groups that we can animate differently per state.
+ */
+export declare function buildSkeletonPrompt(characterDesc: string): string;
+/**
+ * Parse a skeleton SVG and identify parts.
+ */
+export declare function parseSkeleton(svgText: string): SkeletonPart[];
+/**
+ * Render a specific state by injecting CSS animations into the skeleton SVG.
+ * The skeleton remains identical — only the <style> block changes.
+ */
+export declare function renderState(skeleton: PetSkeleton, state: string): string;
+/**
+ * Extract primary/secondary colors from an SVG string.
+ * Looks for fill/stop-color attributes and picks the two most frequent.
+ */
+export declare function extractColors(svgText: string): {
+    primary: string;
+    secondary: string;
+};
+/**
+ * Validate that a skeleton SVG has the required part structure.
+ * Returns list of missing parts (empty = valid).
+ */
+export declare function validateSkeleton(svgText: string): string[];

package/dist/types/skills/memory/local-memory-provider.d.ts

@@ -116,6 +116,16 @@ export declare class LocalMemoryProvider implements MemoryProvider {
             date: string;
         }>;
     };
+    /**
+     * List full memory records for a user (paginated). Used by the memory atlas
+     * visualization, which needs the complete record shape (confidence, importance,
+     * accessCount, timestamps, tags) to drive its 3D rendering.
+     */
+    list(userId: string, options?: {
+        page?: number;
+        pageSize?: number;
+        activeOnly?: boolean;
+    }): import("./local-store.js").MemoryRecord[];
     /**
      * Find memories by event date (±tolerance). For temporal context retrieval.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.9.0",
+  "version": "2.10.1",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",

package/dist/types/runtime/infra/builtin-providers.d.ts

@@ -1,36 +0,0 @@
-/**
- * Supported provider metadata for settings RPC.
- *
- * Bridges provider-core's BUILTIN_PROVIDERS into the ModelPurpose system.
- * This is the authoritative list of providers shown in "Add Key" UI.
- *
- * IMPORTANT: Model lists here are the Layer 2 (offline fallback) data source.
- * Layer 1 is ModelCatalog (models.dev remote). These two are the ONLY sources.
- */
-import type { ModelPurpose } from "./model-registry.js";
-export interface KnownModelMeta {
-    model: string;
-    displayName: string;
-    purposes: ModelPurpose[];
-    baseUrl?: string;
-}
-export interface SupportedProviderMeta {
-    id: string;
-    displayName: string;
-    baseUrl: string;
-    defaultRateLimit?: {
-        rpm?: number;
-        tpm?: number;
-    };
-    knownModels: KnownModelMeta[];
-}
-/**
- * Minimal offline fallback providers.
- * Remote catalog (Layer 1) has text generation models; this Layer 2 keeps ONLY
- * specialized models that remote may not cover: embedding, TTS, STT, image gen,
- * video gen, music gen, 3D gen, realtime voice/video, voice clone.
- *
- * All providers are kept (for Add Key UI dropdown + baseUrl lookup).
- * Text generation / image understanding models are NOT listed here — remote always has them.
- */
-export declare const SUPPORTED_PROVIDERS: SupportedProviderMeta[];