qlogicagent 2.10.12 → 2.10.14

package/dist/types/protocol/wire/gateway-rpc.d.ts

@@ -27,6 +27,40 @@ export interface ProjectInfo {
     leaderSessionId?: string;
 }
 export interface GatewayRpcMethodMap {
+    "agent.health": {
+        params: {};
+        result: {
+            ok: boolean;
+            status: "healthy" | "degraded" | "stopping";
+            uptimeMs: number;
+            protocolVersion: string;
+            version: string;
+        };
+    };
+    "agent.metrics": {
+        params: {};
+        result: {
+            rpc: {
+                activeRequests: number;
+                completedRequests: number;
+                cancelledRequests: number;
+                deadlineExceededRequests: number;
+                dedupedRequests: number;
+                lateResponsesDropped: number;
+                invalidRequests: number;
+            };
+        };
+    };
+    "agent.cancel": {
+        params: {
+            requestId: string;
+            reason?: string;
+        };
+        result: {
+            ok: boolean;
+            cancelled: boolean;
+        };
+    };
     "session.list": {
         params: {
             limit?: number;
@@ -381,8 +415,14 @@ export interface GatewayRpcMethodMap {
         params: {
             userId?: string;
             pageSize?: number;
+            windowStartAt?: number;
+            windowEndAt?: number;
+            windowCenterAt?: number;
+            bucketCount?: number;
+            clusterLimit?: number;
         };
         result: {
+            totalCount: number;
             records: Array<{
                 id: string;
                 text: string;
@@ -399,6 +439,38 @@ export interface GatewayRpcMethodMap {
                 lastAccessedAt: number;
                 isArchived: boolean;
             }>;
+            buckets: Array<{
+                id: string;
+                startAt: number;
+                endAt: number;
+                count: number;
+                avgImportance: number;
+                avgConfidence: number;
+                topCategory: string;
+            }>;
+            clusters: Array<{
+                id: string;
+                label: string;
+                kind: "source" | "category" | "tag";
+                count: number;
+                startAt: number;
+                endAt: number;
+                avgImportance: number;
+                avgConfidence: number;
+                topCategory: string;
+            }>;
+            windowCursor: {
+                startAt: number;
+                endAt: number;
+                centerAt: number;
+                pageSize: number;
+                hasBefore: boolean;
+                hasAfter: boolean;
+            } | null;
+            timeRange: {
+                startAt: number;
+                endAt: number;
+            } | null;
             stats: {
                 formed: number;
                 insights: number;
@@ -425,11 +497,121 @@ export interface GatewayRpcMethodMap {
             }>;
         };
     };
+    "memory.addManual": {
+        params: {
+            userId?: string;
+            text: string;
+            category?: string;
+            importance?: number;
+            source?: string;
+            tags?: string[];
+            attachments?: Array<{
+                type: "image" | "audio" | "video" | "file" | string;
+                filename: string;
+                mimeType?: string;
+                size?: number;
+                text?: string;
+                url?: string;
+                path?: string;
+            }>;
+            autoExtract?: boolean;
+        };
+        result: {
+            ok: boolean;
+            memoriesAdded: number;
+        };
+    };
+    "memory.ingest": {
+        params: {
+            userId?: string;
+            text?: string;
+            category?: string;
+            importance?: number;
+            source?: string;
+            tags?: string[];
+            autoExtract?: boolean;
+            attachments?: Array<{
+                type: "image" | "audio" | "video" | "file" | string;
+                filename: string;
+                mimeType?: string;
+                size?: number;
+                text?: string;
+                url?: string;
+                path?: string;
+            }>;
+        };
+        result: {
+            ok: boolean;
+            extractor: "llm" | "deterministic";
+            candidates: Array<{
+                id: string;
+                text: string;
+                category: string;
+                importance: number;
+                confidence: number;
+                source: string;
+                eventDate?: string;
+                tags: string[];
+                relatedMemoryIds: string[];
+                evidence: Array<Record<string, unknown>>;
+                requiresConfirmation: boolean;
+                reason?: string;
+            }>;
+            relatedMemories: Array<{
+                id: string;
+                text: string;
+                score: number;
+                category?: string;
+            }>;
+        };
+    };
+    "memory.commit": {
+        params: {
+            userId?: string;
+            candidates: Array<{
+                id?: string;
+                text: string;
+                category?: string;
+                importance?: number;
+                confidence?: number;
+                source?: string;
+                eventDate?: string;
+                tags?: string[];
+                relatedMemoryIds?: string[];
+            }>;
+        };
+        result: {
+            ok: boolean;
+            memoriesAdded: number;
+        };
+    };
+    "memory.update": {
+        params: {
+            userId?: string;
+            id: string;
+            text?: string;
+            category?: string;
+            importance?: number;
+            source?: string;
+            eventDate?: string;
+            tags?: string[];
+        };
+        result: {
+            ok: boolean;
+            updated: number;
+        };
+    };
 }
 /**
  * Type-safe Agent RPC caller.
  * Gateway passes this around instead of `(string, Record<string, unknown>) => Promise<unknown>`.
  */
-export type AgentCall = <M extends keyof GatewayRpcMethodMap>(method: M, params: GatewayRpcMethodMap[M]["params"]) => Promise<GatewayRpcMethodMap[M]["result"]>;
+export interface AgentCallOptions {
+    timeoutMs?: number;
+    requestId?: string;
+    idempotencyKey?: string;
+    traceId?: string;
+}
+export type AgentCall = <M extends keyof GatewayRpcMethodMap>(method: M, params: GatewayRpcMethodMap[M]["params"], options?: AgentCallOptions) => Promise<GatewayRpcMethodMap[M]["result"]>;
 /** All gateway-facing RPC method names (runtime array). */
 export declare const GATEWAY_RPC_METHODS: (keyof GatewayRpcMethodMap)[];

package/dist/types/protocol/wire/index.d.ts

@@ -1,5 +1,6 @@
-export { AGENT_RPC_APPROVAL_METHODS, AGENT_RPC_ERROR_CODES, AGENT_RPC_PROTOCOL_VERSION, isAgentRpcNotification, isAgentRpcRequest, isAgentRpcResponse, parseAgentRpcMessage, type AgentHelloParams, type AgentHelloResult, type AgentRpcError, type AgentRpcErrorCode, type AgentRpcMessage, type AgentRpcNotification, type AgentRpcRequest, type AgentRpcResponse, type ToolApprovalRequestParams, type ToolApprovalResponseParams, } from "./agent-rpc.js";
-export { GATEWAY_RPC_METHODS, type AgentCall, type GatewayRpcMethodMap, type ProjectInfo as RpcProjectInfo, type ProjectStatus as RpcProjectStatus, type ProjectType as RpcProjectType, } from "./gateway-rpc.js";
+export { AGENT_RPC_APPROVAL_METHODS, AGENT_RPC_ERROR_CODES, AGENT_RPC_PROTOCOL_VERSION, isAgentRpcNotification, isAgentRpcRequest, isAgentRpcResponse, parseAgentRpcMessage, type AgentHelloParams, type AgentHelloResult, type AgentRpcError, type AgentRpcErrorCode, type AgentRpcMeta, type AgentRpcChannel, type AgentRpcMessage, type AgentRpcNotification, type AgentRpcRequest, type AgentRpcResponse, type ToolApprovalRequestParams, type ToolApprovalResponseParams, } from "./agent-rpc.js";
+export { GatewayRpcContract, buildAgentRpcMeta, classifyGatewayRpcMethod, requireGatewayRpcMeta, requiresIdempotencyKey, type GatewayRpcClassification, type GatewayRpcMetrics, type GatewayRpcMutability, } from "./gateway-contract.js";
+export { GATEWAY_RPC_METHODS, type AgentCall, type AgentCallOptions, type GatewayRpcMethodMap, type ProjectInfo as RpcProjectInfo, type ProjectStatus as RpcProjectStatus, type ProjectType as RpcProjectType, } from "./gateway-rpc.js";
 export { type ChatMessage, type ChatMessageRole, type ThinkingBlock, type ToolCallMessage, type ToolDefinition, } from "./chat-types.js";
 export { type AgentCapabilities, type AgentCategory, type AgentConfig, type AgentDescriptor, type AgentProtocol, type AgentRpcMethodMap, type AgentStatus, type CustomAgentDef, type ProductInstanceDef, type ProductPhase, type ProductStatus, type ProductSummary, type ProductTaskDef, type ProductTaskStatus, type SoloAgentResult, type SoloAgentState, type SoloState, type SoloStatus, } from "./agent-methods.js";
 export { AGENT_TEAM_WS_EVENT_NAMES, AGENT_WS_EVENT_NAMES, ALL_AGENT_WS_EVENT_NAMES, type AgentTeamWsEventName, type AgentWsEventName, type AllAgentWsEventName, } from "./agent-events.js";

package/dist/types/protocol/wire/memory-provider-lifecycle.d.ts

@@ -61,7 +61,7 @@ export interface MemorySearchOptions {
 }
 export interface MemoryIngestOptions {
     llmConfig?: MemoryLlmConfig;
-    source?: MemoryObservationSource;
+    source?: string;
     sessionId?: string;
 }
 export interface MemoryProvider {

package/dist/types/runtime/execution/dream-agent.d.ts

@@ -12,7 +12,7 @@
  */
 import type { DreamTaskState, DreamTurn } from "../../orchestration/subagent/task-types.js";
 import type { ToolDefinition, ToolInvoker, AgentLogger, HookRegistry } from "../../agent/types.js";
-import type { LLMTransport } from "../../provider-core/index.js";
+import type { LLMTransport } from "@xiaozhiclaw/provider-core";
 export interface DreamTriggerConfig {
     /** Minimum hours since last consolidation. Default: 24. */
     minHours: number;

package/dist/types/runtime/execution/forked-agent.d.ts

@@ -18,7 +18,7 @@
  * Reference: claude-code src/utils/forkedAgent.ts
  */
 import type { AgentLogger, ChatMessage, ToolDefinition, ToolInvoker, TokenUsage, TurnEvent, HookRegistry } from "../../agent/types.js";
-import type { LLMTransport } from "../../provider-core/index.js";
+import type { LLMTransport } from "@xiaozhiclaw/provider-core";
 import type { AgentProgress } from "./progress-tracker.js";
 /**
  * Tool permission check function — CC canUseTool parity.

package/dist/types/runtime/hooks/context-compression.d.ts

@@ -1,7 +1,7 @@
 import { ContextEngineRegistry, type CompressibleMessage, type CompressionResult, type CompressionStrategy, type AsyncCompressionStrategy, type SummarizeFn } from "../../orchestration/index.js";
 import type { HookRegistry } from "./hook-registry.js";
 import type { RuntimeLogger } from "./hook-registry.js";
-import type { LLMTransport } from "../../provider-core/index.js";
+import type { LLMTransport } from "@xiaozhiclaw/provider-core";
 /** Rough token estimate: ~4 chars per token for mixed CJK/English. */
 export declare function estimateTokens(msg: CompressibleMessage): number;
 /** Estimate total tokens for a message array. */

package/dist/types/runtime/session/session-persistence.d.ts

@@ -107,7 +107,7 @@ export declare function deleteSession(sessionId: string, projectRoot: string): P
  */
 export declare function pruneOldSessions(projectRoot: string): Promise<number>;
 export interface TaskSummaryDeps {
-    transport: import("../../provider-core/index.js").LLMTransport;
+    transport: import("@xiaozhiclaw/provider-core").LLMTransport;
     apiKey: string;
     model: string;
 }

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

@@ -2,10 +2,7 @@
  * Local Embedding — Pluggable embedding interface for local memory.
  *
  * Provides a unified interface for text → vector embedding.
- * Strategies:
- *   1. "api" — calls an external embedding API (OpenAI-compatible)
- *   2. "onnx" — @xenova/transformers for fully offline embedding
- *   3. "none" — no embeddings, FTS-only search (zero-dep fallback)
+ * If no API config is provided, memory search falls back to FTS-only.
  */
 export interface EmbeddingProvider {
     readonly dimensions: number;
@@ -38,29 +35,6 @@ export declare class NullEmbeddingProvider implements EmbeddingProvider {
     embed(_text: string): Promise<Float32Array>;
     embedBatch(_texts: string[]): Promise<Float32Array[]>;
 }
-/**
- * Wraps a primary EmbeddingProvider with automatic fallback to a local provider.
- * When the primary fails (timeout, network error, 5xx), transparently retries with local.
- *
- * IMPORTANT: primary and fallback MUST have the same dimensions.
- * If they differ, vectors in the same index will be incomparable.
- * Use this only when both produce the same dimensionality (e.g. hub TEI bge-m3 1024d
- * + local ONNX bge-m3-small 1024d).
- */
-export declare class FallbackEmbeddingProvider implements EmbeddingProvider {
-    readonly dimensions: number;
-    readonly model: string;
-    private primary;
-    private fallback;
-    private onFallback?;
-    constructor(opts: {
-        primary: EmbeddingProvider;
-        fallback: EmbeddingProvider;
-        onFallback?: (error: Error) => void;
-    });
-    embed(text: string): Promise<Float32Array>;
-    embedBatch(texts: string[]): Promise<Float32Array[]>;
-}
 export declare class ApiEmbeddingProvider implements EmbeddingProvider {
     readonly dimensions: number;
     readonly model: string;
@@ -75,89 +49,19 @@ export declare class ApiEmbeddingProvider implements EmbeddingProvider {
     private parseResponse;
 }
 export interface LocalEmbeddingConfig {
-    strategy: "api" | "onnx" | "none";
     api?: EmbeddingApiConfig;
-    onnx?: OnnxEmbeddingConfig;
-    /**
-     * When strategy=api, if the API fails (timeout/error), fallback to this.
-     * - "onnx": use local ONNX model (download on first use, ~23MB)
-     * - "none": give up embedding (FTS-only)
-     * Requires same dimensions for vector compatibility. Default ONNX model
-     * (bge-small-zh-v1.5, 512d) differs from bge-m3 (1024d).
-     * Accept dimension mismatch for degraded recall in fallback mode.
-     */
-    fallbackStrategy?: "onnx" | "none";
-    fallbackOnnx?: OnnxEmbeddingConfig;
-}
-export interface OnnxEmbeddingConfig {
-    /** Model ID for @xenova/transformers (default: "Xenova/bge-small-zh-v1.5") */
-    modelId?: string;
-    /** Expected dimensions (default: 512 for bge-small-zh-v1.5) */
-    dimensions?: number;
-    /** Max sequence length before truncation (default: 256) */
-    maxLength?: number;
-    /** Override local model path (for testing). */
-    localModelPath?: string;
 }
-/**
- * Offline embedding provider using ONNX Runtime via @xenova/transformers.
- *
- * Model is lazily downloaded on first use (~24MB for bge-small-zh-v1.5 quantized).
- * Subsequent loads are instant from local cache (~/.qlogicagent/models/).
- *
- * For China network: set ONNX_MODEL_MIRROR to OSS URL or HF_MIRROR=https://hf-mirror.com
- */
-export declare class OnnxEmbeddingProvider implements EmbeddingProvider {
-    readonly dimensions: number;
-    readonly model: string;
-    private maxLength;
-    private localModelPath;
-    private pipeline;
-    private loading;
-    constructor(config?: OnnxEmbeddingConfig);
-    private getPipeline;
-    embed(text: string): Promise<Float32Array>;
-    embedBatch(texts: string[]): Promise<Float32Array[]>;
-    /**
-     * Pre-download and load the ONNX model without blocking.
-     * Call this at process startup for instant readiness on first real embed().
-     */
-    warmup(): Promise<void>;
-}
-export interface WarmupResult {
-    onnxAvailable: boolean;
-    modelCached: boolean;
-    modelDownloaded: boolean;
-    dimensions: number;
-    error?: string;
-}
-/**
- * Run at process startup to verify environment and pre-download ONNX model.
- *
- * - Checks if @xenova/transformers is installed
- * - Checks if model already in local cache
- * - If not cached, downloads from OSS CDN in background
- * - Returns status for diagnostics logging
- *
- * Fire-and-forget: never throws, never blocks critical path.
- */
-export declare function warmupEmbeddingModel(config?: OnnxEmbeddingConfig): Promise<WarmupResult>;
 /**
  * Create an embedding provider based on configuration.
  *
  * Resolution order:
- *   1. Explicit config (api/onnx/none)
- *   2. Auto-detect: @xenova/transformers available → use ONNX (lazy download)
- *   3. Fallback to NullEmbeddingProvider (FTS-only)
- *
- * When config.fallbackStrategy is set and strategy=api, wraps primary in
- * FallbackEmbeddingProvider for automatic local retry on API failure.
+ *   1. API config → ApiEmbeddingProvider
+ *   2. No API config → NullEmbeddingProvider (FTS-only)
  */
 export declare function createEmbeddingProvider(config?: LocalEmbeddingConfig): EmbeddingProvider;
 /**
  * Known provider → format mapping.
- * Used by auto-cascade to build the correct EmbeddingApiConfig
- * when the user's LLM provider also has an embedding API.
+ * Used only for the explicit ModelRegistry embedding binding.
  */
 export declare const PROVIDER_EMBEDDING_REGISTRY: Record<string, {
     format: "openai" | "minimax" | "volcengine";

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

@@ -9,7 +9,7 @@
  *   - Without embedding: FTS-only search (still useful for exact/keyword matches)
  */
 import type { MemoryProvider, MemorySearchResult, MemorySearchOptions, MemoryIngestMessage, MemoryIngestOptions } from "../../protocol/wire/index.js";
-import type { SqliteDatabase } from "./local-store.js";
+import type { MemoryUpdateInput, SqliteDatabase } from "./local-store.js";
 import { type LocalEmbeddingConfig } from "./local-embedding.js";
 /** A pre-extracted memory item ready to be stored (no LLM needed). */
 export interface ExtractedMemoryItem {
@@ -38,6 +38,9 @@ export declare class LocalMemoryProvider implements MemoryProvider {
     private dbPath;
     constructor(config: LocalMemoryProviderConfig);
     private resolveUserId;
+    private buildEmbedding;
+    private findExistingDuplicate;
+    private insertDeduped;
     search(query: string, userId: string, options?: MemorySearchOptions): Promise<MemorySearchResult[]>;
     ingest(messages: MemoryIngestMessage[], userId: string, options?: MemoryIngestOptions): Promise<void>;
     addText(text: string, userId: string, options?: MemoryIngestOptions & {
@@ -47,6 +50,7 @@ export declare class LocalMemoryProvider implements MemoryProvider {
         memoriesAdded: number;
     }>;
     remove(memoryId: string): Promise<boolean>;
+    update(memoryId: string, input: MemoryUpdateInput): Promise<boolean>;
     /**
      * Ingest pre-extracted memory items (no LLM needed).
      * Compatible with qmemory-adapter's ingestExtracted interface.
@@ -129,6 +133,19 @@ export declare class LocalMemoryProvider implements MemoryProvider {
     /**
      * Find memories by event date (±tolerance). For temporal context retrieval.
      */
+    /**
+     * Return the final atlas payload: a bounded interactive record window plus
+     * whole-history buckets/clusters for large timelines.
+     */
+    getAtlas(userId: string, options?: {
+        pageSize?: number;
+        windowStartAt?: number;
+        windowEndAt?: number;
+        windowCenterAt?: number;
+        bucketCount?: number;
+        clusterLimit?: number;
+        activeOnly?: boolean;
+    }): import("./local-store.js").MemoryAtlasResult;
     findByEventDate(userId: string, targetDate: string, toleranceDays?: number): import("./local-store.js").MemorySearchHit[];
     /**
      * Find related memories (event continuity detection).
@@ -200,8 +217,4 @@ export declare class LocalMemoryProvider implements MemoryProvider {
      */
     close(): void;
 }
-/**
- * Create a local memory provider (convenience factory).
- * Caller must provide the createDatabase factory to avoid hard dependency on better-sqlite3.
- */
 export declare function createLocalMemoryProvider(config: LocalMemoryProviderConfig): LocalMemoryProvider;

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

@@ -42,6 +42,15 @@ export interface MemoryInsertInput {
     tags?: string[];
     embedding?: Float32Array;
 }
+export interface MemoryUpdateInput {
+    text?: string;
+    category?: string;
+    importance?: number;
+    source?: string;
+    eventDate?: string;
+    tags?: string[];
+    embedding?: Float32Array | null;
+}
 export interface MemorySearchHit {
     id: string;
     text: string;
@@ -50,6 +59,45 @@ export interface MemorySearchHit {
     importance: number;
     metadata: Record<string, unknown>;
 }
+export interface MemoryAtlasBucket {
+    id: string;
+    startAt: number;
+    endAt: number;
+    count: number;
+    avgImportance: number;
+    avgConfidence: number;
+    topCategory: string;
+}
+export interface MemoryAtlasCluster {
+    id: string;
+    label: string;
+    kind: "source" | "category" | "tag";
+    count: number;
+    startAt: number;
+    endAt: number;
+    avgImportance: number;
+    avgConfidence: number;
+    topCategory: string;
+}
+export interface MemoryAtlasWindowCursor {
+    startAt: number;
+    endAt: number;
+    centerAt: number;
+    pageSize: number;
+    hasBefore: boolean;
+    hasAfter: boolean;
+}
+export interface MemoryAtlasResult {
+    totalCount: number;
+    records: MemoryRecord[];
+    buckets: MemoryAtlasBucket[];
+    clusters: MemoryAtlasCluster[];
+    windowCursor: MemoryAtlasWindowCursor | null;
+    timeRange: {
+        startAt: number;
+        endAt: number;
+    } | null;
+}
 export interface SqliteDatabase {
     exec(sql: string): void;
     prepare(sql: string): SqliteStatement;
@@ -89,6 +137,24 @@ export declare class LocalMemoryStore {
      * Get all memories for a user (paginated).
      */
     listByUser(userId: string, page?: number, pageSize?: number, activeOnly?: boolean): MemoryRecord[];
+    /**
+     * Return a windowed atlas payload for large-history visualization.
+     *
+     * `records` are only the interactive window. `buckets` and `clusters` summarize
+     * the whole history so the UI can render distant history as star dust /
+     * aggregate galaxies without loading every memory as an interactive object.
+     */
+    getAtlas(userId: string, options?: {
+        pageSize?: number;
+        windowStartAt?: number;
+        windowEndAt?: number;
+        windowCenterAt?: number;
+        bucketCount?: number;
+        clusterLimit?: number;
+        activeOnly?: boolean;
+    }): MemoryAtlasResult;
+    private getAtlasBuckets;
+    private getAtlasClusters;
     /**
      * Get a single memory by ID.
      */
@@ -97,6 +163,10 @@ export declare class LocalMemoryStore {
      * Update memory text and bump updatedAt.
      */
     updateText(id: string, text: string, embedding?: Float32Array): boolean;
+    /**
+     * Update editable memory fields and bump updatedAt.
+     */
+    update(id: string, input: MemoryUpdateInput): boolean;
     /**
      * Delete a memory by ID.
      */

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

@@ -29,19 +29,13 @@ export declare function createMemoryProvider(config: MemoryProviderFactoryConfig
  * Used by stdio-server to auto-configure memory.
  *
  * Environment variables:
- *   QMEMORY_EMBEDDING_STRATEGY — "auto" | "api" | "onnx" | "none" (default: "none")
- *     - "auto": detect LLM provider → use their embedding API directly
- *   QMEMORY_EMBEDDING_BASE_URL — required when strategy=api
- *   QMEMORY_EMBEDDING_API_KEY  — required when strategy=api
- *   QMEMORY_EMBEDDING_MODEL    — model name (default: "text-embedding-3-small")
- *   QMEMORY_ONNX_MODEL_ID      — model for ONNX (default: "Xenova/bge-small-zh-v1.5")
+ *   QMEMORY_EMBEDDING_TIMEOUT_MS — embedding request timeout (default: 1500)
  *   QMEMORY_USER_PREFIX        — user ID prefix for multi-tenant
  *
- * Auto-cascade (strategy=auto):
- *   Layer 0: LLM provider's embedding API (detected from LLM_PROVIDER + *_API_KEY)
- *   Layer 1: Self-hosted TEI bge-m3 (QMEMORY_TEI_URL / QMEMORY_TEI_FALLBACK_URL)
- *   Layer 2: ONNX local (@xenova/transformers)
- *   Layer 3: FTS5 pure text (NullEmbeddingProvider)
+ * Fixed embedding resolution:
+ *   Layer 0: Explicit ModelRegistry "embedding" binding
+ *   Layer 1: LLM Router default embedding endpoint (BAAI/bge-m3)
+ *   Layer 2: FTS5 pure text (NullEmbeddingProvider)
  *
  * @param projectRoot — Project root for local storage path
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.10.12",
+  "version": "2.10.14",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",
@@ -56,25 +56,23 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "oxlint .",
+    "check:provider-core-boundary": "node scripts/check-provider-core-boundary.mjs",
     "release": "node scripts/release.mjs"
   },
   "engines": {
     "node": ">=22.0.0"
   },
   "dependencies": {
+    "@xiaozhiclaw/provider-core": "^0.1.0",
     "better-sqlite3": "^12.10.0",
     "dotenv": "^17.3.1",
     "nanoid": "^5.1.5",
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0"
   },
-  "optionalDependencies": {
-    "@xenova/transformers": "^2.17.2"
-  },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.15.0",
-    "@qlogic/provider-core": "workspace:*",
     "esbuild": "^0.28.0",
     "tsx": "^4.19.0",
     "typescript": "^5.9.0",

package/dist/types/provider-core/adapters/aliyun-oss-file-upload-adapter.d.ts

@@ -1,44 +0,0 @@
-/**
- * Aliyun OSS File Upload Adapter 鈥?direct upload to Alibaba Cloud OSS.
- *
- * Uploads files directly to OSS bucket using V1 signature (HMAC-SHA1).
- * No external dependencies 鈥?uses Node.js crypto + fetch.
- *
- * This is the **universal fallback adapter** for providers without a native
- * File Upload API (e.g. Anthropic). Ensures ALL file handling goes through
- * upload 鈥?never base64 inline.
- *
- * Environment variables:
- *   OSS_ACCESS_KEY_ID       鈥?Aliyun AccessKey ID
- *   OSS_ACCESS_KEY_SECRET   鈥?Aliyun AccessKey Secret
- *   OSS_BUCKET              鈥?Bucket name (default: "qlogicagent")
- *   OSS_REGION              鈥?Region (default: "cn-beijing")
- *   OSS_ENDPOINT            鈥?Custom endpoint (default: derived from region)
- */
-import type { FileUploadAdapter, FileUploadResult } from "../file-upload-service.js";
-export interface AliyunOSSFileUploadConfig {
-    /** Aliyun AccessKey ID. Required. */
-    accessKeyId: string;
-    /** Aliyun AccessKey Secret. Required. */
-    accessKeySecret: string;
-    /** OSS Bucket name. Default: "qlogicagent". */
-    bucket?: string;
-    /** OSS Region. Default: "cn-beijing". */
-    region?: string;
-    /** Custom OSS endpoint. Default: "{bucket}.oss-{region}.aliyuncs.com". */
-    endpoint?: string;
-    /** Upload path prefix. Default: "media". */
-    pathPrefix?: string;
-    /** Timeout ms. Default: 120_000. */
-    timeoutMs?: number;
-}
-/**
- * Create an AliyunOSSFileUploadAdapter from environment variables.
- * Returns undefined if required env vars (OSS_ACCESS_KEY_ID, OSS_ACCESS_KEY_SECRET) are missing.
- */
-export declare function createAliyunOSSAdapterFromEnv(): AliyunOSSFileUploadAdapter | undefined;
-export declare class AliyunOSSFileUploadAdapter implements FileUploadAdapter {
-    private readonly config;
-    constructor(config: AliyunOSSFileUploadConfig);
-    uploadFile(buffer: Buffer, filename: string, mimeType: string, _apiKey: string, signal?: AbortSignal): Promise<FileUploadResult>;
-}