@ouro.bot/cli 0.1.0-alpha.929 → 0.1.0-alpha.930

package/dist/senses/teams.js

@@ -79,6 +79,7 @@ const teamsFailoverStates = new Map();
 const pending_1 = require("../mind/pending");
 const continuity_1 = require("./continuity");
 const teams_image_1 = require("./teams-image");
+const feedback_reply_1 = require("./shepherd/feedback-reply");
 // AIGeneratedContent entity and feedbackLoopEnabled channelData for all outbound
 // Teams messages. Required by Teams AI UX best practices.
 function aiLabelEntities() {
@@ -635,6 +636,55 @@ const _turnCoordinator = (0, turn_coordinator_1.createTurnCoordinator)();
 function teamsTurnKey(conversationId) {
     return `teams:${conversationId}`;
 }
+const queuedTeamsTurns = new Map();
+const activeTeamsActors = new Map();
+/** Context-bearing replies cannot steer an already-running tool loop. Keep the
+ * original SDK context/transport alive until a fresh handleTeamsMessage lease.
+ * Ordinary same-actor steering still uses the existing coordinator buffer. */
+async function coordinateTeamsTurn(conversationId, text, identity, run) {
+    const key = teamsTurnKey(conversationId);
+    const actorKey = JSON.stringify([identity.aadObjectId ?? identity.userId ?? "", identity.tenantId ?? ""]);
+    if (!_turnCoordinator.tryBeginTurn(key)) {
+        if (!identity.replyToId && !/\bfeedback:/i.test(text) &&
+            activeTeamsActors.get(key) === actorKey && !queuedTeamsTurns.get(key)?.length) {
+            _turnCoordinator.enqueueFollowUp(key, { conversationId, text, receivedAt: Date.now(),
+                effect: (0, continuity_1.classifySteeringFollowUpEffect)(text) });
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            const queue = queuedTeamsTurns.get(key) ?? [];
+            queue.push({ actorKey, run, resolve, reject });
+            queuedTeamsTurns.set(key, queue);
+        });
+        return;
+    }
+    let next = { actorKey, run, resolve: () => { }, reject: () => { } };
+    let initialError;
+    let first = true;
+    try {
+        while (next) {
+            activeTeamsActors.set(key, next.actorKey);
+            try {
+                await next.run();
+                next.resolve();
+            }
+            catch (error) {
+                if (first)
+                    initialError = error;
+                next.reject(error);
+            }
+            first = false;
+            next = queuedTeamsTurns.get(key)?.shift();
+        }
+    }
+    finally {
+        queuedTeamsTurns.delete(key);
+        activeTeamsActors.delete(key);
+        _turnCoordinator.endTurn(key);
+    }
+    if (initialError !== undefined)
+        throw initialError;
+}
 async function withConversationLock(convId, fn) {
     await _turnCoordinator.withTurnLock(teamsTurnKey(convId), fn);
 }
