@ouro.bot/cli 0.1.0-alpha.50 → 0.1.0-alpha.52

package/dist/repertoire/tools.js

@@ -35,9 +35,11 @@ function blockedLocalToolMessage() {
     return "I can't do that because my trust level with you isn't high enough for local shell/file operations. Ask me for a remote-safe alternative (Graph/ADO/web), or run that operation from CLI.";
 }
 function baseToolsForCapabilities(capabilities, context) {
+    // Use baseToolDefinitions at call time so dynamically-added tools are included
+    const currentTools = tools_base_1.baseToolDefinitions.map((d) => d.tool);
     if (!shouldBlockLocalTools(capabilities, context))
-        return tools_base_1.tools;
-    return tools_base_1.tools.filter((tool) => !exports.REMOTE_BLOCKED_LOCAL_TOOLS.has(tool.function.name));
+        return currentTools;
+    return currentTools.filter((tool) => !exports.REMOTE_BLOCKED_LOCAL_TOOLS.has(tool.function.name));
 }
 // Apply a single tool preference to a tool schema, returning a new object.
 function applyPreference(tool, pref) {
@@ -49,37 +51,55 @@ function applyPreference(tool, pref) {
         },
     };
 }
+// Filter out tools whose requiredCapability is not in the provider's capability set.
+// Uses baseToolDefinitions at call time so dynamically-added tools are included.
+// Only base tools can have requiredCapability (integration tools do not).
+function filterByCapability(toolList, providerCapabilities) {
+    return toolList.filter((tool) => {
+        const def = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === tool.function.name);
+        if (!def?.requiredCapability)
+            return true;
+        return providerCapabilities?.has(def.requiredCapability) === true;
+    });
+}
 // Return the appropriate tools list based on channel capabilities.
 // Base tools (no integration) are always included.
 // Teams/integration tools are included only if their integration is in availableIntegrations.
 // When toolPreferences is provided, matching preferences are appended to tool descriptions.
