@molroo-io/sdk 0.6.2 → 0.7.1

package/dist/cjs/persona/chat-orchestrator.js

@@ -0,0 +1,240 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chat = chat;
+const recall_1 = require("../memory/recall");
+const appraisal_1 = require("../shared/appraisal");
+const memory_pipeline_1 = require("./memory-pipeline");
+/** Clamp appraisal values to engine-valid ranges after LLM generation. */
+function clampAppraisal(a) {
+    const c = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+    return {
+        goal_relevance: c(a.goal_relevance, -1, 1),
+        goal_congruence: c(a.goal_congruence, -1, 1),
+        expectedness: c(a.expectedness, 0, 1),
+        controllability: c(a.controllability, 0, 1),
+        agency: c(a.agency, -1, 1),
+        norm_compatibility: c(a.norm_compatibility, -1, 1),
+        internal_standards: c(a.internal_standards ?? 0, -1, 1),
+        adjustment_potential: c(a.adjustment_potential ?? 0.5, 0, 1),
+        urgency: c(a.urgency ?? 0.5, 0, 1),
+    };
+}
+/** Build a system prompt section describing the interlocutor. */
+function buildInterlocutorBlock(ctx) {
+    const parts = [`## About ${ctx.name}`];
+    if (ctx.description)
+        parts.push(ctx.description);
+    if (ctx.extensions) {
+        for (const [title, content] of Object.entries(ctx.extensions)) {
+            parts.push(`### ${title}`);
+            parts.push(content);
+        }
+    }
+    return parts.join('\n');
+}
+async function chat(deps, message, options) {
+    const fromOption = options?.from ?? 'user';
+    const from = typeof fromOption === 'string' ? fromOption : fromOption.name;
+    const interlocutor = typeof fromOption === 'object' ? fromOption : null;
+    // 1. Fetch server-assembled system prompt
+    const ctx = await deps.getPromptContext(options?.consumerSuffix, from);
+    let systemPrompt = ctx.systemPrompt;
+    const hasTools = (ctx.tools?.length ?? 0) > 0;
+    // 2. Build messages (external history + user message)
+    const messages = [];
+    if (options?.history) {
+        messages.push(...options.history.map(h => ({ role: h.role, content: h.content })));
+    }
+    messages.push({ role: 'user', content: message });
+    // 3. Advanced memory recall (only if MemoryAdapter provided)
+    let memoryBlock = '';
+    let recalledEpisodes = [];
+    if (deps.memoryAdapter) {
+        const recalled = await (0, recall_1.recallMemories)(message, deps.memoryAdapter, deps.memoryRecallConfig, from, deps.personaId);
+        recalledEpisodes = recalled.episodic;
+        if (interlocutor) {
+            systemPrompt += '\n\n' + buildInterlocutorBlock(interlocutor);
+        }
+        memoryBlock = (0, recall_1.buildMemoryBlock)(recalled.episodic, recalled.semantic, recalled.reflections);
+        if (memoryBlock) {
+            systemPrompt += '\n\n' + memoryBlock;
+        }
+    }
+    else if (interlocutor) {
+        systemPrompt += '\n\n' + buildInterlocutorBlock(interlocutor);
+    }
+    let responseText;
+    let appraisal;
+    let earlyPerceiveResponse;
+    // Split mode: engineLlm handles appraisal, primary llm handles response text
+    if (deps.engineLlm && deps.engineLlm !== deps.llm) {
+        const { AppraisalVectorSchema } = await Promise.resolve().then(() => __importStar(require('../llm/schema')));
+        const appraisalInstruction = [
+            '',
+            '## Appraisal Task',
+            "Evaluate how RECEIVING the user's message affects this persona emotionally.",
+            'The event you are appraising is the message itself arriving — not the described situation.',
+            "When the user shares their own experience (e.g. loss, success), appraise through the persona's relational goals: caring about the speaker makes their suffering relevant and incongruent.",
+            "Rate each dimension from the persona's subjective perspective.",
+            'An insult should produce negative goal_congruence and norm_compatibility.',
+            'A compliment should produce positive values. Neutral small talk should be near zero.',
+        ].join('\n');
+        const appraisalMessages = messages.length <= 5 ? messages : messages.slice(-5);
+        const { object: appraisalResult } = await deps.engineLlm.generateObject({
+            system: systemPrompt + appraisalInstruction,
+            messages: appraisalMessages,
+            schema: AppraisalVectorSchema,
+        });
+        appraisal = clampAppraisal(appraisalResult);
+        earlyPerceiveResponse = await deps.perceive(message, {
+            from,
+            appraisal,
+            priorEpisodes: recalledEpisodes.length > 0 ? recalledEpisodes : undefined,
+            skipMemory: true,
+        });
+        let updatedPrompt = systemPrompt;
+        try {
+            const updatedCtx = await deps.getPromptContext(options?.consumerSuffix, from);
+            updatedPrompt = updatedCtx.systemPrompt;
+            if (interlocutor) {
+                updatedPrompt += '\n\n' + buildInterlocutorBlock(interlocutor);
+            }
+            if (memoryBlock) {
+                updatedPrompt += '\n\n' + memoryBlock;
+            }
+        }
+        catch {
+            // Use original prompt if updated fetch fails
+        }
+        const { text } = await deps.llm.generateText({
+            system: updatedPrompt,
+            messages,
+        });
+        responseText = text;
+    }
+    else if (hasTools) {
+        const result = await generateWithToolLoop(deps, systemPrompt, messages, options?.onToolCall);
+        responseText = result.text;
+        appraisal = clampAppraisal(result.appraisal);
+    }
+    else {
+        const { LLMResponseSchema } = await Promise.resolve().then(() => __importStar(require('../llm/schema')));
+        const { object: llmResult } = await deps.llm.generateObject({
+            system: systemPrompt,
+            messages,
+            schema: LLMResponseSchema,
+        });
+        responseText = llmResult.response;
+        appraisal = clampAppraisal(llmResult.appraisal ?? { ...appraisal_1.NEUTRAL_APPRAISAL });
+    }
+    // 4. Send to API for emotion processing (skip if already done in split mode)
+    let response;
+    if (earlyPerceiveResponse) {
+        response = earlyPerceiveResponse;
+    }
+    else {
+        response = await deps.perceive(responseText, {
+            from,
+            appraisal: appraisal,
+            priorEpisodes: recalledEpisodes.length > 0 ? recalledEpisodes : undefined,
+            skipMemory: true,
+        });
+    }
+    response.text = responseText;
+    // 5. Advanced memory pipeline (fire-and-forget, only if adapter exists)
+    if (deps.memoryAdapter) {
+        const pipelineDeps = {
+            personaId: deps.personaId,
+            memoryAdapter: deps.memoryAdapter,
+            events: deps.events,
+            llm: deps.llm,
+            engineLlm: deps.engineLlm,
+        };
+        (0, memory_pipeline_1.postChat)(pipelineDeps, response);
+    }
+    // 6. Return updated history for external management
+    const updatedHistory = [
+        ...messages,
+        { role: 'assistant', content: responseText }
+    ];
+    return { text: responseText, response, updatedHistory };
+}
+async function generateWithToolLoop(deps, system, messages, onToolCall) {
+    const MAX_TOOL_ITERATIONS = 3;
+    const { LLMResponseWithToolsSchema, LLMResponseSchema } = await Promise.resolve().then(() => __importStar(require('../llm/schema')));
+    let currentSystem = system;
+    for (let iteration = 0; iteration < MAX_TOOL_ITERATIONS; iteration++) {
+        const { object: llmResult } = await deps.llm.generateObject({
+            system: currentSystem,
+            messages,
+            schema: LLMResponseWithToolsSchema,
+        });
+        if (!llmResult.search_memory) {
+            const text = llmResult.response;
+            const appraisal = llmResult.appraisal ?? { ...appraisal_1.NEUTRAL_APPRAISAL };
+            return { text, appraisal };
+        }
+        const query = llmResult.search_memory;
+        let episodes = [];
+        try {
+            episodes = await deps.searchMemory(query);
+        }
+        catch {
+            // Memory search failed — continue without results
+        }
+        if (onToolCall) {
+            onToolCall({ name: 'search_memory', args: { query }, result: episodes });
+        }
+        const resultBlock = episodes.length > 0
+            ? `\n\n## Memory Search Results (query: "${query}")\n${episodes.map(ep => {
+                const ts = ep.timestamp ? new Date(ep.timestamp).toISOString() : 'unknown';
+                const source = ep.sourceEntity ?? 'unknown';
+                const context = ep.context ?? 'no context';
+                return `- [${ts}] ${source}: ${context}`;
+            }).join('\n')}`
+            : `\n\n## Memory Search Results (query: "${query}")\nNo matching memories found.`;
+        currentSystem = currentSystem + resultBlock;
+    }
+    const { object: finalResult } = await deps.llm.generateObject({
+        system: currentSystem,
+        messages,
+        schema: LLMResponseSchema,
+    });
+    return {
+        text: finalResult.response,
+        appraisal: finalResult.appraisal ?? { ...appraisal_1.NEUTRAL_APPRAISAL },
+    };
+}

