@ouro.bot/cli 0.1.0-alpha.146 → 0.1.0-alpha.148

package/dist/senses/teams.js

@@ -34,8 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_FLUSH_INTERVAL_MS = void 0;
+exports.aiLabelEntities = aiLabelEntities;
 exports.stripMentions = stripMentions;
 exports.splitMessage = splitMessage;
+exports.sanitizeFeedbackComment = sanitizeFeedbackComment;
+exports.buildFeedbackSyntheticText = buildFeedbackSyntheticText;
+exports.buildWelcomeCard = buildWelcomeCard;
 exports.createTeamsCallbacks = createTeamsCallbacks;
 exports.resolvePendingConfirmation = resolvePendingConfirmation;
 exports.withConversationLock = withConversationLock;
@@ -73,6 +77,16 @@ const pipeline_1 = require("./pipeline");
 const teamsFailoverStates = new Map();
 const pending_1 = require("../mind/pending");
 const continuity_1 = require("./continuity");
+// AIGeneratedContent entity and feedbackLoopEnabled channelData for all outbound
+// Teams messages. Required by Teams AI UX best practices.
+function aiLabelEntities() {
+    return [{
+            type: "https://schema.org/Message",
+            "@type": "Message",
+            "@context": "https://schema.org",
+            additionalType: ["AIGeneratedContent"],
+        }];
+}
 // Strip @mention markup from incoming messages.
 // Removes <at>...</at> tags and trims extra whitespace.
 // Fallback safety net -- the SDK's activity.mentions.stripText should handle
@@ -127,6 +141,46 @@ function splitMessage(text, maxLen) {
     }
     return chunks;
 }
+// Sanitize user-provided feedback comments: truncate, strip control chars and newlines.
+function sanitizeFeedbackComment(comment) {
+    const cleaned = comment.replace(/[\x00-\x1f\n\r]/g, "");
+    return cleaned.length > 200 ? cleaned.slice(0, 200) : cleaned;
+}
+// Build synthetic message text from a Teams feedback reaction.
+function buildFeedbackSyntheticText(reaction, comment) {
+    const emoji = reaction === "like" ? "thumbs-up" : "thumbs-down";
+    if (comment) {
+        const sanitized = sanitizeFeedbackComment(comment);
+        return `[reacted with ${emoji} to your message: "${sanitized}"]`;
+    }
+    return `[reacted with ${emoji} to your message]`;
+}
+// Build a welcome Adaptive Card with prompt starters for new bot installs.
+function buildWelcomeCard() {
+    const promptStarters = [
+        "What can you help me with?",
+        "Tell me about yourself",
+        "What's on my calendar today?",
+        "Summarize my recent emails",
+    ];
+    return {
+        type: "AdaptiveCard",
+        version: "1.5",
+        body: [
+            {
+                type: "TextBlock",
+                text: "Hey! I'm here and ready to help. Try one of these to get started, or just ask me anything.",
+                wrap: true,
+                size: "Medium",
+            },
+        ],
+        actions: promptStarters.map((prompt) => ({
+            type: "Action.Submit",
+            title: prompt,
+            data: { msteams: { type: "messageBack", text: prompt, displayText: prompt } },
+        })),
+    };
+}
 // Create Teams-specific callbacks for the agent loop.
 // The SDK handles cumulative text, debouncing (500ms), and the streaming
 // protocol (streamSequence, streamId, informative/streaming/final types).
@@ -139,12 +193,16 @@ function splitMessage(text, maxLen) {
 // (transient status) or safeSend (terminal errors). Reasoning is accumulated
 // and periodically pushed via safeUpdate on the same flush timer tick.
 function createTeamsCallbacks(stream, controller, sendMessage, options) {
+    const MIN_INITIAL_CHARS = 20;
     let stopped = false; // set when stream signals cancellation (403)
     let hadToolRun = false;
     let hadRealOutput = false; // true once reasoning/tool output shown; suppresses phrases
     let reasoningBuf = ""; // accumulated reasoning text for status display
+    let totalEmitted = 0; // cumulative chars emitted via safeEmit (for >4000 finalization)
+    let streamFinalized = false; // true after stream.close() — subsequent flushes go to safeSend
     let textBuffer = ""; // accumulated text output for chunked streaming
     let streamHasContent = false; // tracks whether primary output has received content
+    let firstContentEmitted = false; // true after first content push — disables MIN_INITIAL_CHARS threshold
     let phraseTimer = null;
     let lastPhrase = "";
     let flushTimer = null;
@@ -194,15 +252,16 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
             result.catch(() => markStopped());
         }
     }