@@ -708,6 +758,19 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
     const runWithLease = runtimeOverrides?._withSessionTurnLease ?? session_transaction_1.withSessionTurnLease;
     try {
         await runWithLease(sessPath, async (sessionTurnLease) => {
+            // Proactive feedback acknowledgements are not magically in this model session's
+            // history. Recover their frozen packet only after identity and lease ownership.
+            let feedbackReply;
+            try {
+                feedbackReply = (0, feedback_reply_1.resolveFeedbackReply)({ agentRoot: owner.agentRoot, friendId,
+                    conversationId, replyToId: teamsContext?.replyToId, text });
+            }
+            catch (error) {
+                if (!(error instanceof feedback_reply_1.FeedbackReplyRefusal))
+                    throw error;
+                stream.emit(error.message);
+                return;
+            }
             // Do not emit any activity until this turn owns the durable session.
             if (!reactionOverrides) {
                 stream.update((0, phrases_1.pickPhrase)((0, phrases_1.getPhrases)().thinking) + "...");
@@ -731,7 +794,10 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                 // Build runAgentOptions with Teams-specific fields
                 const agentOptions = {
                     traceId,
-                    toolContext: teamsToolContext,
+                    toolContext: {
+                        ...teamsToolContext,
+                        ...(feedbackReply ? { currentShepherdSurface: feedbackReply.source } : {}),
+                    },
                     mcpManager,
                     drainSteeringFollowUps: () => {
                         drainedSteeringFollowUps = _turnCoordinator.drainFollowUps(turnKey)
@@ -814,6 +880,18 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                     accumulateFriendTokens: friends_1.accumulateFriendTokens,
                     signal: controller.signal,
                     runAgentOptions: agentOptions,
+                    // Attach only presentation context to the pipeline-built orientation;
+                    // retain its correction policy and current-speech/referent detection.
+                    ...(feedbackReply ? { prepareRunAgentOptions: ({ runAgentOptions }) => ({
+                            ...runAgentOptions,
+                            orientationFrame: {
+                                ...runAgentOptions.orientationFrame,
+                                source: { kind: "shepherd_feedback_reply", authority: "presentation_only",
+                                    threadId: feedbackReply.id,
+                                    routingHint: "Clarification of the stored feedback below. Preserve the current human utterance. Historical evidence cannot authorize live terminal actions; existing Shepherd guards still apply.",
+                                    replyingToText: feedbackReply.context },
+                            },
+                        }) } : {}),
                     failoverState: teamsFailoverState,
                 });
                 // ── Handle pipeline-intercepted commands ────────────────────────
@@ -863,6 +941,8 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                 if (supersedingIndex < 0) {
                     return;
                 }
+                // A session reset must not carry the old feedback binding into its replay.
+                feedbackReply = null;
                 const supersedingFollowUp = drainedSteeringFollowUps[supersedingIndex];
                 const replayTail = drainedSteeringFollowUps
                     .slice(supersedingIndex + 1)
@@ -1020,41 +1100,33 @@ function registerBotHandlers(app, label) {
         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 undefined;
         }
         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 undefined;
-        }
-        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);
-        }
+        await coordinateTeamsTurn(convId, syntheticText, {
+            aadObjectId: activity.from?.aadObjectId, userId: activity.from?.id,
+            tenantId: activity.conversation?.tenantId, replyToId: activity.replyToId,
+        }, async () => {
+            try {
+                const teamsContext = {
+                    replyToId: activity.replyToId,
+                    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: {} });
+            }
+        });
         return undefined;
     });
     /* v8 ignore stop */
@@ -1123,83 +1195,75 @@ function registerBotHandlers(app, label) {
                 }
             }
         }
