briyah 1.2.0 → 1.2.1

package/dist-sdk/server/src/ai/agent.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
 const app_types_1 = require("../../../shared/types/app.types");
+const logger_1 = require("../common/logger");
 const crypto_1 = require("crypto");
 class Agent {
     id;
@@ -39,7 +40,6 @@ class Agent {
     modelName;
     smallModelName;
     serviceName;
-    imageProperties;
     reasoningEffort;
     allowSearch;
     maxOutputTokens = 0;
@@ -191,11 +191,14 @@ class Agent {
     async compact() {
         const originalHistory = [...(this.history || [])];
         const originalLength = originalHistory.length;
+        const originalChars = originalHistory.reduce((sum, m) => sum + (m?.content?.length || 0), 0);
         if (originalLength === 0) {
             return {
                 success: true,
                 originalLength,
                 newLength: originalLength,
+                originalChars,
+                newChars: 0,
                 message: 'No conversation history to compact',
             };
         }
@@ -206,11 +209,15 @@ class Agent {
             const summary = summaryResponse?.summary || summaryResponse;
             this.addToConversationHistory(`[CONVERSATION HISTORY SUMMARY]\n\n${summary}`, true);
             const newLength = this.history.length;
+            const newChars = this.history.reduce((sum, m) => sum + (m?.content?.length || 0), 0);
+            logger_1.logger.log(`Compacted ${this.agentName}: ${originalChars} -> ${newChars} characters (${originalLength} -> ${newLength} messages)`);
             this.save();
             return {
                 success: true,
                 originalLength,
                 newLength,
+                originalChars,
+                newChars,
                 message: `${originalLength} messages -> ${newLength} messages`,
                 summary,
             };
@@ -223,11 +230,11 @@ class Agent {
     async textPrompt(prompt, jsonSchema = null, saveResponse = true, promptInstructions = null, cacheMessage = false, maxOutputChars = 0) {
         return await this.aiService.textPrompt(this, prompt, jsonSchema, saveResponse, promptInstructions, this.aiService.getCacheConfig(this, cacheMessage), maxOutputChars);
     }
-    async generateImage(prompt) {
-        return await this.aiService.generateImage(this, prompt, this.imageProperties);
+    async generateImage(prompt, imageProperties) {
+        return await this.aiService.generateImage(this, prompt, imageProperties);
     }
-    async editImage(prompt, referenceImageArtifactIds) {
-        return await this.aiService.editImage(this, prompt, this.imageProperties, referenceImageArtifactIds);
+    async editImage(prompt, imageProperties, referenceImageArtifactIds) {
+        return await this.aiService.editImage(this, prompt, imageProperties, referenceImageArtifactIds);
     }
 }
 exports.Agent = Agent;

package/dist-sdk/server/src/ai/ai-debug-logger.d.ts

@@ -0,0 +1,10 @@
+export declare class AiDebugLogger {
+    static isEnabled(): boolean;
+    private static getLogDir;
+    private static timestamp;
+    private static sanitize;
+    private static write;
+    static writeRequest(agentName: string, content: unknown): void;
+    static writeThinking(agentName: string, content: string): void;
+    static writeResponse(agentName: string, content: string): void;
+}

package/dist-sdk/server/src/ai/ai-debug-logger.js

@@ -0,0 +1,82 @@
+"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.AiDebugLogger = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class AiDebugLogger {
+    static isEnabled() {
+        return process.env.AI_DEBUG === 'true';
+    }
+    static getLogDir() {
+        const dataPath = process.env.BRIYAH_DATA_PATH || path.resolve(process.cwd(), 'server', 'data');
+        const dir = path.resolve(dataPath, 'logs', 'ai-debug');
+        fs.mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    static timestamp() {
+        const now = new Date();
+        const pad = (n, len = 2) => String(n).padStart(len, '0');
+        return (`${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}` +
+            `_${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}` +
+            `-${pad(now.getMilliseconds(), 3)}`);
+    }
+    static sanitize(name) {
+        return name.replace(/[<>:"/\\|?*\s]+/g, '_').substring(0, 80);
+    }
+    static write(agentName, suffix, content) {
+        if (!this.isEnabled())
+            return;
+        try {
+            const filename = `${this.timestamp()}_${this.sanitize(agentName)}_${suffix}.txt`;
+            fs.writeFileSync(path.join(this.getLogDir(), filename), content, 'utf8');
+        }
+        catch {
+        }
+    }
+    static writeRequest(agentName, content) {
+        const text = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+        this.write(agentName, 'REQUEST', text);
+    }
+    static writeThinking(agentName, content) {
+        if (!content)
+            return;
+        this.write(agentName, 'THINKING', content);
+    }
+    static writeResponse(agentName, content) {
+        this.write(agentName, 'RESPONSE', content ?? '');
+    }
+}
+exports.AiDebugLogger = AiDebugLogger;

package/dist-sdk/server/src/room/message.d.ts

@@ -7,7 +7,7 @@ export declare class RoomMessage implements Message {
     timestamp: Date;
     name?: string;
     situation?: string;
-    updatePortrait?: string[];
+    changes?: Record<string, any>;
     index?: number;
     constructor(sender: string, action: MessageAction, content: string, targets?: string[], name?: string, situation?: string);
     getSender(): string;

package/dist-sdk/server/src/room/message.js

@@ -10,7 +10,7 @@ class RoomMessage {
     timestamp;
     name;
     situation;
-    updatePortrait;
+    changes;
     index;
     constructor(sender, action = app_types_1.MessageAction.SPEAK, content, targets = [], name, situation) {
         this.sender = sender;

package/dist-sdk/server/src/room/room.d.ts

@@ -67,6 +67,7 @@ export declare class Room {
     isRoomAdjourned(): boolean;
     setArtifacts(artifacts: Artifact[]): void;
     private parseAgentResponse;
+    private static extractPreamble;
     private static coerceMessageAction;
     private getAgentAiResponse;
     perceive(agent: Agent, message: RoomMessage, onResponse: (message: RoomMessage | null) => void): void;

package/dist-sdk/server/src/room/room.js

@@ -201,19 +201,14 @@ class Room {
         let normalizedAction;
         if (typeof response !== 'object') {
             needsModeration = true;
-            const lines = response.split('\n');
-            for (const line of lines) {
-                const trimmedLine = line.trim();
-                if (trimmedLine.startsWith('# Situation:')) {
-                    situation = trimmedLine.substring('# Situation:'.length).trim();
-                    content = lines
-                        .filter((l) => !l.startsWith('# Situation:'))
-                        .join('\n')
-                        .trimStart();
-                    break;
-                }
+            const parsed = Room.extractPreamble(response);
+            if (parsed) {
+                situation = parsed.preamble;
+                content = parsed.content;
+            }
+            else {
+                situation = undefined;
             }
-            situation = situation || undefined;
         }
         else if (!response.content) {
             needsModeration = true;
@@ -244,11 +239,31 @@ class Room {
         }
         situation = response.situation || undefined;
         const msg = new message_1.RoomMessage(agent.agentNickname, normalizedAction, response.content, targets, response.name, situation);
-        if (Array.isArray(response.update_portrait) && response.update_portrait.length > 0) {
-            msg.updatePortrait = response.update_portrait;
+        if (response.changes && typeof response.changes === 'object') {
+            msg.changes = response.changes;
         }
         return msg;
     }
+    static extractPreamble(response) {
+        const lines = response.split('\n');
+        let i = 0;
+        while (i < lines.length && lines[i].trim() === '')
+            i++;
+        const tagLineRe = /^\s*<\w+>[\s\S]*?<\/\w+>\s*$/;
+        if (i >= lines.length || !tagLineRe.test(lines[i]))
+            return null;
+        const preambleLines = [];
+        let j = i;
+        while (j < lines.length && tagLineRe.test(lines[j])) {
+            preambleLines.push(lines[j].trim());
+            j++;
+        }
+        const preamble = preambleLines.join('\n');
+        if (j < lines.length && lines[j].trim() === '')
+            j++;
+        const content = lines.slice(j).join('\n').trimStart();
+        return { preamble, content };
+    }
     static coerceMessageAction(raw) {
         if (typeof raw !== 'string')
             return undefined;
@@ -324,6 +339,13 @@ class Room {
     async moderate(moderatorAgent, message, onResponse) {
         const humanAgent = this.getAgents().find((agent) => agent.isControlledByHuman);
         const humanAgentName = humanAgent ? humanAgent.agentNickname : 'Player';
+        const visibleArtifacts = this.getVisibleArtifacts(moderatorAgent.agentNickname)
+            .map((a) => `${a.name} (by ${a.creator}): ${a.body}`)
+            .join('\n\n');
+        const invisibleArtifactNames = this.getArtifacts()
+            .filter((a) => !this.getVisibleArtifacts(moderatorAgent.agentNickname).includes(a))
+            .map((a) => a.name)
+            .join(', ');
         const variables = {
             agentName: moderatorAgent.agentName,
             agentNickname: moderatorAgent.agentNickname || moderatorAgent.agentName,
@@ -335,6 +357,8 @@ class Room {
             scenario: this.getGoal(),
             humanAgent: humanAgent,
             humanAgentName: humanAgentName,
+            visibleArtifacts: visibleArtifacts,
+            invisibleArtifactNames: invisibleArtifactNames,
         };
         let prompt = `
 Current Situation: ${this.getSituation()}
@@ -648,11 +672,11 @@ Recent Message: ${message.getContent()}
                 originalMessage.content = content;
             }
             if (this.checkAgentNicknameMatch(originalMessage.sender, responderNickname)) {
-                let responder = this.getHumanAgentName();
-                if (!responder)
-                    responder = roomLeaderName;
-                this.setCurrentSpeaker(responder);
-                logger_1.logger.warn(`Moderator routed message to sender: ${originalMessage.sender}. Setting responder to room leader: ${responder}`);
+                logger_1.logger.warn(`Moderator routed message to sender: ${originalMessage.sender}. Reassigning responder to room leader: ${roomLeaderName}`);
+                responderNickname = roomLeaderName;
+                moderatorMessage.name = roomLeaderName;
+                if (!targets.includes(roomLeaderName))
+                    targets.push(roomLeaderName);
             }
             logger_1.logger.log(`Moderator routing: sender=${originalMessage.sender} action=${moderatorMessage.action}, name=${responderNickname}, targets=${targets.join(', ')}`);
             if (moderatorMessage.action === app_types_1.MessageAction.RELAY) {

package/dist-sdk/server/src/sdk/briyah-config.d.ts

@@ -4,6 +4,7 @@ export interface LoggingOptions {
     logFile?: string;
     console?: boolean;
     level?: 'debug' | 'log' | 'warn' | 'error';
+    aiDebug?: boolean;
 }
 export interface BriyahConfigOptions {
     dataPath?: string;

package/dist-sdk/server/src/sdk/briyah-config.js

@@ -23,6 +23,10 @@ class BriyahConfigService {
             this.env.DEFAULT_MARKUP_RATE = String(options.markupRate);
             process.env.DEFAULT_MARKUP_RATE = String(options.markupRate);
         }
+        if (options?.logging?.aiDebug) {
+            this.env.AI_DEBUG = 'true';
+            process.env.AI_DEBUG = 'true';
+        }
     }
     get(key, defaultValue) {
         const value = this.env[key];

package/dist-sdk/server/src/story/story.service.d.ts

@@ -77,14 +77,21 @@ export declare class StoryService {
     private compactAgentHistories;
     private extractMarkdownContent;
     private updatePlotPlan;
+    private publishInventoryArtifact;
+    private applyInventoryUpdates;
     private updateCharacterProfiles;
     private getImageModelConfig;
+    private getImagePropertiesForAgent;
     private createArtistAgent;
     private generateCharacterPortrait;
+    private generatePortraitForName;
     private updateCharacterPortrait;
     private generateSceneIllustration;
+    private ensureMinorCharacterPortraits;
     private generateSceneReference;
     private generateStoryImage;
+    private parseNarratorPreamble;
+    private formatDisplaySituation;
     private updateStorySituation;
     generateStoryMarkdown(storyId: string): Promise<string>;
     exportStoryData(storyId: string): Promise<{