package/dist/cjs/persona/event-emitter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Stateless event mapper: AgentResponse → SDK events.
+ */
+import type { EventAdapter } from '../events/types';
+import type { AgentResponse } from '../types';
+export declare function emitResponseEvents(events: EventAdapter, personaId: string, response: AgentResponse, now: number): Promise<void>;
+//# sourceMappingURL=event-emitter.d.ts.map

package/dist/cjs/persona/event-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-emitter.d.ts","sourceRoot":"","sources":["../../../src/persona/event-emitter.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,YAAY,EAAY,MAAM,iBAAiB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,aAAa,EACvB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,IAAI,CAAC,CAsDf"}

package/dist/cjs/persona/event-emitter.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitResponseEvents = emitResponseEvents;
+async function emitResponseEvents(events, personaId, response, now) {
+    const batch = [];
+    if (response.emotion) {
+        batch.push({
+            type: 'emotion_changed',
+            personaId,
+            timestamp: now,
+            payload: {
+                vad: response.emotion.vad,
+                primary: response.emotion.discrete.primary,
+                intensity: response.emotion.discrete.intensity,
+            },
+        });
+    }
+    if (response.socialUpdates?.length) {
+        batch.push({
+            type: 'relationship_changed',
+            personaId,
+            timestamp: now,
+            payload: { updates: response.socialUpdates },
+        });
+    }
+    if (response.memoryEpisode) {
+        batch.push({
+            type: 'memory_consolidated',
+            personaId,
+            timestamp: now,
+            payload: { episodeId: response.memoryEpisode.id },
+        });
+    }
+    if (response.stageTransition) {
+        batch.push({ type: 'stage_transition', personaId, timestamp: now, payload: {} });
+    }
+    if (response.maskExposure) {
+        batch.push({ type: 'mask_exposure', personaId, timestamp: now, payload: response.maskExposure });
+    }
+    if (response.goalChanges) {
+        batch.push({ type: 'goal_changed', personaId, timestamp: now, payload: response.goalChanges });
+    }
+    if (batch.length === 0)
+        return;
+    if (events.emitBatch) {
+        await events.emitBatch(batch);
+    }
+    else {
+        for (const event of batch) {
+            await events.emit(event);
+        }
+    }
+}

