@ouro.bot/cli 0.1.0-alpha.927 → 0.1.0-alpha.928

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.928",
+      "changes": [
+        "Teams can send private local PNG and JPEG images into the current conversation, with bounded inline bytes, family trust, no-send enforcement and honest activity receipts.",
+        "Preserves the existing Teams integration schema order when adding inline image delivery.",
+        "Records private-image preparation and Teams acceptance in structured telemetry without logging image bytes, paths or captions."
+      ]
+    },
     {
       "version": "0.1.0-alpha.927",
       "changes": [

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.927",
+  "runtimeVersion": "0.1.0-alpha.928",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-09-03T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>ouro-butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.927</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.928</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/heart/attachments/image-normalize.js

@@ -101,10 +101,14 @@ async function defaultEncodeVariant(input) {
 }
 async function normalizeImageForVision(params) {
     const maxVlmBytes = params.maxVlmBytes ?? exports.MAX_VLM_IMAGE_BYTES;
+    if (params.maxEdge !== undefined && (!Number.isInteger(params.maxEdge) || params.maxEdge < 1)) {
+        throw new Error("Image maximum edge must be a positive integer");
+    }
     const originalMimeType = params.attachment.mimeType?.trim().toLowerCase();
     const originalByteCount = params.attachment.byteCount;
     const outputDir = materializedOutputDir(params.agentRoot, params.attachment.id);
     if (originalMimeType
+        && params.maxEdge === undefined
         && SAFE_VLM_MIME_TYPES.has(originalMimeType)
         && typeof originalByteCount === "number"
         && originalByteCount <= maxVlmBytes) {
@@ -149,8 +153,11 @@ async function normalizeImageForVision(params) {
         probe = await probeImage({ sourcePath: workingSourcePath });
     }
     const targetFormats = probe.hasAlpha ? ["png", "jpeg"] : ["jpeg"];
+    const requestedMaxEdge = params.maxEdge;
+    const sizes = requestedMaxEdge === undefined ? SIZE_STEPS
+        : [...new Set([requestedMaxEdge, ...SIZE_STEPS.filter((size) => size < requestedMaxEdge)])];
     for (const targetFormat of targetFormats) {
-        for (const maxEdge of SIZE_STEPS) {
+        for (const maxEdge of sizes) {
             const qualities = targetFormat === "jpeg" ? JPEG_QUALITIES : [undefined];
             for (const quality of qualities) {
                 const variant = await encodeVariant({

package/dist/repertoire/guardrails.js

@@ -1184,6 +1184,9 @@ function checkFirstClassMcpTrust(context) {
     return allow;
 }
 function checkTrustLevelGuardrails(toolName, args, context) {
+    if (toolName === "teams_send_image" && context.trustLevel !== "family") {
+        return deny("sending local images in Teams requires family trust.");
+    }
     const cacheSyncResult = mailCacheSyncShellGuardrail(toolName, args, context);
     if (!cacheSyncResult.allowed)
         return cacheSyncResult;

package/dist/repertoire/tools-teams.js

@@ -9,6 +9,7 @@ const ado_client_1 = require("./ado-client");
 const graph_endpoints_json_1 = __importDefault(require("./data/graph-endpoints.json"));
 const ado_endpoints_json_1 = __importDefault(require("./data/ado-endpoints.json"));
 const runtime_1 = require("../nerves/runtime");
+const teams_image_1 = require("../senses/teams-image");
 const MUTATE_METHODS = ["POST", "PATCH", "DELETE"];
 const DEFAULT_ADO_QUERY = "SELECT [System.Id], [System.Title], [System.State], [System.AssignedTo] FROM WorkItems WHERE [System.AssignedTo] = @Me AND [System.State] <> 'Closed' ORDER BY [System.ChangedDate] DESC";
 exports.teamsToolDefinitions = [
@@ -283,6 +284,43 @@ exports.teamsToolDefinitions = [
         integration: "ado",
         summaryKeys: ["query"],
     },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "teams_send_image",
+                description: "Send a local PNG or JPEG image into the current Teams conversation, without publishing it or using OneDrive. Requires family trust. Images are resized/compressed for inline delivery. An activity receipt confirms Teams acceptance, not client rendering.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Absolute path to a local PNG or JPEG image" },
+                        caption: { type: "string", maxLength: teams_image_1.MAX_TEAMS_IMAGE_CAPTION_LENGTH, description: "Optional short caption (up to 1024 characters)" },
+                    },
+                    required: ["path"],
+                    additionalProperties: false,
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            if (ctx?.noSend || ctx?.habitSession || ctx?.autonomousTurnKind) {
+                throw new Error("Teams image sending is unavailable in no-send or autonomous turns");
+            }
+            if (ctx?.context?.friend.trustLevel !== "family" || ctx.context.channel.channel !== "teams") {
+                throw new Error("Sending local images in Teams requires a family-trusted Teams conversation");
+            }
+            if (!ctx.teamsSendImage || !ctx.agentName || !ctx.agentRoot) {
+                throw new Error("Teams image sending requires an authenticated current-conversation sender and agent owner");
+            }
+            const caption = args.caption ?? "";
+            if (caption.length > teams_image_1.MAX_TEAMS_IMAGE_CAPTION_LENGTH)
+                throw new Error("Teams image caption exceeds 1024 characters");
+            const attachment = await (0, teams_image_1.prepareTeamsImage)({ path: args.path, agentName: ctx.agentName, agentRoot: ctx.agentRoot });
+            const activityId = await ctx.teamsSendImage(attachment, caption);
+            return `image accepted by Teams in the current conversation (activity ${activityId}); client rendering is not verified`;
+        },
+        summaryKeys: ["path"],
+        riskProfile: { mutates: "external_side_effect", risk: "high", reason: "sends local image bytes to the current Teams conversation" },
+    },
 ];
 function searchEndpoints(entries, query) {
     (0, runtime_1.emitNervesEvent)({

package/dist/repertoire/tools.js

@@ -164,7 +164,8 @@ function selectToolsForChannel(capabilities, toolPreferences, _context, provider
     }
     else {
         const available = new Set(capabilities?.availableIntegrations ?? []);
-        const integrations = available.size === 0 ? [] : [...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions]
+        const integrations = [...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions]
+            .filter((definition) => available.size > 0 || definition.tool.function.name === "teams_send_image")
             .filter((definition) => definition.integration ? available.has(definition.integration) : capabilities?.channel === "teams")
             .map((definition) => {
             const preference = definition.integration ? toolPreferences?.[definition.integration] : undefined;
@@ -197,7 +198,9 @@ function selectToolsForChannel(capabilities, toolPreferences, _context, provider
             ordinary.push(tools_surface_1.surfaceToolDefinition);
         }
     }
-    ordinary = ordinary.filter((definition) => (!relationship || relationship.advertisedToolNames.includes(definition.tool.function.name))
+    ordinary = ordinary.filter((definition) => (definition.tool.function.name !== "teams_send_image" || (!context?.noSend && !context?.habitSession && !context?.autonomousTurnKind))
+        &&
+            (!relationship || relationship.advertisedToolNames.includes(definition.tool.function.name))
         && (!definition.requiredCapability || providerCapabilities?.has(definition.requiredCapability) === true));
     const engine = [
         ...(context?.noSend ? [] : [tools_flow_1.ponderTool]),

package/dist/senses/teams-image.js

@@ -0,0 +1,119 @@
+"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.MAX_TEAMS_IMAGE_CAPTION_LENGTH = exports.MAX_TEAMS_INLINE_IMAGE_BYTES = void 0;
+exports.prepareTeamsImage = prepareTeamsImage;
+exports.createTeamsImageSender = createTeamsImageSender;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const image_normalize_1 = require("../heart/attachments/image-normalize");
+const cli_local_file_1 = require("../heart/attachments/sources/cli-local-file");
+const runtime_1 = require("../nerves/runtime");
+exports.MAX_TEAMS_INLINE_IMAGE_BYTES = 56 * 1024;
+exports.MAX_TEAMS_IMAGE_CAPTION_LENGTH = 1024;
+function imageMime(bytes) {
+    if (bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+        return "image/png";
+    if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255)
+        return "image/jpeg";
+    throw new Error("Teams image must contain PNG or JPEG bytes");
+}
+async function readBoundedImage(filePath, maxBytes) {
+    const file = await fs.open(filePath, "r");
+    try {
+        const stat = await file.stat();
+        if (!stat.isFile() || stat.size === 0 || stat.size > maxBytes) {
+            throw new Error(`Teams image must be a nonempty regular file under ${maxBytes} bytes`);
+        }
+        // Bound the actual read as well as the stat, including a file that grows after the stat.
+        const bytes = Buffer.alloc(stat.size + 1);
+        const { bytesRead } = await file.read(bytes, 0, bytes.length, 0);
+        if (bytesRead !== stat.size)
+            throw new Error("Teams image changed while reading; nothing was sent");
+        return bytes.subarray(0, bytesRead);
+    }
+    finally {
+        await file.close();
+    }
+}
+async function prepareTeamsImage(input) {
+    if (!path.isAbsolute(input.path))
+        throw new Error("Teams image path must be absolute");
+    const original = await readBoundedImage(input.path, image_normalize_1.MAX_ATTACHMENT_DOWNLOAD_BYTES_IMAGE);
+    const mimeType = imageMime(original);
+    const attachment = (0, cli_local_file_1.buildCliLocalFileAttachmentRecord)({ path: input.path, mimeType, byteCount: original.length });
+    const normalized = await (0, image_normalize_1.normalizeImageForVision)({
+        attachment, sourcePath: input.path, agentName: input.agentName, agentRoot: input.agentRoot,
+        maxEdge: 1024, maxVlmBytes: exports.MAX_TEAMS_INLINE_IMAGE_BYTES,
+    });
+    const bytes = await readBoundedImage(normalized.path, exports.MAX_TEAMS_INLINE_IMAGE_BYTES);
+    const contentType = imageMime(bytes);
+    if (normalized.mimeType !== contentType)
+        throw new Error("Normalized Teams image MIME does not match its bytes");
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels", event: "channel.teams_image_prepared",
+        message: "private image prepared for inline Teams delivery",
+        meta: { mimeType: contentType, byteCount: bytes.length, maxEdge: 1024 },
+    });
+    return {
+        contentType,
+        contentUrl: `data:${contentType};base64,${bytes.toString("base64")}`,
+        name: `${path.basename(input.path, path.extname(input.path)).slice(0, 100)}${contentType === "image/png" ? ".png" : ".jpg"}`,
+    };
+}
+function createTeamsImageSender(send, replyToId, entities = []) {
+    return async (attachment, caption) => {
+        if (caption.length > exports.MAX_TEAMS_IMAGE_CAPTION_LENGTH)
+            throw new Error("Teams image caption exceeds 1024 characters");
+        const message = {
+            type: "message", text: caption, replyToId, attachments: [attachment],
+            entities, channelData: { feedbackLoopEnabled: true },
+        };
+        if (Buffer.byteLength(JSON.stringify(message), "utf8") > 80 * 1024) {
+            throw new Error("Teams image message exceeds the inline payload budget; nothing was sent");
+        }
+        const receipt = await send(message);
+        if (!receipt || typeof receipt !== "object" || !("id" in receipt)
+            || typeof receipt.id !== "string" || !receipt.id.trim()) {
+            throw new Error("Teams image delivery is unknown: no activity receipt returned; do not retry automatically");
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels", event: "channel.teams_image_accepted",
+            message: "Teams accepted an inline image activity; client rendering is not verified",
+            meta: { activityId: receipt.id, mimeType: attachment.contentType },
+        });
+        return receipt.id;
+    };
+}

package/dist/senses/teams.js

@@ -78,6 +78,7 @@ const session_transaction_1 = require("../mind/session-transaction");
 const teamsFailoverStates = new Map();
 const pending_1 = require("../mind/pending");
 const continuity_1 = require("./continuity");
+const teams_image_1 = require("./teams-image");
 // AIGeneratedContent entity and feedbackLoopEnabled channelData for all outbound
 // Teams messages. Required by Teams AI UX best practices.
 function aiLabelEntities() {
@@ -721,6 +722,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                     summarize: (0, core_1.createSummarize)("human"),
                     tenantId: teamsContext.tenantId,
                     botApi: teamsContext.botApi,
+                    teamsSendImage: teamsContext.teamsSendImage,
                 } : {}) };
             let currentText = text;
             const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)(owner) ?? undefined;
@@ -1181,6 +1183,7 @@ function registerBotHandlers(app, label) {
                 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) => {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.927",
+  "version": "0.1.0-alpha.928",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.927",
+      "version": "0.1.0-alpha.928",
       "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.927",
+  "version": "0.1.0-alpha.928",
   "engines": {
     "node": ">=22"
   },