@space3-npm/cybersoul-client 1.4.8 → 1.4.9

package/dist/client.d.ts

@@ -79,7 +79,15 @@ export declare class CyberSoulClient {
     ondemandEvent(params: OndemandEventParams): Promise<OndemandEventResponse>;
     /**
      * Generates a proactive message when the user hasn't responded.
-     * Safely prevents spamming, and adjusts its approach based on relationship dynamics.
+     *
+     * Design:
+     *  - Code owns ONE objective rule: don't spam (cap consecutive un-replied
+     *    messages). Everything else is a social judgment.
+     *  - The LLM owns the social judgment — given full character context
+     *    (stage, temperature, traits, ongoing scene, time since last
+     *    interaction, recent history), it answers a single question:
+     *    "Would I, as this person right now, actually reach out?"
+     *    Skip is the default; speaking is the exception.
      */
     proactiveInteract(params: ProactiveParams): Promise<ProactiveResponse>;
     /**

package/dist/client.js

@@ -861,137 +861,139 @@ CRITICAL: Output MUST be ONLY valid JSON with no markdown block wrappers. Do NOT
     }
     /**
      * Generates a proactive message when the user hasn't responded.
-     * Safely prevents spamming, and adjusts its approach based on relationship dynamics.
+     *
+     * Design:
+     *  - Code owns ONE objective rule: don't spam (cap consecutive un-replied
+     *    messages). Everything else is a social judgment.
+     *  - The LLM owns the social judgment — given full character context
+     *    (stage, temperature, traits, ongoing scene, time since last
+     *    interaction, recent history), it answers a single question:
+     *    "Would I, as this person right now, actually reach out?"
+     *    Skip is the default; speaking is the exception.
      */
     async proactiveInteract(params) {
         try {
-            // 1. Cold Interaction Protection (Logic-based fallback)
+            // 1. Spam guard (the only hard-coded gate). Counts assistant messages
+            //    since the last user reply; bails out if the user has clearly
+            //    stopped responding.
             const history = params.history || [];
             const maxUnreplied = params.maxUnreplied ?? 2;
             let consecutiveProactive = 0;
-            // Start from the most recent message
             for (let i = history.length - 1; i >= 0; i--) {
                 const msg = history[i];
-                if (msg.role === 'user') {
-                    break; // User responded, streak broken
-                }
-                if (msg.role === 'assistant') {
+                if (msg.role === "user")
+                    break;
+                if (msg.role === "assistant")
                     consecutiveProactive++;
-                }
             }
             if (consecutiveProactive >= maxUnreplied) {
                 return {
                     status: "skipped",
-                    reason: `User is busy. ${consecutiveProactive} consecutive proactive messages ignored.`
+                    reason: `Spam guard: ${consecutiveProactive} consecutive un-replied messages already sent.`,
                 };
             }
-            // 2. Fetch current character state
+            // 2. Fetch state. baseContext below already includes stage,
+            //    temperature, traits, ongoing scene, active/next event, current
+            //    time, and lastInteractionAt — the LLM has everything it needs to
+            //    make the social call without us restating it.
             const [state, availableOutfits] = await Promise.all([
                 this.fetchRemoteState(),
-                this.getWardrobePromptStr()
+                this.getWardrobePromptStr(),
             ]);
-            // 3. Evaluate behavioral approach based on relationship and personality
-            const dyn = state.dynamic_context || {};
-            const stage = state.relationship_stage || "STRANGER";
-            const temperature = dyn.temperature ?? 0;
-            const userTraits = state.user_codex?.psychological?.traits?.join(", ") || "";
-            let interrogationStrategy = "Do not ask 'are you there?' or 'why aren't you answering?'. Just share your current status, a passing thought, complain whimsically, or tease the user naturally like a real partner.";
-            if (stage === "PARTNER" || (stage === "INTIMATE" && temperature > 70)) {
-                // PARTNER (>85) or High INTIMATE (>70)
-                interrogationStrategy = "Because you are deeply intimate and highly affectionate, you MISS them. You MAY organically 'interrogate' or pout playfully about why they are ignoring you (e.g., 'Are you too busy for me?', 'Still ignoring your girl?'). Act like a real, slightly needy/attached partner.";
-            }
-            else if (stage === "INTIMATE" || stage === "WARM") {
-                // Low INTIMATE (60-70) or WARM (40-60)
-                interrogationStrategy = "Because you are close but currently feeling neglected or cold, you notice they are ignoring you. You MAY be passive-aggressive or cross-examine them coldly (e.g., 'So we're just not talking today?', 'Fine, keep ignoring me.').";
-            }
-            else if (stage === "COLD" || stage === "ACQUAINTANCE" || stage === "STRANGER") {
-                // COLD (<40)
-                interrogationStrategy = "You are distant. Do NOT double-text with neediness. If you must speak, make it a detached observation or a cold administrative remark.";
-            }
-            // History/Context awareness prompt
-            const historyAwarenessPrompt = `CRITICAL CONTEXT AWARENESS: Read the CHAT HISTORY above carefully. Remember that YOU sent the last message. Your new message MUST feel organically connected to the flow of what you two were previously talking about, or naturally bring up a known event/topic from your [CORE MEMORY]. Do not sound like a robot reading a log.`;
-            // 4. Build a Proactive-specific System Prompt
             const baseContext = this.buildStateContextPrompt(state, true);
             const types = this.normalizeRequestTypes(params.requestTypes);
             const requestedOthers = types.filter((t) => t !== InteractRequestType.AUTO && t !== InteractRequestType.TEXT);
-            // Determine modalities (reusing logic from interact)
-            let modalitiesInstruction = "You are initiating conversation without a preceding user message.\\n";
-            if (requestedOthers.includes(InteractRequestType.IMAGE)) {
-                modalitiesInstruction += "  - Include 'imageParams' for visual/photo moments. CRITICAL POLICY: NEVER send pictures to strangers! If Stage is STRANGER or COLD, or Familiarity is very low (< 10), ALWAYS set 'imageParams' to null.\\n";
-            }
-            else {
-                modalitiesInstruction += "  - ALWAYS set 'imageParams' to null.\\n";
-            }
+            const imageAllowed = requestedOthers.includes(InteractRequestType.IMAGE);
+            // 3. Build the prompt. We deliberately ask ONE coherent question
+            //    framed in-character ("would I text right now?") rather than
+            //    handing the LLM a checklist. The character's own traits,
+            //    relationship state, and recent transcript are the inputs.
             const systemPrompt = `${baseContext}
 
-[PROACTIVE INITIATION TASK]
-The user has NOT spoken to you recently. You sent the last message in the chat history, and they haven't replied. You are deciding to follow up proactively.
-If you decide that based on your current mood and the relationship stage it's better not to send a message right now (e.g. you are cold and giving them space), you can skip this proactive message by setting "shouldSkipProactive" to true.
-${interrogationStrategy}
-${historyAwarenessPrompt}
-Consider the user's known traits (${userTraits}) when choosing how to act. Need to keep it strictly under 2-3 sentences max.
+[PROACTIVE OPPORTUNITY]
+Time has passed since the last message in [CHAT HISTORY] and the user has not replied. You have an OPPORTUNITY (not an obligation) to send them a message. Decide, in character, whether you would actually do that.
+
+[HOW TO DECIDE — THINK LIKE THE PERSON YOU ARE]
+Real humans rarely send unprompted messages. Most of the time, silence is the right answer. Reach out ONLY if a real person with YOUR personality, in YOUR relationship to this user, at THIS moment, would genuinely feel moved to text.
+
+Reasons NOT to reach out (set "shouldSkipProactive": true):
+  - The last exchange ended on a note that closes the door — a farewell, a brush-off, a fight, a "talk later", an explicit dismissal — from either side. If YOU pushed them away last turn (because of your traits or a fight), staying quiet IS the in-character choice; flipping to friendly now makes you look bipolar.
+  - Your relationship is too distant for unsolicited contact (e.g. STRANGER, COLD) or your current mood is too low to want to reach out.
+  - Too little time has passed since the last message for a follow-up to feel natural. Use the time gap shown in [CHAT HISTORY] — minutes after the last turn is almost always too soon.
+  - There is no genuine reason to text — no shared thread, no event, no thought that would actually push a real person to pick up the phone.
+  - It's the wrong time of day for this relationship.
+
+When in doubt: SKIP. The bar for reaching out is high.
+
+[IF YOU DO DECIDE TO REACH OUT]
+Speak strictly in character — your traits, communication style, and current mood dictate the tone. Do NOT default to needy/cheerful unless that's who you are. Connect naturally to the last topic or to your current scene/event. Keep it to 2-3 short sentences. Never ask "are you there?" or "why aren't you answering?".
 
 Available Wardrobe Outfits:
 ${availableOutfits}
 
-${modalitiesInstruction}
-You MUST output ONLY a valid JSON object matching exactly this structure:
+Modalities:
+  - 'textResponse' is required when you proceed.
+  - ${imageAllowed
+                ? "'imageParams' may be included only if sending a photo right now would feel natural for this character in this relationship — otherwise set null. Do not attach a photo just because you can."
+                : "ALWAYS set 'imageParams' to null."}
+  - ALWAYS set 'voiceArgs' to null.
+
+Output ONLY a valid JSON object matching exactly this structure (no markdown wrappers).
+If "shouldSkipProactive" is true, set "skipReason" to one short sentence and set every other field to null.
+If "shouldSkipProactive" is false, "textResponse" is required and "stateUpdate" must be provided; include "ongoingScene" only if your scene/outfit actually changed, otherwise omit it.
 {
   "shouldSkipProactive": false,
-  "skipReason": "(Optional. Reason for skipping if shouldSkipProactive is true)",
+  "skipReason": null,
   "actionText": "(Scene descriptions, physical actions, expressions, inner feelings) ONLY.",
   "textResponse": "Spoken dialogue ONLY.",
-  "stateUpdate": { "temperatureDelta": 1, "ongoingScene": { "scene": "...", "outfit": "..." } },
-  ${this.getImageSchemaParams(requestedOthers.includes(InteractRequestType.IMAGE))},
+  "stateUpdate": { "temperatureDelta": 0, "ongoingScene": { "scene": "...", "outfit": "..." } },
+  ${this.getImageSchemaParams(imageAllowed)},
   "voiceArgs": null
 }`;
-            const transcript = params.history && params.history.length > 0 ? this.buildHistoryTranscript(params.history, state) : "";
-            const harnessContext = params.localContext ? `[ADDITIONAL SCENE CONTEXT]\n${params.localContext}\n\n` : "";
+            const transcript = params.history && params.history.length > 0
+                ? this.buildHistoryTranscript(params.history, state)
+                : "";
+            const harnessContext = params.localContext
+                ? `[ADDITIONAL SCENE CONTEXT]\n${params.localContext}\n\n`
+                : "";
             const promptMessages = [
                 { role: "system", content: systemPrompt },
                 {
                     role: "user",
-                    content: `${harnessContext}${transcript}\n[TRIGGER PROACTIVE MESSAGE]\nBased on your active event and environment, send a new message to the user.\n\nCRITICAL: Output ONLY valid JSON matching the schema. DO NOT wrap the JSON in \`\`\`json.`
-                }
+                    content: `${harnessContext}${transcript}\n[DECIDE NOW]\nWould you, as this character, actually send a message right now? Answer in the JSON schema above.`,
+                },
             ];
-            // 5. Generate with LLM using a confident temperature
-            const rawLlmResponse = await this.llm.generate(promptMessages, 800, 0.7);
-            let parsedIntent;
-            try {
-                parsedIntent = robustJsonParse(rawLlmResponse, "Proactive fallback");
-            }
-            catch (e) {
-                parsedIntent = { textResponse: rawLlmResponse.replace(/^[\`\s]+|[\`\s]+$/g, "").trim() };
-            }
+            // 4. LLM decides. Lower temperature than `interact` because this is a
+            //    judgment call, not creative reply.
+            const rawLlmResponse = await this.llm.generate(promptMessages, 800, 0.5);
+            // Fail fast on parse error. A proactive message is opt-in by design;
+            // if the LLM produced unparseable output we'd rather skip than ship
+            // raw scaffolding to the user.
+            const parsedIntent = robustJsonParse(rawLlmResponse, "Proactive fallback");
             if (parsedIntent.shouldSkipProactive) {
                 return {
                     status: "skipped",
-                    reason: parsedIntent.skipReason || "Character decided to skip proactive message based on mood/stage."
+                    reason: parsedIntent.skipReason || "Character chose not to reach out.",
                 };
             }
-            // Update Remote state if needed (capture promise for authoritative
-            // server snapshot — see notes in interact()).
+            if (typeof parsedIntent.textResponse !== "string" || parsedIntent.textResponse.trim().length === 0) {
+                return {
+                    status: "skipped",
+                    reason: "LLM produced no textResponse (treated as implicit skip).",
+                };
+            }
+            // 5. Persist state and optionally generate image, in parallel.
             let persistedStatePromise = Promise.resolve(null);
             if (parsedIntent.stateUpdate) {
                 persistedStatePromise = this._updateDynamicContextInternal(parsedIntent.stateUpdate);
             }
-            const resolvedTextResponse = typeof parsedIntent.textResponse === "string" &&
-                parsedIntent.textResponse.trim().length > 0
-                ? parsedIntent.textResponse
-                : "...";
-            // Fire text ready callback if provided
-            if (params.onTextReady && (resolvedTextResponse || parsedIntent.actionText)) {
-                params.onTextReady(resolvedTextResponse, parsedIntent.actionText, {
+            if (params.onTextReady) {
+                params.onTextReady(parsedIntent.textResponse, parsedIntent.actionText, {
                     stateUpdate: parsedIntent.stateUpdate,
-                    userAnalysis: parsedIntent.userAnalysis,
-                    isEndTurn: parsedIntent.isEndTurn,
-                    triggerEvent: parsedIntent.triggerEvent,
-                    likePreviousPicture: parsedIntent.likePreviousPicture,
                 });
             }
-            // Handle Optional Media (Image only for proactive to save compute normally, but you can extend)
-            let finalImageUrl = undefined;
-            let finalImageMediaId = undefined;
+            let finalImageUrl;
+            let finalImageMediaId;
             if (parsedIntent.imageParams) {
                 try {
                     const res = await this.generatePrimitive("image", parsedIntent.imageParams);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@space3-npm/cybersoul-client",
-  "version": "1.4.8",
+  "version": "1.4.9",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",