@clude/sdk 3.2.0 → 3.3.0

package/dist/sdk/cortex-v2.d.ts

@@ -0,0 +1,120 @@
+/**
+ * CLUDE Cortex v2 — The Integration Layer
+ *
+ * Extends the existing Cortex SDK with:
+ * - Cognitive model router (right model for the right task)
+ * - Memory Packs (portable memory bundles for cross-agent sharing)
+ * - Multi-backend support (local SQLite → Supabase → custom)
+ * - Privacy controls (private inference, selective sharing)
+ * - Token metering hooks ($CLUDE gas tracking)
+ *
+ * The 5 P's: Private, Portable, Permissionless, Poly-model, Persistent
+ */
+import { Cortex } from './cortex';
+import type { CortexConfig, MemoryType } from './types';
+export type CognitiveFunction = 'embed' | 'recall' | 'store' | 'consolidate' | 'reflect' | 'emerge' | 'classify' | 'summarize' | 'search';
+export interface ModelRoute {
+    provider: string;
+    model: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+export interface RouterConfig {
+    routes: Partial<Record<CognitiveFunction, ModelRoute>>;
+    fallback: ModelRoute;
+}
+export interface MemoryPack {
+    id: string;
+    name: string;
+    description: string;
+    memories: PackedMemory[];
+    created_at: string;
+    created_by: string;
+    signature?: string;
+    format_version: number;
+}
+export interface PackedMemory {
+    content: string;
+    summary: string;
+    type: MemoryType;
+    importance: number;
+    tags: string[];
+    concepts: string[];
+    created_at: string;
+}
+export type PrivacyLevel = 'private' | 'shared' | 'public';
+export interface PrivacyPolicy {
+    /** Default privacy for new memories */
+    default: PrivacyLevel;
+    /** Types that are always private regardless of default */
+    alwaysPrivate: MemoryType[];
+    /** Whether to use private inference for all LLM calls */
+    privateInference: boolean;
+    /** Whether to encrypt memories at rest */
+    encryptAtRest: boolean;
+}
+export interface MeteringEvent {
+    operation: 'store' | 'recall' | 'dream' | 'export' | 'import';
+    tokens_used: number;
+    memory_count: number;
+    timestamp: string;
+}
+export type MeteringHandler = (event: MeteringEvent) => void | Promise<void>;
+export interface CortexV2Config extends CortexConfig {
+    /** Cognitive model router configuration */
+    router?: Partial<RouterConfig>;
+    /** Privacy policy */
+    privacy?: Partial<PrivacyPolicy>;
+    /** Token metering callback (for $CLUDE gas tracking) */
+    onMeter?: MeteringHandler;
+}
+export declare class CortexV2 extends Cortex {
+    private router;
+    private privacy;
+    private onMeter;
+    private meterLog;
+    constructor(config: CortexV2Config);
+    /** Get the configured model for a cognitive function */
+    getRoute(fn: CognitiveFunction): ModelRoute;
+    /** Update a route at runtime */
+    setRoute(fn: CognitiveFunction, route: ModelRoute): void;
+    /** Export selected memories as a portable pack */
+    exportPack(opts: {
+        name: string;
+        description: string;
+        memoryIds?: number[];
+        types?: MemoryType[];
+        query?: string;
+        limit?: number;
+    }): Promise<MemoryPack>;
+    /** Import a memory pack into this agent's memory */
+    importPack(pack: MemoryPack, opts?: {
+        /** Override importance for imported memories */
+        importanceMultiplier?: number;
+        /** Prefix for imported memory tags */
+        tagPrefix?: string;
+        /** Only import specific types */
+        types?: MemoryType[];
+    }): Promise<{
+        imported: number;
+        skipped: number;
+    }>;
+    /** Serialize a pack to JSON string */
+    serializePack(pack: MemoryPack): string;
+    /** Serialize a pack to Markdown (human-readable) */
+    serializePackMarkdown(pack: MemoryPack): string;
+    /** Parse a pack from JSON string */
+    parsePack(json: string): MemoryPack;
+    /** Get current privacy policy */
+    getPrivacyPolicy(): PrivacyPolicy;
+    /** Update privacy policy */
+    setPrivacyPolicy(policy: Partial<PrivacyPolicy>): void;
+    /** Get all metering events */
+    getMeterLog(): MeteringEvent[];
+    /** Get total operations by type */
+    getMeterSummary(): Record<string, {
+        count: number;
+        totalMemories: number;
+    }>;
+    private meter;
+}

package/dist/sdk/cortex.d.ts

@@ -0,0 +1,63 @@
+import './sdk-mode';
+import type { CortexConfig, DreamOptions, Memory, MemorySummary, MemoryType, StoreMemoryOptions, RecallOptions, MemoryStats } from './types';
+import type { MemoryLinkType } from './shared-constants';
+export declare class Cortex {
+    private config;
+    private db;
+    private http;
+    private hostedMode;
+    private initialized;
+    private dreamActive;
+    constructor(config: CortexConfig);
+    /** Initialize database schema, encryption, and on-chain registry. Call before store/recall. */
+    init(): Promise<void>;
+    /** Store a new memory. Returns memory ID or null. */
+    store(opts: StoreMemoryOptions): Promise<number | null>;
+    /** Recall memories with hybrid vector + keyword + graph scoring. */
+    recall(opts?: RecallOptions): Promise<Memory[]>;
+    /** Recall lightweight summaries (progressive disclosure). */
+    recallSummaries(opts?: RecallOptions): Promise<MemorySummary[]>;
+    /** Hydrate full memory content for specific IDs. */
+    hydrate(ids: number[]): Promise<Memory[]>;
+    /** Apply type-specific memory decay. Self-hosted only. */
+    decay(): Promise<number>;
+    /** Get memory system statistics. */
+    stats(): Promise<MemoryStats>;
+    /** Get recent memories from the last N hours. */
+    recent(hours: number, types?: MemoryType[], limit?: number): Promise<Memory[]>;
+    /** Get current self-model memories. */
+    selfModel(): Promise<Memory[]>;
+    /** Create a typed link between two memories. */
+    link(sourceId: number, targetId: number, type: MemoryLinkType, strength?: number): Promise<void>;
+    /** Run one full dream cycle. Self-hosted only — requires anthropic config. */
+    dream(opts?: DreamOptions): Promise<void>;
+    /** Start cron-based dream schedule. Self-hosted only — requires anthropic config. */
+    startDreamSchedule(): void;
+    /** Stop the dream schedule. */
+    stopDreamSchedule(): void;
+    /** Run a single active reflection (meditation) session. Self-hosted only. */
+    reflect(opts?: {
+        onReflection?: (journal: any) => Promise<void>;
+    }): Promise<any>;
+    /** Start the active reflection (meditation) schedule. Self-hosted only. */
+    startReflectionSchedule(): void;
+    /** Stop the active reflection schedule. */
+    stopReflectionSchedule(): void;
+    /** Score memory importance using LLM. Self-hosted only. */
+    scoreImportance(description: string): Promise<number>;
+    /** Format memories into context string for LLM prompts. Works in both modes. */
+    formatContext(memories: Memory[]): string;
+    /** Infer structured concepts from memory content. Works in both modes. */
+    inferConcepts(summary: string, source: string, tags: string[]): string[];
+    /** Listen for memory events. Self-hosted only. */
+    on(event: 'memory:stored', handler: (payload: {
+        importance: number;
+        memoryType: string;
+    }) => void): void;
+    /** Verify a memory exists in the on-chain registry by its ID. Self-hosted only. */
+    verifyOnChain(memoryId: number): Promise<boolean>;
+    /** Clean up resources and stop schedules. */
+    destroy(): void;
+    private guard;
+    private requireSelfHosted;
+}

package/dist/sdk/http-transport.d.ts

@@ -0,0 +1,14 @@
+/**
+ * HTTP transport for hosted Cortex mode.
+ * Wraps fetch calls with Bearer auth and JSON serialization.
+ */
+export declare class HttpTransport {
+    private baseUrl;
+    private apiKey;
+    constructor(config: {
+        apiKey: string;
+        baseUrl?: string;
+    });
+    post<T>(path: string, body?: Record<string, unknown>): Promise<T>;
+    get<T>(path: string, params?: Record<string, string | undefined>): Promise<T>;
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,4 @@
+export { Cortex } from './cortex';
+export { CortexV2 } from './cortex-v2';
+export type { CortexConfig, DreamOptions, MemoryType, Memory, MemorySummary, StoreMemoryOptions, RecallOptions, MemoryStats, MemoryLinkType, MemoryConcept, } from './types';
+export type { CortexV2Config, CognitiveFunction, ModelRoute, RouterConfig, MemoryPack, PackedMemory, PrivacyLevel, PrivacyPolicy, MeteringEvent, MeteringHandler, } from './cortex-v2';