-function getToolsForChannel(capabilities, toolPreferences, context) {
+// When providerCapabilities is provided, tools with requiredCapability are filtered.
+function getToolsForChannel(capabilities, toolPreferences, context, providerCapabilities) {
     const baseTools = baseToolsForCapabilities(capabilities, context);
     const bluebubblesTools = capabilities?.channel === "bluebubbles"
         ? tools_bluebubbles_1.bluebubblesToolDefinitions.map((d) => d.tool)
         : [];
+    let result;
     if (!capabilities || capabilities.availableIntegrations.length === 0) {
-        return [...baseTools, ...bluebubblesTools];
+        result = [...baseTools, ...bluebubblesTools];
     }
-    const available = new Set(capabilities.availableIntegrations);
-    const channelDefs = [...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
-    // Include tools whose integration is available, plus channel tools with no integration gate (e.g. teams_send_message)
-    const integrationDefs = channelDefs.filter((d) => d.integration ? available.has(d.integration) : capabilities.channel === "teams");
-    if (!toolPreferences || Object.keys(toolPreferences).length === 0) {
-        return [...baseTools, ...bluebubblesTools, ...integrationDefs.map((d) => d.tool)];
+    else {
+        const available = new Set(capabilities.availableIntegrations);
+        const channelDefs = [...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
+        // Include tools whose integration is available, plus channel tools with no integration gate (e.g. teams_send_message)
+        const integrationDefs = channelDefs.filter((d) => d.integration ? available.has(d.integration) : capabilities.channel === "teams");
+        if (!toolPreferences || Object.keys(toolPreferences).length === 0) {
+            result = [...baseTools, ...bluebubblesTools, ...integrationDefs.map((d) => d.tool)];
+        }
+        else {
+            // Build a map of integration -> preference text for fast lookup
+            const prefMap = new Map();
+            for (const [key, value] of Object.entries(toolPreferences)) {
+                prefMap.set(key, value);
+            }
+            // Apply preferences to matching integration tools (new objects, no mutation)
+            // d.integration is guaranteed truthy -- integrationDefs are pre-filtered above
+            const enrichedIntegrationTools = integrationDefs.map((d) => {
+                const pref = prefMap.get(d.integration);
+                return pref ? applyPreference(d.tool, pref) : d.tool;
+            });
+            result = [...baseTools, ...bluebubblesTools, ...enrichedIntegrationTools];
+        }
     }
-    // Build a map of integration -> preference text for fast lookup
-    const prefMap = new Map();
-    for (const [key, value] of Object.entries(toolPreferences)) {
-        prefMap.set(key, value);
-    }
-    // Apply preferences to matching integration tools (new objects, no mutation)
-    // d.integration is guaranteed truthy -- integrationDefs are pre-filtered above
-    const enrichedIntegrationTools = integrationDefs.map((d) => {
-        const pref = prefMap.get(d.integration);
-        return pref ? applyPreference(d.tool, pref) : d.tool;
-    });
-    return [...baseTools, ...bluebubblesTools, ...enrichedIntegrationTools];
+    return filterByCapability(result, providerCapabilities);
 }
 // Check whether a tool requires user confirmation before execution.
 // Reads from ToolDefinition.confirmationRequired instead of a separate Set.
@@ -192,6 +212,8 @@ function summarizeArgs(name, args) {
         return summarizeKeyValues(args, ["sessionId"]);
     if (name === "bluebubbles_set_reply_target")
         return summarizeKeyValues(args, ["target", "threadOriginatorGuid"]);
+    if (name === "set_reasoning_effort")
+        return summarizeKeyValues(args, ["level"]);
     if (name === "claude")
         return summarizeKeyValues(args, ["prompt"]);
     if (name === "web_search")

package/dist/senses/bluebubbles.js

@@ -48,6 +48,7 @@ const identity_1 = require("../heart/identity");
 const turn_coordinator_1 = require("../heart/turn-coordinator");
 const context_1 = require("../mind/context");
 const tokens_1 = require("../mind/friends/tokens");
+const group_context_1 = require("../mind/friends/group-context");
 const resolver_1 = require("../mind/friends/resolver");
 const store_file_1 = require("../mind/friends/store-file");
 const types_1 = require("../mind/friends/types");
@@ -97,6 +98,10 @@ function resolveFriendParams(event) {
         channel: "bluebubbles",
     };
 }
+function resolveGroupExternalId(event) {
+    const groupKey = event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.sender.externalId;
+    return `group:${groupKey}`;
+}
 /**
  * Check if any participant in a group chat is a known family member.
  * Looks up each participant handle in the friend store.
@@ -585,6 +590,16 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                 return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
             }
         }
+        if (event.kind === "message" && event.chat.isGroup) {
+            await (0, group_context_1.upsertGroupContextParticipants)({
+                store,
+                participants: (event.chat.participantHandles ?? []).map((externalId) => ({
+                    provider: "imessage-handle",
+                    externalId,
+                })),
+                groupExternalId: resolveGroupExternalId(event),
+            });
+        }
         // Build inbound user message (adapter concern: BB-specific content formatting)
         const userMessage = {
             role: "user",
@@ -842,21 +857,33 @@ function findImessageHandle(friend) {
     }
     return undefined;
 }
+function normalizeBlueBubblesSessionKey(sessionKey) {
+    const trimmed = sessionKey.trim();
+    if (trimmed.startsWith("chat_identifier_")) {
+        return `chat_identifier:${trimmed.slice("chat_identifier_".length)}`;
+    }
+    if (trimmed.startsWith("chat_")) {
+        return `chat:${trimmed.slice("chat_".length)}`;
+    }
+    return trimmed;
+}
 function extractChatIdentifierFromSessionKey(sessionKey) {
-    if (sessionKey.startsWith("chat:")) {
-        const chatGuid = sessionKey.slice("chat:".length).trim();
+    const normalizedKey = normalizeBlueBubblesSessionKey(sessionKey);
+    if (normalizedKey.startsWith("chat:")) {
+        const chatGuid = normalizedKey.slice("chat:".length).trim();
         const parts = chatGuid.split(";");
         return parts.length >= 3 ? parts[2]?.trim() || undefined : undefined;
     }
-    if (sessionKey.startsWith("chat_identifier:")) {
-        const identifier = sessionKey.slice("chat_identifier:".length).trim();
+    if (normalizedKey.startsWith("chat_identifier:")) {
+        const identifier = normalizedKey.slice("chat_identifier:".length).trim();
         return identifier || undefined;
     }
     return undefined;
 }
 function buildChatRefForSessionKey(friend, sessionKey) {
-    if (sessionKey.startsWith("chat:")) {
-        const chatGuid = sessionKey.slice("chat:".length).trim();
+    const normalizedKey = normalizeBlueBubblesSessionKey(sessionKey);
+    if (normalizedKey.startsWith("chat:")) {
+        const chatGuid = normalizedKey.slice("chat:".length).trim();
         if (!chatGuid)
             return null;
         return {
@@ -900,12 +927,20 @@ async function sendProactiveBlueBubblesMessageToSession(params, deps = {}) {
         });
         return { delivered: false, reason: "friend_not_found" };
     }
-    if (!types_1.TRUSTED_LEVELS.has(friend.trustLevel ?? "stranger")) {
+    const explicitCrossChatAuthorized = params.intent === "explicit_cross_chat"
+        && types_1.TRUSTED_LEVELS.has(params.authorizingSession?.trustLevel ?? "stranger");
+    if (!explicitCrossChatAuthorized && !types_1.TRUSTED_LEVELS.has(friend.trustLevel ?? "stranger")) {
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.bluebubbles_proactive_trust_skip",
             message: "proactive send skipped: trust level not allowed",
-            meta: { friendId: params.friendId, sessionKey: params.sessionKey, trustLevel: friend.trustLevel ?? "unknown" },
+            meta: {
+                friendId: params.friendId,
+                sessionKey: params.sessionKey,
+                trustLevel: friend.trustLevel ?? "unknown",
+                intent: params.intent ?? "generic_outreach",
+                authorizingTrustLevel: params.authorizingSession?.trustLevel ?? null,
+            },
         });
         return { delivered: false, reason: "trust_skip" };
     }

package/dist/senses/pipeline.js

@@ -14,6 +14,7 @@ const tasks_1 = require("../repertoire/tasks");
 const session_activity_1 = require("../heart/session-activity");
 const active_work_1 = require("../heart/active-work");
 const delegation_1 = require("../heart/delegation");
+const target_resolution_1 = require("../heart/target-resolution");
 const thoughts_1 = require("../heart/daemon/thoughts");
 const pending_1 = require("../mind/pending");
 function emptyTaskBoard() {
@@ -137,6 +138,26 @@ async function handleInboundTurn(input) {
     catch {
         sessionActivity = [];
     }
+    let targetCandidates = [];
+    try {
+        if (input.channel !== "inner") {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            targetCandidates = await (0, target_resolution_1.listTargetSessionCandidates)({
+                sessionsDir: `${agentRoot}/state/sessions`,
+                friendsDir: `${agentRoot}/friends`,
+                agentName: (0, identity_1.getAgentName)(),
+                currentSession: {
+                    friendId: currentSession.friendId,
+                    channel: currentSession.channel,
+                    key: currentSession.key,
+                },
+                friendStore: input.friendStore,
+            });
+        }
+    }
+    catch {
+        targetCandidates = [];
+    }
     const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
         currentSession,
         currentObligation,
@@ -152,6 +173,7 @@ async function handleInboundTurn(input) {
             }
         })(),
         friendActivity: sessionActivity,
+        targetCandidates,
     });
     const delegationDecision = (0, delegation_1.decideDelegation)({
         channel: input.channel,

package/dist/senses/teams.js

@@ -40,6 +40,7 @@ exports.createTeamsCallbacks = createTeamsCallbacks;
 exports.resolvePendingConfirmation = resolvePendingConfirmation;
 exports.withConversationLock = withConversationLock;
 exports.handleTeamsMessage = handleTeamsMessage;
+exports.sendProactiveTeamsMessageToSession = sendProactiveTeamsMessageToSession;
 exports.drainAndSendPendingTeams = drainAndSendPendingTeams;
 exports.startTeamsApp = startTeamsApp;
 const fs = __importStar(require("fs"));
@@ -867,6 +868,98 @@ function findAadObjectId(friend) {
     }
     return undefined;
 }
+function resolveTeamsFriendStore(deps) {
+    return deps.store
+        ?? deps.createFriendStore?.()
+        ?? new store_file_1.FileFriendStore(path.join((0, identity_1.getAgentRoot)(), "friends"));
+}
+function getTeamsConversations(botApi) {
+    return botApi.conversations;
+}
+function hasExplicitCrossChatAuthorization(params) {
+    return params.intent === "explicit_cross_chat"
+        && types_1.TRUSTED_LEVELS.has(params.authorizingSession?.trustLevel ?? "stranger");
+}
+async function sendProactiveTeamsMessageToSession(params, deps) {
+    const store = resolveTeamsFriendStore(deps);
+    const conversations = getTeamsConversations(deps.botApi);
+    let friend;
+    try {
+        friend = await store.get(params.friendId);
+    }
+    catch {
+        friend = null;
+    }
+    if (!friend) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.teams_proactive_no_friend",
+            message: "proactive send skipped: friend not found",
+            meta: { friendId: params.friendId, sessionKey: params.sessionKey },
+        });
+        return { delivered: false, reason: "friend_not_found" };
+    }
+    if (!hasExplicitCrossChatAuthorization(params) && !types_1.TRUSTED_LEVELS.has(friend.trustLevel ?? "stranger")) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.teams_proactive_trust_skip",
+            message: "proactive send skipped: trust level not allowed",
+            meta: {
+                friendId: params.friendId,
+                trustLevel: friend.trustLevel ?? "unknown",
+                intent: params.intent ?? "generic_outreach",
+                authorizingTrustLevel: params.authorizingSession?.trustLevel ?? null,
+            },
+        });
+        return { delivered: false, reason: "trust_skip" };
+    }
+    const aadInfo = findAadObjectId(friend);
+    if (!aadInfo) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.teams_proactive_no_aad_id",
+            message: "proactive send skipped: no AAD object ID found",
+            meta: { friendId: params.friendId, sessionKey: params.sessionKey },
+        });
+        return { delivered: false, reason: "missing_target" };
+    }
+    try {
+        const conversation = await conversations.create({
+            bot: { id: deps.botApi.id },
+            members: [{ id: aadInfo.aadObjectId, role: "user", name: friend.name || aadInfo.aadObjectId }],
+            tenantId: aadInfo.tenantId,
+            isGroup: false,
+        });
+        await conversations.activities(conversation.id).create({
+            type: "message",
+            text: params.text,
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.teams_proactive_sent",
+            message: "proactive teams message sent",
+            meta: { friendId: params.friendId, aadObjectId: aadInfo.aadObjectId, sessionKey: params.sessionKey },
+        });
+        return { delivered: true };
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.teams_proactive_send_error",
+            message: "proactive teams send failed",
+            meta: {
+                friendId: params.friendId,
+                aadObjectId: aadInfo.aadObjectId,
+                sessionKey: params.sessionKey,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return { delivered: false, reason: "send_error" };
+    }
+}
 function scanPendingTeamsFiles(pendingRoot) {
     const results = [];
     let friendIds;
@@ -912,8 +1005,7 @@ async function drainAndSendPendingTeams(store, botApi, pendingRoot) {
     const root = pendingRoot ?? path.join((0, identity_1.getAgentRoot)(), "state", "pending");
     const pendingFiles = scanPendingTeamsFiles(root);
     const result = { sent: 0, skipped: 0, failed: 0 };
-    const conversations = botApi.conversations;
-    for (const { friendId, filePath, content } of pendingFiles) {
+    for (const { friendId, key, filePath, content } of pendingFiles) {
         let parsed;
         try {
             parsed = JSON.parse(content);
@@ -935,95 +1027,32 @@ async function drainAndSendPendingTeams(store, botApi, pendingRoot) {
             catch { /* ignore */ }
             continue;
         }
-        let friend;
-        try {
-            friend = await store.get(friendId);
-        }
-        catch {
-            friend = null;
-        }
-        if (!friend) {
-            result.skipped++;
-            try {
-                fs.unlinkSync(filePath);
-            }
-            catch { /* ignore */ }
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                component: "senses",
-                event: "senses.teams_proactive_no_friend",
-                message: "proactive send skipped: friend not found",
-                meta: { friendId },
-            });
-            continue;
-        }
-        if (!types_1.TRUSTED_LEVELS.has(friend.trustLevel ?? "stranger")) {
-            result.skipped++;
+        const sendResult = await sendProactiveTeamsMessageToSession({
+            friendId,
+            sessionKey: key,
+            text: messageText,
+            intent: "generic_outreach",
+        }, {
+            botApi,
+            store,
+        });
+        if (sendResult.delivered) {
+            result.sent++;
             try {
                 fs.unlinkSync(filePath);
             }
             catch { /* ignore */ }
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.teams_proactive_trust_skip",
-                message: "proactive send skipped: trust level not allowed",
-                meta: { friendId, trustLevel: friend.trustLevel ?? "unknown" },
-            });
             continue;
         }