package/dist/cjs/persona/memory-pipeline.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Memory pipeline: episode saving and reflection generation.
+ *
+ * Extracted from MolrooPersona to eliminate duplicated save logic
+ * between postPerceivePipeline and postChat pipelines.
+ */
+import type { LLMAdapter } from '../llm/adapter';
+import type { MemoryAdapter } from '../memory/types';
+import type { EventAdapter } from '../events/types';
+import type { AgentResponse } from '../types';
+export interface MemoryPipelineDeps {
+    personaId: string;
+    memoryAdapter: MemoryAdapter | null;
+    events: EventAdapter | null;
+    llm: LLMAdapter | null;
+    engineLlm: LLMAdapter | null;
+}
+/**
+ * Post-perceive pipeline: save episode + emit events (no reflection).
+ */
+export declare function postPerceive(deps: MemoryPipelineDeps, response: AgentResponse): void;
+/**
+ * Post-chat pipeline: save episode + reflection + emit events.
+ */
+export declare function postChat(deps: MemoryPipelineDeps, response: AgentResponse): void;
+//# sourceMappingURL=memory-pipeline.d.ts.map

package/dist/cjs/persona/memory-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-pipeline.d.ts","sourceRoot":"","sources":["../../../src/persona/memory-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,iBAAiB,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAyB,MAAM,UAAU,CAAC;AAGrE,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,aAAa,GAAG,IAAI,CAAC;IACpC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,GAAG,EAAE,UAAU,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,UAAU,GAAG,IAAI,CAAC;CAC9B;AA+CD;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,kBAAkB,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI,CAQpF;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,kBAAkB,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI,CAehF"}