-    // Safely emit a text delta to the stream.
+    // Safely emit a text delta to the stream with AI labels.
     // On error (e.g. 403 from Teams stop button), abort the controller.
     function safeEmit(text) {
         /* v8 ignore next -- defensive guard: stopped set by prior 403; tested via flush abort path @preserve */
         if (stopped)
             return;
         try {
-            catchAsync(stream.emit(text));
+            catchAsync(stream.emit({ text, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } }));
             streamHasContent = true;
+            totalEmitted += text.length;
         }
         catch {
             markStopped();
@@ -217,7 +276,7 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         try {
             // stream.emit() is typed as void but the Teams SDK returns a Promise
             // internally (async HTTP). Cast to capture the result for awaiting.
-            const result = stream.emit(text);
+            const result = stream.emit({ text, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
             streamHasContent = true;
             if (result && typeof result.then === "function") {
                 await result;
@@ -273,11 +332,49 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
     // emitted text into a single streaming message (cumulative), so every
     // periodic flush appends to the same response — not separate messages.
     // No preemptive splitting — sends full text. Error recovery happens in flush().
+    // Hybrid MIN_INITIAL_CHARS: hold back until >= MIN_INITIAL_CHARS accumulated
+    // before the first content emit, so phrase rotation shows while real content
+    // buffers. After first emit, flush normally (no threshold).
     function flushTextBuffer() {
         if (!textBuffer)
             return;
+        if (!firstContentEmitted && textBuffer.length < MIN_INITIAL_CHARS)
+            return;
+        // Proactive >4000 finalization: if cumulative emitted + buffer >= RECOVERY_CHUNK_SIZE,
+        // finalize the stream and send overflow via safeSend (follow-up message).
+        if (!streamFinalized && totalEmitted + textBuffer.length >= RECOVERY_CHUNK_SIZE) {
+            const remaining = RECOVERY_CHUNK_SIZE - totalEmitted;
+            /* v8 ignore next 2 -- defensive: remaining always > 0 because finalization runs once @preserve */
+            if (remaining > 0)
+                safeEmit(textBuffer.slice(0, remaining));
+            try {
+                stream.close();
+            }
+            catch { /* stream may already be dead */ }
+            streamFinalized = true;
+            /* v8 ignore next -- defensive ternary: remaining always > 0 at first finalization @preserve */
+            const overflow = textBuffer.slice(remaining > 0 ? remaining : 0);
+            textBuffer = "";
+            if (overflow)
+                safeSend(overflow);
+            if (!firstContentEmitted) {
+                firstContentEmitted = true;
+                stopPhraseRotation();
+            }
+            return;
+        }
+        if (streamFinalized) {
+            // After finalization, all content goes to safeSend (follow-up messages)
+            safeSend(textBuffer);
+            textBuffer = "";
+            return;
+        }
         safeEmit(textBuffer);
         textBuffer = "";
+        if (!firstContentEmitted) {
+            firstContentEmitted = true;
+            stopPhraseRotation();
+        }
     }
     function startPhraseRotation(pool) {
         stopPhraseRotation();
@@ -320,7 +417,8 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         onTextChunk: (text) => {
             if (stopped)
                 return;
-            stopPhraseRotation();
+            // Don't stop phrase rotation here — let it continue until first content
+            // emit (handled in flushTextBuffer when MIN_INITIAL_CHARS threshold met).
             textBuffer += text;
             startFlushTimer();
         },
@@ -329,6 +427,8 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         },
         onToolStart: (name, args) => {
             stopPhraseRotation();
+            // Force-flush any accumulated text, bypassing MIN_INITIAL_CHARS threshold
+            firstContentEmitted = true;
             flushTextBuffer();
             // Emit a placeholder to satisfy the 15s Copilot timeout for initial
             // stream.emit(). Without this, long tool chains (e.g. ADO batch ops)
@@ -395,18 +495,25 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
             : undefined,
         flush: async () => {
             stopFlushTimer();
+            stopPhraseRotation();
             if (textBuffer) {
+                // Bypass MIN_INITIAL_CHARS threshold — flush delivers all remaining content
+                firstContentEmitted = true;
                 const text = textBuffer;
                 textBuffer = "";
-                if (!stopped) {
+                if (streamFinalized && sendMessage) {
+                    // Stream already finalized (>4000 path) — send remaining content as follow-up
+                    safeSend(text);
+                }
+                else if (!stopped) {
                     // Stream is alive — await the emit so we can catch async 413/failure
                     // and fall through to sendMessage recovery.
                     const ok = await tryEmit(text);
                     if (!ok)
                         markStopped();
                 }
-                if (stopped && sendMessage) {
-                    // Stream is dead — fall back to sendMessage; split on failure as recovery.
+                if (stopped && !streamFinalized && sendMessage) {
+                    // Stream is dead (not from finalization) — fall back to sendMessage; split on failure as recovery.
                     try {
                         await sendMessage(text);
                     }
@@ -417,8 +524,8 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
                     }
                 }
             }
-            else if (!streamHasContent) {
-                safeEmit("(completed with tool calls only \u2014 no text response)");
+            else if (!streamHasContent && !options?.suppressEmptyStreamMessage) {
+                safeEmit("(completed with tool calls only — no text response)");
             }
         },
     };
@@ -485,14 +592,17 @@ function handleTeamsSlashCommand(text, registry, friendId, conversationId, strea
     return null;
 }
 // Handle an incoming Teams message
-async function handleTeamsMessage(text, stream, conversationId, teamsContext, sendMessage) {
+async function handleTeamsMessage(text, stream, conversationId, teamsContext, sendMessage, reactionOverrides) {
     const turnKey = teamsTurnKey(conversationId);
     // NOTE: Confirmation resolution is handled in the app.on("message") handler
     // BEFORE the conversation lock.  By the time we get here, any pending
     // confirmation has already been resolved and the reply consumed.
     // Send first thinking phrase immediately so the user sees feedback
     // before sync I/O (session load, trim) blocks the event loop.
-    stream.update((0, phrases_1.pickPhrase)((0, phrases_1.getPhrases)().thinking) + "...");
+    // Skip for reaction signals — they should be processed quietly.
+    if (!reactionOverrides) {
+        stream.update((0, phrases_1.pickPhrase)((0, phrases_1.getPhrases)().thinking) + "...");
+    }
     await new Promise(r => setImmediate(r));
     // Resolve identity provider early for friend resolution + slash command session path
     const store = getFriendStore();
@@ -517,7 +627,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
     // ── Teams adapter concerns: controller, callbacks, session path ──────────
     const controller = new AbortController();
     const channelConfig = (0, config_2.getTeamsChannelConfig)();
-    const callbacks = createTeamsCallbacks(stream, controller, sendMessage, { conversationId, flushIntervalMs: channelConfig.flushIntervalMs });
+    const callbacks = createTeamsCallbacks(stream, controller, sendMessage, { conversationId, flushIntervalMs: channelConfig.flushIntervalMs, ...(reactionOverrides?.suppressEmptyStreamMessage ? { suppressEmptyStreamMessage: true } : {}) });
     const traceId = (0, nerves_1.createTraceId)();
     const sessPath = (0, config_2.sessionPath)(friendId, "teams", conversationId);
     const teamsCapabilities = (0, channel_1.getChannelCapabilities)("teams");
@@ -546,6 +656,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                     .map(({ text: followUpText, effect }) => ({ text: followUpText, effect }));
                 return drainedSteeringFollowUps;
             },
+            ...(reactionOverrides?.isReactionSignal ? { isReactionSignal: true } : {}),
         };
         if (channelConfig.skipConfirmation)
             agentOptions.skipConfirmation = true;
@@ -765,6 +876,72 @@ function registerBotHandlers(app, label) {
         (0, runtime_1.emitNervesEvent)({ level: "warn", event: "channel.verify_state", component: "channels", message: `[${label}] verify-state failed for all connections`, meta: {} });
         return { status: 412 };
     });
+    // Handle Teams feedback reactions (thumbs up/down on AI-generated messages).
+    // SDK routes message/submitAction with actionName "feedback" to this event.
+    /* v8 ignore start -- Teams SDK invoke handler; requires live SDK context @preserve */
+    app.on("message.submit.feedback", async (ctx) => {
+        const { stream, activity } = ctx;
+        const reaction = activity.value?.actionValue?.reaction;
+        const comment = activity.value?.actionValue?.feedback;
+        const convId = activity.conversation?.id || "unknown";
+        const turnKey = teamsTurnKey(convId);
+        // Validate payload — graceful no-op for malformed invocations
+        if (activity.value?.actionName !== "feedback" || !reaction) {
+            return;
+        }
+        const syntheticText = buildFeedbackSyntheticText(reaction, comment);
+        // Turn coordination: if a turn is active, enqueue as steering follow-up
+        if (!_turnCoordinator.tryBeginTurn(turnKey)) {
+            _turnCoordinator.enqueueFollowUp(turnKey, {
+                conversationId: convId,
+                text: syntheticText,
+                receivedAt: Date.now(),
+                effect: (0, continuity_1.classifySteeringFollowUpEffect)(syntheticText),
+            });
+            return;
+        }
+        try {
+            const teamsContext = {
+                signin: async () => undefined,
+                aadObjectId: activity.from?.aadObjectId,
+                tenantId: activity.conversation?.tenantId,
+                displayName: activity.from?.name,
+            };
+            const ctxSend = async (t) => {
+                await ctx.send({ type: "message", text: t, replyToId: activity.replyToId, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
+            };
+            await handleTeamsMessage(syntheticText, stream, convId, teamsContext, ctxSend, { isReactionSignal: true, suppressEmptyStreamMessage: true });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.feedback_handler_error", component: "channels", message: msg.slice(0, 200), meta: {} });
+        }
+        finally {
+            _turnCoordinator.endTurn(turnKey);
+        }
+    });
+    /* v8 ignore stop */
+    // Handle bot install — send welcome Adaptive Card with prompt starters.
+    /* v8 ignore start -- Teams SDK install handler; requires live SDK context @preserve */
+    app.on("install.add", async (ctx) => {
+        try {
+            const card = buildWelcomeCard();
+            await ctx.send({
+                type: "message",
+                attachments: [{
+                        contentType: "application/vnd.microsoft.card.adaptive",
+                        content: card,
+                    }],
+                entities: aiLabelEntities(),
+                channelData: { feedbackLoopEnabled: true },
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.welcome_handler_error", component: "channels", message: msg.slice(0, 200), meta: {} });
+        }
+    });
+    /* v8 ignore stop */
     app.on("message", async (ctx) => {
         const { stream, activity, api, signin } = ctx;
         const text = activity.text || "";
@@ -880,7 +1057,7 @@ function registerBotHandlers(app, label) {
             const ctxSend = async (t) => {
                 // Use send with replyToId (not reply, which adds a blockquote).
                 // replyToId anchors the message after the user's message in Copilot Chat.
-                await ctx.send({ type: "message", text: t, replyToId: activity.id });
+                await ctx.send({ type: "message", text: t, replyToId: activity.id, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
             };
             await handleTeamsMessage(text, stream, convId, teamsContext, ctxSend);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.146",
+  "version": "0.1.0-alpha.148",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",

package/dist/heart/daemon/heartbeat-timer.js

@@ -1,132 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HeartbeatTimer = exports.DEFAULT_CADENCE_MS = void 0;
-exports.parseCadenceMs = parseCadenceMs;
-const runtime_1 = require("../../nerves/runtime");
-const parser_1 = require("../../repertoire/tasks/parser");
-exports.DEFAULT_CADENCE_MS = 30 * 60 * 1000; // 30 minutes
-function parseCadenceMs(raw) {
-    if (typeof raw !== "string")
-        return null;
-    const value = raw.trim();
-    if (!value)
-        return null;
-    const match = /^(\d+)(m|h|d)$/.exec(value);
-    if (!match)
-        return null;
-    const interval = Number.parseInt(match[1], 10);
-    if (!Number.isFinite(interval) || interval <= 0)
-        return null;
-    const unit = match[2];
-    if (unit === "m")
-        return interval * 60 * 1000;
-    if (unit === "h")
-        return interval * 60 * 60 * 1000;
-    return interval * 24 * 60 * 60 * 1000;
-}
-class HeartbeatTimer {
-    agent;
-    sendToAgent;
-    readFileSync;
-    readdirSync;
-    heartbeatTaskDir;
-    runtimeStatePath;
-    now;
-    pendingTimer = null;
-    constructor(options) {
-        this.agent = options.agent;
-        this.sendToAgent = options.sendToAgent;
-        this.readFileSync = options.deps.readFileSync;
-        this.readdirSync = options.deps.readdirSync;
-        this.heartbeatTaskDir = options.deps.heartbeatTaskDir;
-        this.runtimeStatePath = options.deps.runtimeStatePath;
-        this.now = options.deps.now ?? (() => Date.now());
-    }
-    start() {
-        this.scheduleNext();
-    }
-    stop() {
-        if (this.pendingTimer !== null) {
-            clearTimeout(this.pendingTimer);
-            this.pendingTimer = null;
-        }
-    }
-    scheduleNext() {
-        const cadenceMs = this.readCadence();
-        const lastCompletedAt = this.readLastCompletedAt();
-        const nowMs = this.now();
-        let delay;
-        if (lastCompletedAt === null) {
-            // Never run before — fire once after a full cadence (not immediately, to avoid spin loop
-            // when the agent has no inner dialog state to write lastCompletedAt)
-            delay = cadenceMs;
-        }
-        else {
-            const elapsed = nowMs - lastCompletedAt;
-            delay = Math.max(0, cadenceMs - elapsed);
-        }
-        this.pendingTimer = setTimeout(() => {
-            this.fire();
-        }, delay);
-    }
-    fire() {
-        this.pendingTimer = null;
-        (0, runtime_1.emitNervesEvent)({
-            component: "daemon",
-            event: "daemon.heartbeat_fire",
-            message: "heartbeat timer fired",
-            meta: { agent: this.agent },
-        });
-        this.sendToAgent(this.agent, { type: "heartbeat" });
-        this.scheduleNext();
-    }
-    readCadence() {
-        // Scan habits dir for *-heartbeat.md
-        let files;
-        try {
-            files = this.readdirSync(this.heartbeatTaskDir);
-        }
-        catch {
-            return exports.DEFAULT_CADENCE_MS;
-        }
-        const heartbeatFile = files.find((f) => f.endsWith("-heartbeat.md"));
-        if (!heartbeatFile)
-            return exports.DEFAULT_CADENCE_MS;
-        try {
-            const content = this.readFileSync(`${this.heartbeatTaskDir}/${heartbeatFile}`, "utf-8");
-            const cadence = this.extractCadenceFromTaskFile(content);
-            return cadence ?? exports.DEFAULT_CADENCE_MS;
-        }
-        catch {
-            return exports.DEFAULT_CADENCE_MS;
-        }
-    }
-    extractCadenceFromTaskFile(content) {
-        // Parse frontmatter from task file to get cadence value
-        const lines = content.split(/\r?\n/);
-        if (lines[0]?.trim() !== "---")
-            return null;
-        const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
-        if (closing === -1)
-            return null;
-        const rawFrontmatter = lines.slice(1, closing).join("\n");
-        const frontmatter = (0, parser_1.parseFrontmatter)(rawFrontmatter);
-        return parseCadenceMs(frontmatter.cadence);
-    }
-    readLastCompletedAt() {
-        try {
-            const raw = this.readFileSync(this.runtimeStatePath, "utf-8");
-            const state = JSON.parse(raw);
-            if (typeof state.lastCompletedAt !== "string")
-                return null;
-            const ms = new Date(state.lastCompletedAt).getTime();
-            if (Number.isNaN(ms))
-                return null;
-            return ms;
-        }
-        catch {
-            return null;
-        }
-    }
-}
-exports.HeartbeatTimer = HeartbeatTimer;