-        const aadInfo = findAadObjectId(friend);
-        if (!aadInfo) {
+        if (sendResult.reason === "friend_not_found" || sendResult.reason === "trust_skip" || sendResult.reason === "missing_target") {
             result.skipped++;
             try {
                 fs.unlinkSync(filePath);
             }
             catch { /* ignore */ }
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                component: "senses",
-                event: "senses.teams_proactive_no_aad_id",
-                message: "proactive send skipped: no AAD object ID found",
-                meta: { friendId },
-            });
             continue;
         }
-        try {
-            const conversation = await conversations.create({
-                bot: { id: botApi.id },
-                members: [{ id: aadInfo.aadObjectId, role: "user", name: friend.name || aadInfo.aadObjectId }],
-                tenantId: aadInfo.tenantId,
-                isGroup: false,
-            });
-            await conversations.activities(conversation.id).create({
-                type: "message",
-                text: messageText,
-            });
-            result.sent++;
-            try {
-                fs.unlinkSync(filePath);
-            }
-            catch { /* ignore */ }
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.teams_proactive_sent",
-                message: "proactive teams message sent",
-                meta: { friendId, aadObjectId: aadInfo.aadObjectId },
-            });
-        }
-        catch (error) {
-            result.failed++;
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                component: "senses",
-                event: "senses.teams_proactive_send_error",
-                message: "proactive teams send failed",
-                meta: {
-                    friendId,
-                    aadObjectId: aadInfo.aadObjectId,
-                    reason: error instanceof Error ? error.message : String(error),
-                },
-            });
-        }
+        result.failed++;
     }
     if (result.sent > 0 || result.skipped > 0 || result.failed > 0) {
         (0, runtime_1.emitNervesEvent)({

package/package.json

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