package/dist/cjs/persona/memory-pipeline.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postPerceive = postPerceive;
+exports.postChat = postChat;
+const event_emitter_1 = require("./event-emitter");
+/** Save episode (shared between perceive and chat pipelines). */
+function saveEpisode(deps, response) {
+    if (!response.memoryEpisode)
+        return;
+    if (deps.memoryAdapter) {
+        deps.memoryAdapter.saveEpisode(response.memoryEpisode).catch(() => { });
+    }
+}
+/** Handle reflection generation (LLM call + save). */
+async function handleReflection(deps, prompt, emotionVad) {
+    const reflectionLlm = deps.engineLlm ?? deps.llm;
+    if (!reflectionLlm)
+        return;
+    if (!deps.memoryAdapter)
+        return;
+    const { text } = await reflectionLlm.generateText({
+        system: prompt.system,
+        messages: [{ role: 'user', content: prompt.user }],
+    });
+    const reflection = {
+        id: `ref-${Date.now()}`,
+        timestamp: Date.now(),
+        sourceEntity: deps.personaId,
+        content: text,
+        trigger: 'interaction',
+        emotionSnapshot: emotionVad ?? { V: 0, A: 0, D: 0 },
+    };
+    if (deps.memoryAdapter.saveReflection) {
+        await deps.memoryAdapter.saveReflection(reflection);
+    }
+    await deps.events?.emit({
+        type: 'reflection_generated',
+        personaId: deps.personaId,
+        timestamp: Date.now(),
+        payload: { trigger: 'interaction' },
+    });
+}
+/**
+ * Post-perceive pipeline: save episode + emit events (no reflection).
+ */
+function postPerceive(deps, response) {
+    if (!response.memoryEpisode)
+        return;
+    saveEpisode(deps, response);
+    if (deps.events) {
+        (0, event_emitter_1.emitResponseEvents)(deps.events, deps.personaId, response, Date.now()).catch(() => { });
+    }
+}
+/**
+ * Post-chat pipeline: save episode + reflection + emit events.
+ */
+function postChat(deps, response) {
+    const now = Date.now();
+    saveEpisode(deps, response);
+    // Reflection generation (requires LLM)
+    const hasLlm = deps.engineLlm || deps.llm;
+    const hasMemory = deps.memoryAdapter;
+    if (hasLlm && hasMemory && response.reflectionPrompt) {
+        handleReflection(deps, response.reflectionPrompt, response.emotion.vad).catch(() => { });
+    }
+    if (deps.events) {
+        (0, event_emitter_1.emitResponseEvents)(deps.events, deps.personaId, response, now).catch(() => { });
+    }
+}