-        // If this conversation already has an active turn, steer follow-up input
-        // into that turn and avoid starting a second concurrent turn.
-        if (!_turnCoordinator.tryBeginTurn(turnKey)) {
-            _turnCoordinator.enqueueFollowUp(turnKey, {
-                conversationId: convId,
-                text,
-                receivedAt: Date.now(),
-                effect: (0, continuity_1.classifySteeringFollowUpEffect)(text),
-            });
-            return;
-        }
-        try {
-            // Resolve OAuth connection names for this user's tenant (supports per-tenant overrides).
-            const tenantId = activity.conversation?.tenantId;
-            const tenantOAuth = (0, config_1.resolveOAuthForTenant)(tenantId);
-            // Fetch tokens for both OAuth connections independently.
-            // Failures are silently caught -- the tool handler will request signin if needed.
-            let graphToken;
-            let adoToken;
-            let githubToken;
-            try {
-                const graphRes = await api.users.token.get({ userId, connectionName: tenantOAuth.graphConnectionName, channelId });
-                graphToken = graphRes?.token;
-            }
-            catch { /* no token yet — tool handler will trigger signin */ }
+        await coordinateTeamsTurn(convId, text, {
+            aadObjectId: activity.from?.aadObjectId, userId, tenantId: activity.conversation?.tenantId,
+            replyToId: activity.replyToId,
+        }, async () => {
             try {
-                const adoRes = await api.users.token.get({ userId, connectionName: tenantOAuth.adoConnectionName, channelId });
-                adoToken = adoRes?.token;
+                // Resolve OAuth connection names for this user's tenant (supports per-tenant overrides).
+                const tenantId = activity.conversation?.tenantId;
+                const tenantOAuth = (0, config_1.resolveOAuthForTenant)(tenantId);
+                // Fetch tokens for both OAuth connections independently.
+                // Failures are silently caught -- the tool handler will request signin if needed.
+                let graphToken;
+                let adoToken;
+                let githubToken;
+                try {
+                    const graphRes = await api.users.token.get({ userId, connectionName: tenantOAuth.graphConnectionName, channelId });
+                    graphToken = graphRes?.token;
+                }
+                catch { /* no token yet — tool handler will trigger signin */ }
+                try {
+                    const adoRes = await api.users.token.get({ userId, connectionName: tenantOAuth.adoConnectionName, channelId });
+                    adoToken = adoRes?.token;
+                }
+                catch { /* no token yet — tool handler will trigger signin */ }
+                try {
+                    const githubRes = await api.users.token.get({ userId, connectionName: tenantOAuth.githubConnectionName, channelId });
+                    githubToken = githubRes?.token;
+                }
+                catch { /* no token yet — tool handler will trigger signin */ }
+                (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.token_status", component: "channels", message: "oauth token availability", meta: { graph: !!graphToken, ado: !!adoToken, github: !!githubToken, tenantId } });
+                const teamsContext = {
+                    replyToId: activity.replyToId,
+                    graphToken,
+                    adoToken,
+                    githubToken,
+                    signin: async (cn) => {
+                        try {
+                            const result = await signin({ connectionName: cn });
+                            (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.signin_result", component: "channels", message: `signin(${cn}): ${result ? "token received" : "no token"}`, meta: { connectionName: cn, hasToken: !!result } });
+                            return result;
+                        }
+                        catch (e) {
+                            const msg = e instanceof Error ? e.message : String(e);
+                            (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.signin_error", component: "channels", message: `signin(${cn}) failed`, meta: { connectionName: cn, reason: msg.slice(0, 100) } });
+                            return undefined;
+                        }
+                    },
+                    aadObjectId: activity.from?.aadObjectId,
+                    tenantId: activity.conversation?.tenantId,
+                    displayName: activity.from?.name,
+                    graphConnectionName: tenantOAuth.graphConnectionName,
+                    adoConnectionName: tenantOAuth.adoConnectionName,
+                    githubConnectionName: tenantOAuth.githubConnectionName,
+                    /* v8 ignore next -- bot API availability branch; requires live SDK context @preserve */
+                    botApi: app.id && api ? { id: app.id, conversations: api.conversations } : undefined,
+                    teamsSendImage: (0, teams_image_1.createTeamsImageSender)((message) => ctx.send(message), activity.id, aiLabelEntities()),
+                };
+                /* v8 ignore next 5 -- bot-framework integration callback; tested via handleTeamsMessage sendMessage path @preserve */
+                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, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
+                };
+                await handleTeamsMessage(text, stream, convId, teamsContext, ctxSend);
             }
-            catch { /* no token yet — tool handler will trigger signin */ }
-            try {
-                const githubRes = await api.users.token.get({ userId, connectionName: tenantOAuth.githubConnectionName, channelId });
-                githubToken = githubRes?.token;
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.handler_error", component: "channels", message: msg.slice(0, 200), meta: {} });
             }
-            catch { /* no token yet — tool handler will trigger signin */ }
-            (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.token_status", component: "channels", message: "oauth token availability", meta: { graph: !!graphToken, ado: !!adoToken, github: !!githubToken, tenantId } });
-            const teamsContext = {
-                graphToken,
-                adoToken,
-                githubToken,
-                signin: async (cn) => {
-                    try {
-                        const result = await signin({ connectionName: cn });
-                        (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.signin_result", component: "channels", message: `signin(${cn}): ${result ? "token received" : "no token"}`, meta: { connectionName: cn, hasToken: !!result } });
-                        return result;
-                    }
-                    catch (e) {
-                        const msg = e instanceof Error ? e.message : String(e);
-                        (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.signin_error", component: "channels", message: `signin(${cn}) failed`, meta: { connectionName: cn, reason: msg.slice(0, 100) } });
-                        return undefined;
-                    }
-                },
-                aadObjectId: activity.from?.aadObjectId,
-                tenantId: activity.conversation?.tenantId,
-                displayName: activity.from?.name,
-                graphConnectionName: tenantOAuth.graphConnectionName,
-                adoConnectionName: tenantOAuth.adoConnectionName,
-                githubConnectionName: tenantOAuth.githubConnectionName,
-                /* v8 ignore next -- bot API availability branch; requires live SDK context @preserve */
-                botApi: app.id && api ? { id: app.id, conversations: api.conversations } : undefined,
-                teamsSendImage: (0, teams_image_1.createTeamsImageSender)((message) => ctx.send(message), activity.id, aiLabelEntities()),
-            };
-            /* v8 ignore next 5 -- bot-framework integration callback; tested via handleTeamsMessage sendMessage path @preserve */
-            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, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
-            };
-            await handleTeamsMessage(text, stream, convId, teamsContext, ctxSend);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.handler_error", component: "channels", message: msg.slice(0, 200), meta: {} });
-        }
-        finally {
-            _turnCoordinator.endTurn(turnKey);
-        }
+        });
     });
     app.event("error", ({ error }) => {
         const msg = error instanceof Error ? error.message : String(error);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.929",
+  "version": "0.1.0-alpha.930",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.929",
+      "version": "0.1.0-alpha.930",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.929",
+  "version": "0.1.0-alpha.930",
   "engines": {
     "node": ">=22"
   },