@dreamingai/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1396 @@
+"use strict";
+// ============================================================
+// Dreaming AI — TypeScript SDK
+//
+// The primary client SDK for Dreaming AI Platform.
+// Used by: TekkoStudio Web, Tekko AI Mobile (Expo), Node.js apps
+//
+// Zero dependencies — uses native fetch API.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DreamingClient = exports.DreamingError = void 0;
+// ─── HTTP Client ─────────────────────────────────────────────
+class HttpClient {
+    constructor(config) {
+        this.baseUrl = (config.baseUrl ?? 'https://api.dreaming.ai').replace(/\/$/, '');
+        this.headers = {
+            'Authorization': `Bearer ${config.apiKey}`,
+            'X-Dreaming-App-Id': config.appId,
+            'Content-Type': 'application/json',
+        };
+        this.timeout = config.timeout ?? 30000;
+    }
+    async request(method, path, body) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const res = await fetch(`${this.baseUrl}${path}`, {
+                method,
+                headers: this.headers,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            if (!res.ok) {
+                const error = await res.json().catch(() => ({ message: res.statusText }));
+                throw new DreamingError(error.code ?? 'API_ERROR', error.message ?? res.statusText, res.status);
+            }
+            return await res.json();
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    get(path) { return this.request('GET', path); }
+    post(path, body) { return this.request('POST', path, body); }
+    patch(path, body) { return this.request('PATCH', path, body); }
+    delete(path) { return this.request('DELETE', path); }
+}
+// ─── Error Class ─────────────────────────────────────────────
+class DreamingError extends Error {
+    constructor(code, message, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = 'DreamingError';
+    }
+}
+exports.DreamingError = DreamingError;
+// ─── Resource Clients ────────────────────────────────────────
+class MemoriesClient {
+    constructor(http) {
+        this.http = http;
+    }
+    async create(input) {
+        return this.http.post('/v1/memories', input);
+    }
+    async list(userId, options) {
+        const params = new URLSearchParams({ userId });
+        if (options?.limit)
+            params.set('limit', String(options.limit));
+        if (options?.offset)
+            params.set('offset', String(options.offset));
+        if (options?.types)
+            params.set('types', options.types.join(','));
+        return this.http.get(`/v1/memories?${params}`);
+    }
+    async get(id) {
+        return this.http.get(`/v1/memories/${id}`);
+    }
+    async delete(id) {
+        return this.http.delete(`/v1/memories/${id}`);
+    }
+    async search(input) {
+        return this.http.post('/v1/memories/search', input);
+    }
+    async recall(input) {
+        return this.http.post('/v1/memories/recall', input);
+    }
+}
+class DreamingApiClient {
+    constructor(http) {
+        this.http = http;
+    }
+    async process(input) {
+        return this.http.post('/v1/dreaming/process', input);
+    }
+    async consolidate(userId) {
+        return this.http.post('/v1/dreaming/consolidate', { userId });
+    }
+    async getInsights(userId, limit) {
+        const params = new URLSearchParams({ userId });
+        if (limit)
+            params.set('limit', String(limit));
+        return this.http.get(`/v1/dreaming/insights?${params}`);
+    }
+    async getStatus() {
+        return this.http.get('/v1/dreaming/status');
+    }
+}
+class GraphClient {
+    constructor(http) {
+        this.http = http;
+    }
+    async addEntity(userId, name, entityType, properties) {
+        return this.http.post('/v1/graph/entities', { userId, name, entityType, properties });
+    }
+    async addTriple(userId, subject, predicate, object, options) {
+        return this.http.post('/v1/graph/triples', { userId, subject, predicate, object, ...options });
+    }
+    async query(userId, options) {
+        return this.http.post('/v1/graph/query', { userId, ...options });
+    }
+    async getEntityFacts(userId, entityName) {
+        return this.http.get(`/v1/graph/entities/${encodeURIComponent(entityName)}/facts?userId=${userId}`);
+    }
+}
+class PersonalityClient {
+    constructor(http) {
+        this.http = http;
+    }
+    async getOcean(userId) {
+        return this.http.get(`/v1/personality/ocean?userId=${userId}`);
+    }
+    async analyzeOcean(userId, text) {
+        return this.http.post('/v1/personality/analyze', { userId, text });
+    }
+    async getFingerprint(userId) {
+        return this.http.get(`/v1/personality/fingerprint?userId=${userId}`);
+    }
+}
+// ─── Status Client ───────────────────────────────────────────
+class StatusClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Get current AI cognitive state (for orb rendering) */
+    async getStatus(userId) {
+        const params = userId ? `?userId=${userId}` : '';
+        return this.http.get(`/v1/status${params}`);
+    }
+    /** Get detailed brain health metrics (for settings page) */
+    async getBrainHealth(userId) {
+        const params = userId ? `?userId=${userId}` : '';
+        return this.http.get(`/v1/status/brain${params}`);
+    }
+    /** Get quota usage and limits */
+    async getQuota(userId) {
+        const params = userId ? `?userId=${userId}` : '';
+        const res = await this.http.get(`/v1/admin/quota${params}`);
+        return res.data || res;
+    }
+}
+// ─── Sync Client ─────────────────────────────────────────────
+class SyncClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Get user's global sync settings */
+    async getSettings(userId) {
+        const params = userId ? `?userId=${userId}` : '';
+        const res = await this.http.get(`/v1/sync/settings${params}`);
+        return res.data || res;
+    }
+    /** Update sync settings (global toggle + category toggles) */
+    async updateSettings(input) {
+        const res = await this.http.post('/v1/sync/settings', input);
+        return res.data || res;
+    }
+    /** Get consent status for all partner workspaces */
+    async getConsents(userId, appId) {
+        const params = new URLSearchParams();
+        if (userId)
+            params.set('userId', userId);
+        if (appId)
+            params.set('appId', appId);
+        const res = await this.http.get(`/v1/sync/consent?${params}`);
+        return res.data?.workspaces || [];
+    }
+    /** Accept, pause, resume, or decline sync with a target workspace */
+    async updateConsent(input) {
+        const res = await this.http.post('/v1/sync/consent', {
+            target_workspace_id: input.targetWorkspaceId,
+            action: input.action,
+            userId: input.userId,
+            domain: input.domain,
+            name: input.name,
+        });
+        return res.data || res;
+    }
+    /** Get privacy exposure toggles */
+    async getExposure(userId, appId) {
+        const params = new URLSearchParams();
+        if (userId)
+            params.set('userId', userId);
+        if (appId)
+            params.set('appId', appId);
+        const res = await this.http.get(`/v1/privacy/exposure?${params}`);
+        return res.data || res;
+    }
+    /** Update privacy exposure toggles */
+    async updateExposure(toggles, userId) {
+        const res = await this.http.post('/v1/privacy/exposure', {
+            toggles, userId,
+        });
+        return res.data?.toggles || res.data || toggles;
+    }
+}
+// ─── Context Client ──────────────────────────────────────────
+class ContextClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Get pre-built context string for injection into LLM prompts */
+    async getContext(userId) {
+        return this.http.get(`/v1/memories/recall?userId=${userId}&limit=10`);
+    }
+    /** Before-chat hook: enrich messages with context (for non-middleware integrations) */
+    async beforeChat(input) {
+        const res = await this.http.post('/v1/dreaming/process', {
+            userId: input.userId,
+            conversation: input.messages,
+        });
+        return res.messages || input.messages;
+    }
+    /** After-chat hook: queue conversation for sleeptime processing */
+    async afterChat(input) {
+        return this.http.post('/v1/dreaming/process', {
+            userId: input.userId,
+            conversation: input.messages,
+        });
+    }
+}
+const TIER_COLORS = {
+    efficient: '#22c55e', // green-500
+    smart: '#3b82f6', // blue-500
+    genius: '#a855f7', // purple-500
+};
+const TIER_ORDER = ['efficient', 'smart', 'genius'];
+class MeterClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Get current model tier status for the authenticated user */
+    async getStatus(userId) {
+        const params = userId ? `?userId=${userId}` : '';
+        const res = await this.http.get(`/v1/meter/status${params}`);
+        return res.data || res;
+    }
+    /** Get detailed usage history */
+    async getUsage(userId, options) {
+        const params = new URLSearchParams({ userId });
+        if (options?.days)
+            params.set('days', String(options.days));
+        if (options?.limit)
+            params.set('limit', String(options.limit));
+        const res = await this.http.get(`/v1/meter/usage?${params}`);
+        return res.data || res;
+    }
+    /**
+     * Get a ready-to-use UI badge for displaying the AI tier.
+     * Partners can drop this directly into their app UI.
+     *
+     * @example
+     * ```tsx
+     * const badge = await dreaming.meter.getBadge('user-123');
+     * return (
+     *   <div style={{ background: badge.color, borderRadius: 12, padding: '4px 12px' }}>
+     *     {badge.icon} {badge.label}
+     *   </div>
+     * );
+     * ```
+     */
+    async getBadge(userId) {
+        const status = await this.getStatus(userId);
+        const tier = status.modelTier;
+        const tierIndex = TIER_ORDER.indexOf(tier);
+        const canUpgrade = tierIndex < TIER_ORDER.length - 1;
+        const nextTier = canUpgrade ? TIER_ORDER[tierIndex + 1] : undefined;
+        const nextTierName = nextTier
+            ? status.availableTiers.find(t => t.key === nextTier)?.name
+            : undefined;
+        return {
+            tier,
+            icon: status.modelTierIcon,
+            label: `${status.modelTierName} AI`,
+            color: TIER_COLORS[tier] || '#6b7280',
+            description: status.modelTierDescription,
+            model: status.primaryModel,
+            canUpgrade,
+            nextTier: nextTierName,
+            upgradeMessage: canUpgrade
+                ? `Upgrade to ${nextTierName} AI for smarter, deeper insights powered by ${status.availableTiers.find(t => t.key === nextTier)?.primaryModel || 'a premium model'}.`
+                : undefined,
+        };
+    }
+    /** Quick check: is this user on the highest AI tier? */
+    async isGeniusTier(userId) {
+        const status = await this.getStatus(userId);
+        return status.modelTier === 'genius';
+    }
+    /** Quick check: can this user upgrade to a better AI tier? */
+    async canUpgrade(userId) {
+        const status = await this.getStatus(userId);
+        const tierIndex = TIER_ORDER.indexOf(status.modelTier);
+        return tierIndex < TIER_ORDER.length - 1;
+    }
+    /**
+     * Get a formatted usage summary string for dashboards.
+     *
+     * @example
+     * ```
+     * "🔵 Smart AI — 45 calls, 12.5k tokens this month (avg 230ms)"
+     * ```
+     */
+    async getUsageSummary(userId) {
+        const status = await this.getStatus(userId);
+        const u = status.usage;
+        const tokens = u.tokensThisMonth >= 1000
+            ? `${(u.tokensThisMonth / 1000).toFixed(1)}k`
+            : String(u.tokensThisMonth);
+        return `${status.modelTierIcon} ${status.modelTierName} AI — ${u.callsThisMonth} calls, ${tokens} tokens this month (avg ${u.avgLatencyMs}ms)`;
+    }
+}
+// ─── Main Client ─────────────────────────────────────────────
+class DreamingClient {
+    constructor(config) {
+        const http = new HttpClient(config);
+        this.memories = new MemoriesClient(http);
+        this.dreaming = new DreamingApiClient(http);
+        this.graph = new GraphClient(http);
+        this.personality = new PersonalityClient(http);
+        this.status = new StatusClient(http);
+        this.sync = new SyncClient(http);
+        this.context = new ContextClient(http);
+        this.meter = new MeterClient(http);
+        this.activities = new ActivityClient(http, config);
+        this.constraints = new ConstraintClient(http);
+        this.chat = new ChatClient(http);
+        this.knowledge = new KnowledgeClient(http);
+        this.web = new WebClient(http);
+        this.identity = new IdentityClient(http);
+        this.friends = new FriendsClient(http);
+        this.proactive = new ProactiveClient(http);
+        this.notifications = new NotificationsClient(http);
+        this.evolution = new EvolutionClient(http);
+        this.dna = new DnaClient(http);
+        this.partnerTokens = new PartnerTokensClient(http);
+    }
+    /**
+     * Flush any buffered activity events before shutdown.
+     * Call this in your app's cleanup/beforeunload handler.
+     */
+    async flush() {
+        await this.activities.flush();
+    }
+}
+exports.DreamingClient = DreamingClient;
+class KnowledgeClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Upload a document to the knowledge base.
+     * Supports: text, markdown, CSV, JSON, HTML, URL, base64, PDF.
+     * Auto-detects format from filename/content if sourceType is 'auto' or omitted.
+     *
+     * @example
+     * ```typescript
+     * // Upload markdown
+     * await dreaming.knowledge.upload({
+     *   appId: 'my-app',
+     *   title: 'Training Guide',
+     *   content: '# Running Tips\n\nStart slow...',
+     * });
+     *
+     * // Upload CSV data
+     * await dreaming.knowledge.upload({
+     *   appId: 'my-app',
+     *   title: 'Workout Log',
+     *   content: 'date,distance,time\n2024-01-01,5km,28min',
+     *   sourceType: 'csv',
+     * });
+     *
+     * // Upload with constraint auto-linking
+     * await dreaming.knowledge.upload({
+     *   appId: 'my-app',
+     *   userId: 'user-1',
+     *   title: 'Fitness Plan',
+     *   content: pdfBase64,
+     *   sourceType: 'base64',
+     *   feedConstraints: true,  // Auto-creates tags from content
+     * });
+     * ```
+     */
+    async upload(options) {
+        const res = await this.http.post('/v1/knowledge/upload', options);
+        return res.data;
+    }
+    /**
+     * Upload content from a URL. Fetches and parses automatically.
+     *
+     * @example
+     * ```typescript
+     * await dreaming.knowledge.uploadUrl({
+     *   appId: 'my-app',
+     *   title: 'Running Tips Article',
+     *   url: 'https://example.com/running-tips',
+     * });
+     * ```
+     */
+    async uploadUrl(options) {
+        return this.upload({
+            appId: options.appId,
+            title: options.title,
+            content: options.url,
+            sourceType: 'url',
+            sourceUrl: options.url,
+            moduleId: options.moduleId,
+            userId: options.userId,
+        });
+    }
+    /** List uploaded documents. */
+    async listDocs(options) {
+        const params = new URLSearchParams();
+        if (options?.appId)
+            params.set('appId', options.appId);
+        if (options?.moduleId)
+            params.set('moduleId', options.moduleId);
+        const res = await this.http.get(`/v1/knowledge/docs?${params}`);
+        return res.data;
+    }
+    /** Get document details. */
+    async getDoc(docId) {
+        const res = await this.http.get(`/v1/knowledge/docs/${docId}`);
+        return res.data;
+    }
+    /** View chunks of a document. */
+    async getChunks(docId) {
+        const res = await this.http.get(`/v1/knowledge/docs/${docId}/chunks`);
+        return res.data;
+    }
+    /**
+     * Search knowledge base with semantic + keyword fallback.
+     *
+     * @example
+     * ```typescript
+     * const results = await dreaming.knowledge.search('running tips', {
+     *   appId: 'active365',
+     *   limit: 5,
+     *   domain: 'fitness',
+     * });
+     * ```
+     */
+    async search(query, options) {
+        const params = new URLSearchParams({ appId: options.appId, q: query });
+        if (options.domain)
+            params.set('domain', options.domain);
+        if (options.limit)
+            params.set('limit', String(options.limit));
+        const res = await this.http.get(`/v1/knowledge/search?${params}`);
+        return res.data;
+    }
+    /** Delete a document and all its chunks. */
+    async deleteDoc(docId) {
+        await this.http.delete(`/v1/knowledge/docs/${docId}`);
+    }
+    /**
+     * Enable or disable a document (soft toggle).
+     * Disabled docs are excluded from search and chat context.
+     */
+    async toggleDoc(docId, enabled) {
+        await this.http.patch(`/v1/knowledge/docs/${docId}/toggle`, { enabled });
+    }
+    /**
+     * List knowledge modules with doc/chunk counts.
+     *
+     * @example
+     * ```typescript
+     * const modules = await dreaming.knowledge.listModules('active365');
+     * // [{ module_id: 'fitness-guides', enabled: true, doc_count: 3, chunk_count: 45 }]
+     * ```
+     */
+    async listModules(appId) {
+        const res = await this.http.get(`/v1/knowledge/modules?appId=${appId}`);
+        return res.data;
+    }
+    /**
+     * Enable or disable an entire knowledge module.
+     * All docs in a disabled module are excluded from search.
+     */
+    async toggleModule(moduleId, options) {
+        await this.http.patch(`/v1/knowledge/modules/${moduleId}/toggle`, options);
+    }
+    /**
+     * Re-chunk a document with different settings.
+     */
+    async reprocess(docId, options) {
+        const res = await this.http.post(`/v1/knowledge/reprocess/${docId}`, options || {});
+        return res.data;
+    }
+}
+class ChatClient {
+    constructor(http) {
+        this.http = http;
+    }
+    // ─── Core: Enrich + Learn ─────────────────────────────────
+    /**
+     * BEFORE your LLM call: get memory/personality/goal context.
+     *
+     * Returns messages you inject into your conversation.
+     * Default format is OpenAI-compatible.
+     *
+     * @example
+     * ```typescript
+     * const ctx = await dreaming.chat.enrich('user-1', 'How should I train today?');
+     *
+     * // Inject into your OpenAI call:
+     * const response = await openai.chat.completions.create({
+     *   model: 'gpt-4o',
+     *   messages: [...ctx.messages, ...yourConversation],
+     * });
+     * ```
+     */
+    async enrich(userId, query, options) {
+        const res = await this.http.post('/v1/chat/context', {
+            userId,
+            query,
+            maxMemories: options?.maxMemories,
+            includePersonality: options?.includePersonality,
+            includeConstraints: options?.includeConstraints,
+            includeKnowledge: options?.includeKnowledge,
+            webGrounding: options?.webGrounding,
+            format: options?.format || 'openai',
+        });
+        return res.data;
+    }
+    /**
+     * AFTER your LLM responds: tell Dreaming to extract memories.
+     *
+     * This queues background tasks: memory extraction, entity detection,
+     * insight generation (goal-aware), and personality evolution.
+     *
+     * @example
+     * ```typescript
+     * await dreaming.chat.learn('user-1', userMessage, aiResponse);
+     * ```
+     */
+    async learn(userId, userMessage, aiResponse, options) {
+        const res = await this.http.post('/v1/chat/learn', {
+            userId,
+            userMessage,
+            aiResponse,
+            metadata: options?.metadata,
+        });
+        return res.data;
+    }
+    /**
+     * Full conversation version of learn.
+     */
+    async learnFromMessages(userId, messages, options) {
+        const res = await this.http.post('/v1/chat/learn', {
+            userId,
+            messages,
+            metadata: options?.metadata,
+        });
+        return res.data;
+    }
+    // ─── One-Line Wrappers ────────────────────────────────────
+    /**
+     * Wrap an OpenAI client call. Memory + personality + goals, one line.
+     *
+     * @example
+     * ```typescript
+     * import OpenAI from 'openai';
+     * const openai = new OpenAI();
+     * const dreaming = new DreamingClient({ ... });
+     *
+     * // This one line gives your GPT memory, personality, and goals:
+     * const reply = await dreaming.chat.wrapOpenAI(openai, 'user-1', [
+     *   { role: 'user', content: 'How should I train today?' }
+     * ], { model: 'gpt-4o' });
+     *
+     * console.log(reply); // Goal-aware, memory-enriched response
+     * ```
+     */
+    async wrapOpenAI(openai, userId, messages, options) {
+        // 1. Enrich with context
+        const lastUser = [...messages].reverse().find(m => m.role === 'user')?.content || '';
+        const ctx = await this.enrich(userId, lastUser, { format: 'openai' });
+        // 2. Call OpenAI with enriched messages
+        const enrichedMessages = [...ctx.messages, ...messages];
+        const completion = await openai.chat.completions.create({
+            model: options?.model || 'gpt-4o-mini',
+            messages: enrichedMessages,
+            temperature: options?.temperature,
+            max_tokens: options?.maxTokens,
+        });
+        const aiResponse = completion.choices?.[0]?.message?.content || '';
+        // 3. Learn from the conversation (non-blocking)
+        this.learn(userId, lastUser, aiResponse).catch(() => { });
+        return aiResponse;
+    }
+    /**
+     * Wrap a Google Gemini call. Memory + personality + goals, one line.
+     *
+     * @example
+     * ```typescript
+     * import { GoogleGenerativeAI } from '@google/generative-ai';
+     * const genAI = new GoogleGenerativeAI('YOUR_API_KEY');
+     * const dreaming = new DreamingClient({ ... });
+     *
+     * const reply = await dreaming.chat.wrapGemini(genAI, 'user-1',
+     *   'How should I train today?',
+     *   { model: 'gemini-2.0-flash' }
+     * );
+     * ```
+     */
+    async wrapGemini(genAI, userId, userMessage, options) {
+        // 1. Enrich
+        const ctx = await this.enrich(userId, userMessage, { format: 'raw' });
+        // 2. Call Gemini
+        const model = genAI.getGenerativeModel({ model: options?.model || 'gemini-2.0-flash' });
+        const chat = model.startChat({
+            history: options?.history || [],
+            systemInstruction: ctx.system || ctx.systemPrompt || '',
+        });
+        const result = await chat.sendMessage(userMessage);
+        const aiResponse = result.response.text();
+        // 3. Learn (non-blocking)
+        this.learn(userId, userMessage, aiResponse).catch(() => { });
+        return aiResponse;
+    }
+    /**
+     * Wrap an Anthropic Claude call. Memory + personality + goals, one line.
+     *
+     * @example
+     * ```typescript
+     * import Anthropic from '@anthropic-ai/sdk';
+     * const anthropic = new Anthropic();
+     * const dreaming = new DreamingClient({ ... });
+     *
+     * const reply = await dreaming.chat.wrapAnthropic(anthropic, 'user-1', [
+     *   { role: 'user', content: 'How should I train today?' }
+     * ], { model: 'claude-sonnet-4-20250514' });
+     * ```
+     */
+    async wrapAnthropic(anthropic, userId, messages, options) {
+        // 1. Enrich (Anthropic format: system is separate)
+        const lastUser = [...messages].reverse().find(m => m.role === 'user')?.content || '';
+        const ctx = await this.enrich(userId, lastUser, { format: 'anthropic' });
+        // 2. Call Anthropic
+        const response = await anthropic.messages.create({
+            model: options?.model || 'claude-sonnet-4-20250514',
+            max_tokens: options?.maxTokens || 1024,
+            system: ctx.system || '',
+            messages,
+        });
+        const aiResponse = response.content?.[0]?.text || '';
+        // 3. Learn (non-blocking)
+        this.learn(userId, lastUser, aiResponse).catch(() => { });
+        return aiResponse;
+    }
+    /**
+     * Generic wrapper for any LLM. You provide the call function.
+     *
+     * @example
+     * ```typescript
+     * const reply = await dreaming.chat.wrap(
+     *   'user-1',
+     *   'How should I train today?',
+     *   async (systemPrompt, userMsg) => {
+     *     // Call your LLM however you want
+     *     return await myCustomLLM.generate(systemPrompt + '\n' + userMsg);
+     *   }
+     * );
+     * ```
+     */
+    async wrap(userId, userMessage, llmCall, options) {
+        // 1. Enrich
+        const ctx = await this.enrich(userId, userMessage, { ...options, format: 'raw' });
+        const systemPrompt = ctx.systemPrompt || ctx.system || '';
+        // 2. Call their LLM
+        const aiResponse = await llmCall(systemPrompt, userMessage);
+        // 3. Learn (non-blocking)
+        this.learn(userId, userMessage, aiResponse).catch(() => { });
+        return aiResponse;
+    }
+}
+class ConstraintClient {
+    constructor(http) {
+        this.http = http;
+    }
+    // ─── Goals & Constraints ──────────────────────────────────
+    /**
+     * Create a goal, sub-goal, task, checkpoint, or achievement.
+     *
+     * @example
+     * ```typescript
+     * await dreaming.constraints.setGoal('user-1', 'Run 5K under 25min', {
+     *   category: 'fitness', weight: 90,
+     *   targetValue: 25, unit: 'min',
+     *   deadline: '2026-06-01',
+     *   tags: ['running', 'cardio'],
+     * });
+     * ```
+     */
+    async setGoal(userId, title, options) {
+        const res = await this.http.post('/v1/constraints', {
+            userId,
+            title,
+            constraintType: options?.type || 'goal',
+            parentId: options?.parentId,
+            description: options?.description,
+            weight: options?.weight,
+            priority: options?.priority,
+            category: options?.category,
+            domain: options?.domain,
+            targetValue: options?.targetValue,
+            unit: options?.unit,
+            deadline: options?.deadline,
+            pinned: options?.pinned,
+            tags: options?.tags,
+            metadata: options?.metadata,
+        });
+        return res.data;
+    }
+    /** Create a sub-goal under a parent goal */
+    async addSubGoal(userId, parentId, title, options) {
+        return this.setGoal(userId, title, { ...options, type: 'sub_goal', parentId });
+    }
+    /** Create a task under a goal or sub-goal */
+    async addTask(userId, parentId, title, options) {
+        return this.setGoal(userId, title, { ...options, type: 'task', parentId });
+    }
+    /** Create a checkpoint (milestone) */
+    async addCheckpoint(userId, parentId, title, options) {
+        return this.setGoal(userId, title, { ...options, type: 'checkpoint', parentId });
+    }
+    /** Record an achievement */
+    async addAchievement(userId, title, options) {
+        return this.setGoal(userId, title, { ...options, type: 'achievement' });
+    }
+    /**
+     * List constraints with optional filters.
+     */
+    async list(userId, options) {
+        const params = new URLSearchParams({ userId });
+        if (options?.type)
+            params.set('type', options.type);
+        if (options?.status)
+            params.set('status', options.status);
+        if (options?.category)
+            params.set('category', options.category);
+        if (options?.parentId)
+            params.set('parentId', options.parentId);
+        if (options?.pinned)
+            params.set('pinned', 'true');
+        const res = await this.http.get(`/v1/constraints?${params}`);
+        return res.data;
+    }
+    /**
+     * Update a constraint's weight, status, progress, or other fields.
+     *
+     * @example
+     * ```typescript
+     * // Update progress
+     * await dreaming.constraints.update(goalId, { progress: 75 });
+     *
+     * // Change weight (influences how much AI focuses on this)
+     * await dreaming.constraints.update(goalId, { weight: 30 });
+     *
+     * // Complete a goal
+     * await dreaming.constraints.update(goalId, { status: 'completed' });
+     * ```
+     */
+    async update(constraintId, updates) {
+        const res = await this.http.patch(`/v1/constraints/${constraintId}`, updates);
+        return res.data;
+    }
+    /** Complete a constraint */
+    async complete(constraintId) {
+        return this.update(constraintId, { status: 'completed' });
+    }
+    /** Cancel a constraint */
+    async cancel(constraintId, reason) {
+        return this.update(constraintId, { status: 'cancelled', reason });
+    }
+    /** Pause a constraint (keeps weight but AI won't actively suggest) */
+    async pause(constraintId) {
+        return this.update(constraintId, { status: 'paused' });
+    }
+    /** Resume a paused constraint */
+    async resume(constraintId) {
+        return this.update(constraintId, { status: 'active' });
+    }
+    /** Pin a constraint (locks it from fading) */
+    async pin(constraintId) {
+        return this.update(constraintId, { pinned: true });
+    }
+    /** Unpin a constraint */
+    async unpin(constraintId) {
+        return this.update(constraintId, { pinned: false });
+    }
+    /** Set the weight (0-100) — how much the AI focuses on this */
+    async setWeight(constraintId, weight, reason) {
+        return this.update(constraintId, { weight: Math.min(Math.max(weight, 0), 100), reason });
+    }
+    /** Delete a constraint (soft delete) */
+    async delete(constraintId) {
+        await this.http.delete(`/v1/constraints/${constraintId}`);
+    }
+    /** Get change history for a constraint */
+    async getHistory(constraintId) {
+        const res = await this.http.get(`/v1/constraints/${constraintId}/history`);
+        return res.data;
+    }
+    // ─── Tags ─────────────────────────────────────────────────
+    /**
+     * Create or update a focus tag.
+     *
+     * @example
+     * ```typescript
+     * await dreaming.constraints.addTag('user-1', 'mindfulness', {
+     *   category: 'wellness', weight: 70, pinned: true,
+     * });
+     * ```
+     */
+    async addTag(userId, tagKey, options) {
+        const res = await this.http.post('/v1/constraints/tags', {
+            userId,
+            tagKey,
+            label: options?.label || tagKey,
+            category: options?.category,
+            weight: options?.weight,
+            pinned: options?.pinned,
+            source: 'user',
+            birthReason: options?.birthReason,
+        });
+        return res.data;
+    }
+    /** List tags */
+    async listTags(userId, options) {
+        const params = new URLSearchParams({ userId });
+        if (options?.status)
+            params.set('status', options.status);
+        if (options?.category)
+            params.set('category', options.category);
+        if (options?.pinned)
+            params.set('pinned', 'true');
+        const res = await this.http.get(`/v1/constraints/tags?${params}`);
+        return res.data;
+    }
+    /** Update a tag (weight, pin, category) */
+    async updateTag(tagId, updates) {
+        const res = await this.http.patch(`/v1/constraints/tags/${tagId}`, updates);
+        return res.data;
+    }
+    /** Pin a tag */
+    async pinTag(tagId) {
+        return this.updateTag(tagId, { pinned: true });
+    }
+    /** Set tag weight */
+    async setTagWeight(tagId, weight) {
+        return this.updateTag(tagId, { weight: Math.min(Math.max(weight, 0), 100) });
+    }
+    // ─── Context ──────────────────────────────────────────────
+    /**
+     * Get the weighted constraint context that the AI uses.
+     * Shows exactly how constraints + tags influence dreaming.
+     */
+    async getContext(userId) {
+        const res = await this.http.get(`/v1/constraints/context?userId=${userId}`);
+        return res.data;
+    }
+}
+class ActivityClient {
+    constructor(http, config) {
+        this.http = http;
+        this.buffer = [];
+        this.flushTimer = null;
+        this.isFlushing = false;
+        const bufConfig = config.activityBuffer ?? {};
+        this.bufferSize = bufConfig.bufferSize ?? 20;
+        this.sessionId = `ses_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        if (!bufConfig.disableAutoFlush) {
+            const interval = bufConfig.flushIntervalMs ?? 5000;
+            this.flushTimer = setInterval(() => this.flush().catch(() => { }), interval);
+        }
+    }
+    /**
+     * Track a user activity event — SYNCHRONOUS, zero overhead.
+     * Events are queued locally and flushed as a batch automatically.
+     *
+     * @example
+     * ```typescript
+     * // Track a screen view
+     * dreaming.activities.track('user-123', 'screen_view', 'Dashboard');
+     *
+     * // Track a feature interaction with data
+     * dreaming.activities.track('user-123', 'feature_use', 'AIChat', {
+     *   domain: 'productivity',
+     *   data: { messageCount: 5, topic: 'project planning' },
+     *   durationMs: 45000,
+     * });
+     *
+     * // Track a button click
+     * dreaming.activities.track('user-123', 'button_click', 'UpgradeToProBtn', {
+     *   domain: 'billing',
+     * });
+     * ```
+     */
+    track(userId, activityType, activityName, options) {
+        this.buffer.push({
+            userId,
+            activityType,
+            activityName,
+            domain: options?.domain,
+            data: options?.data,
+            durationMs: options?.durationMs,
+            sessionId: options?.sessionId ?? this.sessionId,
+        });
+        // Auto-flush when buffer is full
+        if (this.buffer.length >= this.bufferSize) {
+            this.flush().catch(() => { });
+        }
+    }
+    /**
+     * Flush buffered events to the server.
+     * Called automatically by the timer/buffer-full, but you can call manually.
+     */
+    async flush() {
+        if (this.buffer.length === 0 || this.isFlushing)
+            return 0;
+        this.isFlushing = true;
+        // Take the current buffer and clear it
+        const events = [...this.buffer];
+        this.buffer = [];
+        try {
+            const res = await this.http.post('/v1/activities/batch', {
+                events,
+            });
+            return res.data?.inserted ?? events.length;
+        }
+        catch {
+            // Put events back on failure (will retry on next flush)
+            this.buffer.unshift(...events);
+            return 0;
+        }
+        finally {
+            this.isFlushing = false;
+        }
+    }
+    /**
+     * Query activity history for a user.
+     */
+    async getHistory(userId, options) {
+        const params = new URLSearchParams({ userId });
+        if (options?.type)
+            params.set('type', options.type);
+        if (options?.domain)
+            params.set('domain', options.domain);
+        if (options?.days)
+            params.set('days', String(options.days));
+        if (options?.limit)
+            params.set('limit', String(options.limit));
+        return this.http.get(`/v1/activities?${params}`);
+    }
+    /** Get the current auto-generated session ID */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /** Start a new session (generates a new session ID) */
+    newSession() {
+        this.sessionId = `ses_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        return this.sessionId;
+    }
+    /** Get the number of buffered (unflushed) events */
+    get pendingCount() {
+        return this.buffer.length;
+    }
+    /** Stop the auto-flush timer (call before app shutdown after flush) */
+    destroy() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+}
+class WebClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Search the web. Respects DNA guardrails (must be enabled for the app).
+     * Results are cached for 24h.
+     *
+     * @example
+     * ```typescript
+     * const results = await dreaming.web.search('5K running tips', {
+     *   appId: 'active365',
+     *   limit: 5,
+     * });
+     * ```
+     */
+    async search(query, options) {
+        const res = await this.http.post('/v1/web/search', { query, ...options });
+        return res.data.results;
+    }
+    /**
+     * Search and return formatted system prompt (for direct LLM injection).
+     */
+    async searchForPrompt(query, appId) {
+        const res = await this.http.post('/v1/web/search', { query, appId, format: 'prompt', limit: 3 });
+        return res.data.contextPrompt || '';
+    }
+    /** Crawl a specific URL for content. */
+    async crawl(url, appId) {
+        try {
+            const res = await this.http.post('/v1/web/crawl', { url, appId });
+            return res.data;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Get the web access policy for an app. */
+    async getPolicy(appId) {
+        const res = await this.http.get(`/v1/web/policy?appId=${appId}`);
+        return res.data;
+    }
+    /**
+     * Update web access policy.
+     *
+     * @example
+     * ```typescript
+     * await dreaming.web.updatePolicy('active365', {
+     *   enabled: true,
+     *   maxDailySearches: 100,
+     *   blockedDomains: ['facebook.com'],
+     * });
+     * ```
+     */
+    async updatePolicy(appId, policy) {
+        const res = await this.http.post('/v1/web/policy', { appId, ...policy });
+        return res.data;
+    }
+    /** Get daily web usage stats for budget monitoring. */
+    async getUsage(appId, date) {
+        const params = date ? `appId=${appId}&date=${date}` : `appId=${appId}`;
+        const res = await this.http.get(`/v1/web/usage?${params}`);
+        return res.data;
+    }
+    /** Get user dreaming settings (all toggles). */
+    async getSettings(userId, appId) {
+        const params = appId ? `userId=${userId}&appId=${appId}` : `userId=${userId}`;
+        const res = await this.http.get(`/v1/web/settings?${params}`);
+        return res.data;
+    }
+    /** Update user dreaming settings (toggle features on/off). */
+    async updateSettings(userId, settings, appId) {
+        const res = await this.http.post('/v1/web/settings', {
+            userId,
+            appId: appId || 'default',
+            ...settings,
+        });
+        return res.data;
+    }
+}
+class IdentityClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Get user identity (names, AI name, sync status). */
+    async get(userId, appId) {
+        const params = appId ? `userId=${userId}&appId=${appId}` : `userId=${userId}`;
+        const res = await this.http.get(`/v1/identity?${params}`);
+        return res.data;
+    }
+    /** Update user identity (display name, preferred name, etc). */
+    async update(userId, appId, updates) {
+        const res = await this.http.post('/v1/identity', { userId, appId, ...updates });
+        return res.data;
+    }
+    /** Get the effective AI name for this user in this app. */
+    async getAiName(userId, appId) {
+        const params = appId ? `userId=${userId}&appId=${appId}` : `userId=${userId}`;
+        const res = await this.http.get(`/v1/identity/ai-name?${params}`);
+        return res.data.aiName;
+    }
+    /** Set a custom AI name (user-chosen or partner default). */
+    async setAiName(userId, appId, aiName, isPartnerDefault = false) {
+        const res = await this.http.post('/v1/identity/ai-name', {
+            userId, appId, aiName, isPartnerDefault,
+        });
+        return res.data.aiName;
+    }
+    /** Get people the user knows (family, friends, colleagues). */
+    async getSocialCircle(userId, appId, relationship) {
+        let params = `userId=${userId}`;
+        if (appId)
+            params += `&appId=${appId}`;
+        if (relationship)
+            params += `&relationship=${relationship}`;
+        const res = await this.http.get(`/v1/identity/social?${params}`);
+        return res.data;
+    }
+    /** Add a person to the user's social circle. */
+    async addPerson(userId, appId, person) {
+        const res = await this.http.post('/v1/identity/social', {
+            userId, appId, ...person,
+        });
+        return res.data;
+    }
+    /** Sync identity from HQ to a partner app. */
+    async syncFromHq(userId, appId) {
+        const res = await this.http.post('/v1/identity/sync', { userId, appId });
+        return res.data;
+    }
+}
+class FriendsClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Send a friend request. */
+    async request(userId, friendUserId, options) {
+        const res = await this.http.post('/v1/friends/request', {
+            userId, friendUserId, ...options,
+        });
+        return res.data;
+    }
+    /** Accept a friend connection. */
+    async accept(connectionId, options) {
+        const res = await this.http.post(`/v1/friends/accept/${connectionId}`, options || {});
+        return res.data;
+    }
+    /** Reject or block a connection. */
+    async reject(connectionId, block = false) {
+        await this.http.post(`/v1/friends/reject/${connectionId}`, { block });
+    }
+    /** List all connections for a user. */
+    async list(userId) {
+        const res = await this.http.get(`/v1/friends?userId=${userId}`);
+        return res.data;
+    }
+    /** Get connection details. */
+    async get(connectionId) {
+        const res = await this.http.get(`/v1/friends/${connectionId}`);
+        return res.data;
+    }
+    /** Trigger an AI-to-AI exchange. */
+    async exchange(connectionId, topic, maxRounds) {
+        const res = await this.http.post(`/v1/friends/${connectionId}/exchange`, { topic, maxRounds });
+        return res.data;
+    }
+    /** Get exchange conversation history. */
+    async conversations(connectionId, limit) {
+        const params = limit ? `?limit=${limit}` : '';
+        const res = await this.http.get(`/v1/friends/${connectionId}/conversations${params}`);
+        return res.data;
+    }
+    /** Get shared memories for a connection. */
+    async sharedMemories(connectionId, limit) {
+        const params = limit ? `?limit=${limit}` : '';
+        const res = await this.http.get(`/v1/friends/${connectionId}/shared${params}`);
+        return res.data;
+    }
+    /** Share a specific memory with a friend. */
+    async shareMemory(connectionId, userId, content, domain, importance) {
+        const res = await this.http.post(`/v1/friends/${connectionId}/share`, {
+            userId, content, domain, importance,
+        });
+        return res.data;
+    }
+    /** Update connection settings. */
+    async update(connectionId, settings) {
+        await this.http.request('PATCH', `/v1/friends/${connectionId}`, settings);
+    }
+}
+class ProactiveClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Trigger proactive evaluation for a user. */
+    async evaluate(userId, appId) {
+        const res = await this.http.post('/v1/proactive/evaluate', { userId, appId });
+        return res;
+    }
+    /** Get pending proactive suggestions. */
+    async getSuggestions(userId, appId, limit) {
+        let params = `userId=${userId}`;
+        if (appId)
+            params += `&appId=${appId}`;
+        if (limit)
+            params += `&limit=${limit}`;
+        const res = await this.http.get(`/v1/proactive/suggestions?${params}`);
+        return res.data;
+    }
+    /** Dismiss a proactive suggestion. */
+    async dismiss(suggestionId) {
+        await this.http.post('/v1/proactive/dismiss', { suggestionId });
+    }
+}
+class NotificationsClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Mark notifications as read. */
+    async markRead(ids) {
+        await this.http.post('/v1/proactive/read', { ids });
+    }
+    /** Act on a proactive suggestion. */
+    async act(suggestionId, action) {
+        const res = await this.http.post('/v1/proactive/act', { suggestionId, action });
+        return res;
+    }
+    /** Get notification preferences. */
+    async getPrefs(userId, appId) {
+        let params = `userId=${userId}`;
+        if (appId)
+            params += `&appId=${appId}`;
+        const res = await this.http.get(`/v1/notifications/prefs?${params}`);
+        return res.data;
+    }
+    /** Update notification preferences. */
+    async updatePrefs(userId, prefs, appId) {
+        const res = await this.http.request('PUT', '/v1/notifications/prefs', { userId, appId, ...prefs });
+        return res.data;
+    }
+    /** Register a push notification token. */
+    async registerPushToken(userId, token, platform, appId) {
+        await this.http.post('/v1/notifications/push-token', { userId, token, platform, appId });
+    }
+    /** Get behavior timeline (activity/mood history). */
+    async getTimeline(userId, options) {
+        let params = `userId=${userId}`;
+        if (options?.days)
+            params += `&days=${options.days}`;
+        if (options?.limit)
+            params += `&limit=${options.limit}`;
+        const res = await this.http.get(`/v1/behavior/timeline?${params}`);
+        return res.data;
+    }
+    /** Get behavior signals. */
+    async getSignals(userId, type) {
+        let params = `userId=${userId}`;
+        if (type)
+            params += `&type=${type}`;
+        const res = await this.http.get(`/v1/behavior/signals?${params}`);
+        return res.data;
+    }
+    /** Get behavior summary. */
+    async getSummary(userId) {
+        const res = await this.http.get(`/v1/behavior/summary?userId=${userId}`);
+        return res.data;
+    }
+}
+class EvolutionClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Track a single activity event. */
+    async trackActivity(activity) {
+        const res = await this.http.post('/v1/activities', activity);
+        return res.data;
+    }
+    /** Track a batch of activities. */
+    async trackBatch(activities) {
+        const res = await this.http.post('/v1/activities/batch', { activities });
+        return res;
+    }
+    /** Get activity history. */
+    async getActivities(userId, options) {
+        let params = `userId=${userId}`;
+        if (options?.category)
+            params += `&category=${options.category}`;
+        if (options?.limit)
+            params += `&limit=${options.limit}`;
+        if (options?.days)
+            params += `&days=${options.days}`;
+        const res = await this.http.get(`/v1/activities?${params}`);
+        return res.data;
+    }
+    /** Get user's life domains. */
+    async getDomains(userId) {
+        const res = await this.http.get(`/v1/domains?userId=${userId}`);
+        return res.data;
+    }
+    /** Create a life domain. */
+    async createDomain(domain) {
+        const res = await this.http.post('/v1/domains', domain);
+        return res.data;
+    }
+    /** Update domain progress. */
+    async updateProgress(domainId, progress, note) {
+        const res = await this.http.post(`/v1/domains/${domainId}/progress`, { progress, note });
+        return res.data;
+    }
+    /** Get domain progress history. */
+    async getDomainHistory(domainId, limit) {
+        const params = limit ? `?limit=${limit}` : '';
+        const res = await this.http.get(`/v1/domains/${domainId}/history${params}`);
+        return res.data;
+    }
+    /** Register an app feature. */
+    async registerFeature(appId, feature) {
+        const res = await this.http.post(`/v1/apps/${appId}/features`, feature);
+        return res.data;
+    }
+    /** Emit an app event. */
+    async emitEvent(appId, event) {
+        const res = await this.http.post(`/v1/apps/${appId}/events`, event);
+        return res.data;
+    }
+    /** Get app context (features, recent events). */
+    async getAppContext(appId, userId) {
+        const params = userId ? `?userId=${userId}` : '';
+        const res = await this.http.get(`/v1/apps/${appId}/context${params}`);
+        return res.data;
+    }
+    /** Get or set user state (mood, role, context). */
+    async getUserState(userId) {
+        const res = await this.http.get(`/v1/user-state?userId=${userId}`);
+        return res.data;
+    }
+    /** Update user state. */
+    async setUserState(userId, state) {
+        const res = await this.http.post('/v1/user-state', { userId, ...state });
+        return res.data;
+    }
+}
+class DnaClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Get app DNA configuration. */
+    async get(appId) {
+        const res = await this.http.get(`/v1/apps/${appId}/dna`);
+        return res.data;
+    }
+    /** Register or update app DNA. */
+    async update(appId, dna) {
+        const res = await this.http.post(`/v1/apps/${appId}/dna`, dna);
+        return res.data;
+    }
+    /** Seed a new user's brain with app defaults. */
+    async seedUser(appId, userId) {
+        const res = await this.http.post(`/v1/apps/${appId}/seed`, { userId });
+        return res.data;
+    }
+    /** List all registered apps. */
+    async listApps() {
+        const res = await this.http.get('/v1/apps/directory');
+        return res.data;
+    }
+}
+class PartnerTokensClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /** Create a child token. */
+    async create(options) {
+        const res = await this.http.post('/v1/partner/tokens', options);
+        return res.data;
+    }
+    /** List partner's tokens. */
+    async list() {
+        const res = await this.http.get('/v1/partner/tokens');
+        return res.data;
+    }
+    /** Revoke a token. */
+    async revoke(tokenId) {
+        await this.http.request('DELETE', `/v1/partner/tokens/${tokenId}`);
+    }
+    /** Update token settings. */
+    async update(tokenId, updates) {
+        const res = await this.http.request('PATCH', `/v1/partner/tokens/${tokenId}`, updates);
+        return res.data;
+    }
+    /** Get token usage stats. */
+    async getUsage(tokenId) {
+        const res = await this.http.get(`/v1/partner/tokens/${tokenId}/usage`);
+        return res.data;
+    }
+}
+// ─── Default Export ──────────────────────────────────────────
+exports.default = DreamingClient;
+//# sourceMappingURL=index.js.map