@ouro.bot/cli 0.1.0-alpha.484 → 0.1.0-alpha.486

package/dist/heart/streaming.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SettleStreamer = exports.SettleParser = void 0;
+exports.RESPONSES_FUNCTION_CALL_OUTPUT_CAP = exports.SettleStreamer = exports.SettleParser = void 0;
+exports.truncateResponsesFunctionCallOutput = truncateResponsesFunctionCallOutput;
 exports.toResponsesInput = toResponsesInput;
 exports.toResponsesTools = toResponsesTools;
 exports.streamChatCompletion = streamChatCompletion;
@@ -112,6 +113,16 @@ class SettleStreamer {
     }
 }
 exports.SettleStreamer = SettleStreamer;
+exports.RESPONSES_FUNCTION_CALL_OUTPUT_CAP = 200_000;
+function truncateResponsesFunctionCallOutput(output, maxChars = exports.RESPONSES_FUNCTION_CALL_OUTPUT_CAP) {
+    if (output.length <= maxChars)
+        return output;
+    const marker = `\n\n[truncated — function_call_output exceeded ${maxChars} chars; original length ${output.length} chars]\n\n`;
+    const remainingBudget = Math.max(0, maxChars - marker.length);
+    const headLength = Math.ceil(remainingBudget * 0.75);
+    const tailLength = Math.max(0, remainingBudget - headLength);
+    return `${output.slice(0, headLength)}${marker}${output.slice(-tailLength)}`;
+}
 function toResponsesUserContent(content) {
     if (typeof content === "string") {
         return content;
@@ -217,7 +228,7 @@ function toResponsesInput(messages) {
             input.push({
                 type: "function_call_output",
                 call_id: t.tool_call_id,
-                output: typeof t.content === "string" ? t.content : "",
+                output: truncateResponsesFunctionCallOutput(typeof t.content === "string" ? t.content : ""),
             });
             continue;
         }

package/dist/mailroom/blob-store.js

@@ -4,6 +4,7 @@ exports.AzureBlobMailroomStore = void 0;
 exports.decryptBlobMessages = decryptBlobMessages;
 const runtime_1 = require("../nerves/runtime");
 const core_1 = require("./core");
+const search_cache_1 = require("./search-cache");
 const MESSAGE_INDEX_PREFIX = "message-index";
 const MESSAGE_INDEX_SORT_MAX_MS = 9_999_999_999_999;
 const MESSAGE_INDEX_SORT_WIDTH = 13;
@@ -22,6 +23,9 @@ function compareCandidatesNewestFirst(left, right) {
 function blobText(value) {
     return Buffer.from(`${JSON.stringify(value, null, 2)}\n`, "utf-8");
 }
+function applyOptionalLimit(items, limit) {
+    return typeof limit === "number" ? items.slice(0, limit) : items;
+}
 function positiveInteger(value, fallback) {
     if (typeof value !== "number" || !Number.isFinite(value))
         return fallback;
@@ -248,7 +252,6 @@ class AzureBlobMailroomStore {
             messageBlobNames.push(item.name);
         }
         const matches = [];
-        const limit = filters.limit ?? 20;
         let nextIndex = 0;
         const worker = async () => {
             while (nextIndex < messageBlobNames.length) {
@@ -259,12 +262,12 @@ class AzureBlobMailroomStore {
                     continue;
                 matches.push(message);
                 matches.sort(compareNewestFirst);
-                if (matches.length > limit)
-                    matches.length = limit;
+                if (typeof filters.limit === "number" && matches.length > filters.limit)
+                    matches.length = filters.limit;
             }
         };
         await Promise.all(Array.from({ length: Math.min(MESSAGE_LIST_SCAN_CONCURRENCY, Math.max(messageBlobNames.length, 1)) }, async () => worker()));
-        return matches.sort(compareNewestFirst).slice(0, limit);
+        return applyOptionalLimit(matches.sort(compareNewestFirst), filters.limit);
     }
     async listMessagesFromIndexes(filters) {
         const messageIds = [];
@@ -275,18 +278,18 @@ class AzureBlobMailroomStore {
             if (!parsed || !messageMatchesFilters(parsed, filters))
                 continue;
             messageIds.push(parsed.id);
-            if (messageIds.length >= (filters.limit ?? 20))
+            if (typeof filters.limit === "number" && messageIds.length >= filters.limit)
                 break;
         }
         if (!sawIndex)
             return null;
-        return (await mapWithConcurrency(messageIds, this.messageFetchConcurrency, async (id) => {
+        const messages = (await mapWithConcurrency(messageIds, this.messageFetchConcurrency, async (id) => {
             return downloadJson(this.messageBlob(id), this.blobOperationTimeoutMs);
         }))
             .filter((message) => message !== null)
             .filter((message) => messageMatchesFilters(message, filters))
-            .sort(compareNewestFirst)
-            .slice(0, filters.limit ?? 20);
+            .sort(compareNewestFirst);
+        return applyOptionalLimit(messages, filters.limit);
     }
     async backfillMessageIndexes(agentId, onProgress) {
         await this.ensureContainer();
@@ -335,7 +338,7 @@ class AzureBlobMailroomStore {
     }
     async putRawMessage(input) {
         await this.ensureContainer();
-        const { message, rawPayload, candidate } = await (0, core_1.buildStoredMailMessage)(input);
+        const { message, rawPayload, privateEnvelope, candidate } = await (0, core_1.buildStoredMailMessage)(input);
         const messageBlob = this.messageBlob(message.id);
         let existing = null;
         try {
@@ -359,6 +362,7 @@ class AzureBlobMailroomStore {
             throw error;
         }
         if (existing) {
+            (0, search_cache_1.upsertMailSearchCacheDocument)(existing, privateEnvelope);
             await this.putMessageIndex(existing);
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
@@ -371,6 +375,7 @@ class AzureBlobMailroomStore {
         await this.rawBlob(message.rawObject).uploadData(blobText(rawPayload));
         await this.messageBlob(message.id).uploadData(blobText(message));
         await this.putMessageIndex(message);
+        (0, search_cache_1.upsertMailSearchCacheDocument)(message, privateEnvelope);
         if (candidate) {
             await this.candidateBlob(candidate.id).uploadData(blobText(candidate));
         }
@@ -426,6 +431,7 @@ class AzureBlobMailroomStore {
         await blob.uploadData(blobText(updated));
         await this.removeMessageIndex(message);
         await this.putMessageIndex(updated);
+        (0, search_cache_1.syncMailSearchCacheMetadata)(updated);
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.mail_blob_store_message_placement_updated",
@@ -578,7 +584,7 @@ class AzureBlobMailroomStore {
     async listAccessLog(agentId) {
         await this.ensureContainer();
         const entries = await downloadJson(this.accessLogBlob(agentId), this.blobOperationTimeoutMs);
-        const safeEntries = Array.isArray(entries) ? entries : [];
+        const safeEntries = (Array.isArray(entries) ? entries : []);
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.mail_blob_access_log_listed",

package/dist/mailroom/core.js

@@ -477,7 +477,7 @@ async function buildStoredMailMessage(input) {
         message: "stored mail message envelope built",
         meta: { id, agentId: message.agentId, placement, compartmentKind: message.compartmentKind, candidate: candidate !== undefined },
     });
-    return { message, rawPayload, ...(candidate ? { candidate } : {}) };
+    return { message, rawPayload, privateEnvelope, ...(candidate ? { candidate } : {}) };
 }
 function decryptStoredMailMessage(message, privateKeys) {
     const privateKey = privateKeys[message.privateEnvelope.keyId];

package/dist/mailroom/file-store.js

@@ -40,9 +40,13 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const runtime_1 = require("../nerves/runtime");
 const core_1 = require("./core");
+const search_cache_1 = require("./search-cache");
 function ensureDir(dir) {
     fs.mkdirSync(dir, { recursive: true });
 }
+function applyOptionalLimit(items, limit) {
+    return typeof limit === "number" ? items.slice(0, limit) : items;
+}
 function readJson(filePath) {
     try {
         return JSON.parse(fs.readFileSync(filePath, "utf-8"));
@@ -122,9 +126,10 @@ class FileMailroomStore {
         return path.join(this.logsDir, `${agentId}.jsonl`);
     }
     async putRawMessage(input) {
-        const { message, rawPayload, candidate } = await (0, core_1.buildStoredMailMessage)(input);
+        const { message, rawPayload, privateEnvelope, candidate } = await (0, core_1.buildStoredMailMessage)(input);
         const existing = readJson(this.messagePath(message.id));
         if (existing) {
+            (0, search_cache_1.upsertMailSearchCacheDocument)(existing, privateEnvelope);
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.mail_store_dedupe",
@@ -135,6 +140,7 @@ class FileMailroomStore {
         }
         writeJson(this.rawPath(message.rawObject), rawPayload);
         writeJson(this.messagePath(message.id), message);
+        (0, search_cache_1.upsertMailSearchCacheDocument)(message, privateEnvelope);
         if (candidate) {
             writeJson(this.candidatePath(candidate.id), candidate);
         }
@@ -165,15 +171,15 @@ class FileMailroomStore {
             .filter((message) => filters.placement ? message.placement === filters.placement : true)
             .filter((message) => filters.compartmentKind ? message.compartmentKind === filters.compartmentKind : true)
             .filter((message) => sourceMatchesFilter(message.source, filters.source))
-            .sort(compareNewestFirst)
-            .slice(0, filters.limit ?? 20);
+            .sort(compareNewestFirst);
+        const limited = applyOptionalLimit(messages, filters.limit);
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.mail_store_messages_listed",
             message: "mailroom store listed messages",
-            meta: { agentId: filters.agentId, count: messages.length },
+            meta: { agentId: filters.agentId, count: limited.length },
         });
-        return messages;
+        return limited;
     }
     async updateMessagePlacement(id, placement) {
         const message = readJson(this.messagePath(id));
@@ -188,6 +194,7 @@ class FileMailroomStore {
         }
         const updated = { ...message, placement };
         writeJson(this.messagePath(id), updated);
+        (0, search_cache_1.syncMailSearchCacheMetadata)(updated);
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.mail_store_message_placement_updated",
@@ -339,15 +346,34 @@ class FileMailroomStore {
             });
             return [];
         }
-        const entries = fs.readFileSync(filePath, "utf-8")
+        const lines = fs.readFileSync(filePath, "utf-8")
             .split(/\r?\n/)
-            .filter(Boolean)
-            .map((line) => JSON.parse(line));
+            .filter(Boolean);
+        const entries = [];
+        let malformedEntriesSkipped = 0;
+        for (const line of lines) {
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch {
+                malformedEntriesSkipped += 1;
+            }
+        }
+        if (malformedEntriesSkipped > 0) {
+            entries.malformedEntriesSkipped = malformedEntriesSkipped;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.mail_access_log_malformed_lines_skipped",
+                message: "skipped malformed file-backed mail access log lines",
+                meta: { agentId, malformedEntriesSkipped },
+            });
+        }
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.mail_access_log_listed",
             message: "mail access log listed",
-            meta: { agentId, count: entries.length },
+            meta: { agentId, count: entries.length, malformedEntriesSkipped },
         });
         return entries;
     }

package/dist/mailroom/mbox-import.js

@@ -36,9 +36,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitMboxMessages = splitMboxMessages;
 exports.importMboxToStore = importMboxToStore;
 exports.importMboxFileToStore = importMboxFileToStore;
+exports.cacheMatchingMailSearchDocumentsFromMboxFile = cacheMatchingMailSearchDocumentsFromMboxFile;
 const fs = __importStar(require("node:fs"));
 const runtime_1 = require("../nerves/runtime");
 const core_1 = require("./core");
+const search_cache_1 = require("./search-cache");
+const search_relevance_1 = require("./search-relevance");
 function splitMboxMessages(rawMbox) {
     const text = rawMbox.toString("utf-8");
     const separators = [...text.matchAll(/^From [^\r\n]*(?:\r?\n)/gm)];
@@ -208,6 +211,11 @@ function extractHeaderDate(rawMessage, headerName) {
     const parsed = new Date(value);
     return Number.isFinite(parsed.getTime()) ? parsed : undefined;
 }
+function normalizeSearchTerms(queryTerms) {
+    return queryTerms
+        .map((term) => term.trim().toLowerCase())
+        .filter((term) => term.length > 0);
+}
 function historicalImportClassification(resolvedPlacement, sourceGrant) {
     return {
         placement: resolvedPlacement,
@@ -339,3 +347,36 @@ async function importMboxFileToStore(input) {
         onProgress: input.onProgress,
     });
 }
+async function cacheMatchingMailSearchDocumentsFromMboxFile(input) {
+    const target = resolveImportTarget(input);
+    const queryTerms = normalizeSearchTerms(input.queryTerms);
+    if (queryTerms.length === 0 || input.limit <= 0)
+        return [];
+    const matches = [];
+    for await (const rawMessage of streamMboxMessagesFromFile(input.filePath)) {
+        const parsedMessage = parseMboxMessage(rawMessage, target.sourceGrant);
+        const { message, privateEnvelope } = await (0, core_1.buildStoredMailMessage)({
+            resolved: target.resolved,
+            envelope: parsedMessage.envelope,
+            rawMime: parsedMessage.rawMessage,
+            receivedAt: parsedMessage.messageDate,
+            ingest: {
+                schemaVersion: 1,
+                kind: "mbox-import",
+                attentionSuppressed: true,
+            },
+            classification: historicalImportClassification(target.resolved.defaultPlacement, target.sourceGrant),
+        });
+        const document = (0, search_cache_1.buildMailSearchCacheDocument)(message, privateEnvelope);
+        if (!queryTerms.some((term) => document.searchText.includes(term)))
+            continue;
+        (0, search_cache_1.upsertMailSearchCacheDocument)(message, privateEnvelope);
+        matches.push(document);
+        if (matches.length >= input.limit)
+            break;
+    }
+    return matches
+        .map((document) => ({ document, relevance: (0, search_relevance_1.scoreMailSearchDocument)(document, queryTerms) }))
+        .sort(search_relevance_1.compareByRelevanceThenRecency)
+        .map((entry) => entry.document);
+}

package/dist/mailroom/reader.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMailroomConfig = parseMailroomConfig;
 exports.readMailroomRegistry = readMailroomRegistry;
+exports.writeMailroomRegistry = writeMailroomRegistry;
 exports.resolveMailroomReader = resolveMailroomReader;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -145,6 +146,27 @@ async function readMailroomRegistry(config) {
     }
     return JSON.parse((await blobClient.downloadToBuffer()).toString("utf-8"));
 }
+async function writeMailroomRegistry(config, registry) {
+    const serialized = `${JSON.stringify(registry, null, 2)}\n`;
+    if (config.registryPath) {
+        fs.mkdirSync(path.dirname(config.registryPath), { recursive: true });
+        fs.writeFileSync(config.registryPath, serialized, "utf-8");
+        return;
+    }
+    const registryAzureAccountUrl = config.registryAzureAccountUrl ?? config.azureAccountUrl;
+    const registryContainer = config.registryContainer ?? config.azureContainer ?? "mailroom";
+    const registryBlob = config.registryBlob;
+    if (!registryAzureAccountUrl || !registryBlob) {
+        throw new Error("mailroom config is missing registryPath or hosted registry coordinates");
+    }
+    const serviceClient = new storage_blob_1.BlobServiceClient(registryAzureAccountUrl, createBlobCredential(config));
+    const blobClient = serviceClient.getContainerClient(registryContainer).getBlockBlobClient(registryBlob);
+    await blobClient.upload(serialized, Buffer.byteLength(serialized), {
+        blobHTTPHeaders: {
+            blobContentType: "application/json; charset=utf-8",
+        },
+    });
+}
 function resolveMailroomReader(agentName = (0, identity_2.getAgentName)()) {
     const runtime = (0, runtime_credentials_1.readRuntimeCredentialConfig)(agentName);
     if (!runtime.ok) {

package/dist/mailroom/search-cache.js

@@ -0,0 +1,182 @@
+"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.buildMailSearchCacheDocument = buildMailSearchCacheDocument;
+exports.upsertMailSearchCacheDocument = upsertMailSearchCacheDocument;
+exports.syncMailSearchCacheMetadata = syncMailSearchCacheMetadata;
+exports.searchMailSearchCache = searchMailSearchCache;
+exports.resetMailSearchCacheForTests = resetMailSearchCacheForTests;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const search_relevance_1 = require("./search-relevance");
+const SEARCH_TEXT_EXCERPT_LIMIT = 16_384;
+const cacheStates = new Map();
+function cacheDir(agentId) {
+    return path.join((0, identity_1.getAgentRoot)(agentId), "state", "mail-search");
+}
+function cachePath(agentId, messageId) {
+    return path.join(cacheDir(agentId), `${messageId}.json`);
+}
+function normalizeSearchText(privateEnvelope) {
+    return [
+        privateEnvelope.subject,
+        privateEnvelope.snippet,
+        privateEnvelope.text.slice(0, SEARCH_TEXT_EXCERPT_LIMIT),
+        privateEnvelope.from.join(" "),
+    ].join("\n").toLowerCase();
+}
+function readJsonDocument(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function cacheState(agentId) {
+    const key = `${agentId}:${cacheDir(agentId)}`;
+    let state = cacheStates.get(key);
+    if (state)
+        return state;
+    state = { loaded: false, docs: new Map() };
+    cacheStates.set(key, state);
+    return state;
+}
+function loadCache(agentId) {
+    const state = cacheState(agentId);
+    if (state.loaded)
+        return state.docs;
+    state.loaded = true;
+    const dir = cacheDir(agentId);
+    if (!fs.existsSync(dir))
+        return state.docs;
+    for (const entry of fs.readdirSync(dir)) {
+        if (!entry.endsWith(".json"))
+            continue;
+        const document = readJsonDocument(path.join(dir, entry));
+        if (!document || document.agentId !== agentId)
+            continue;
+        state.docs.set(document.messageId, document);
+    }
+    return state.docs;
+}
+function buildMailSearchCacheDocument(message, privateEnvelope) {
+    return {
+        schemaVersion: 1,
+        messageId: message.id,
+        agentId: message.agentId,
+        receivedAt: message.receivedAt,
+        placement: message.placement,
+        compartmentKind: message.compartmentKind,
+        ...(message.ownerEmail ? { ownerEmail: message.ownerEmail } : {}),
+        ...(message.source ? { source: message.source } : {}),
+        from: [...privateEnvelope.from],
+        subject: privateEnvelope.subject,
+        snippet: privateEnvelope.snippet,
+        textExcerpt: privateEnvelope.text.slice(0, SEARCH_TEXT_EXCERPT_LIMIT),
+        untrustedContentWarning: privateEnvelope.untrustedContentWarning,
+        searchText: normalizeSearchText(privateEnvelope),
+        attachmentCount: privateEnvelope.attachments.length,
+    };
+}
+function upsertMailSearchCacheDocument(message, privateEnvelope) {
+    const document = buildMailSearchCacheDocument(message, privateEnvelope);
+    const dir = cacheDir(message.agentId);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(cachePath(message.agentId, message.id), `${JSON.stringify(document)}\n`, "utf-8");
+    const docs = loadCache(message.agentId);
+    docs.set(document.messageId, document);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.mail_search_cache_upserted",
+        message: "mail search cache entry written",
+        meta: {
+            agentId: message.agentId,
+            messageId: document.messageId,
+            placement: document.placement,
+            compartmentKind: document.compartmentKind,
+        },
+    });
+    return document;
+}
+function syncMailSearchCacheMetadata(message) {
+    const existing = readJsonDocument(cachePath(message.agentId, message.id));
+    if (!existing)
+        return;
+    const updated = {
+        ...existing,
+        receivedAt: message.receivedAt,
+        placement: message.placement,
+        compartmentKind: message.compartmentKind,
+        ...(message.ownerEmail ? { ownerEmail: message.ownerEmail } : {}),
+        ...(message.source ? { source: message.source } : {}),
+    };
+    fs.writeFileSync(cachePath(message.agentId, message.id), `${JSON.stringify(updated)}\n`, "utf-8");
+    const docs = loadCache(message.agentId);
+    docs.set(updated.messageId, updated);
+}
+function sourceMatches(source, filter) {
+    if (!filter)
+        return true;
+    if (!source)
+        return false;
+    return source.toLowerCase() === filter.toLowerCase();
+}
+function searchMailSearchCache(filters) {
+    const queryTerms = filters.queryTerms ?? [];
+    const docs = [...loadCache(filters.agentId).values()]
+        .filter((document) => filters.placement ? document.placement === filters.placement : true)
+        .filter((document) => filters.compartmentKind ? document.compartmentKind === filters.compartmentKind : true)
+        .filter((document) => sourceMatches(document.source, filters.source))
+        .filter((document) => queryTerms.length
+        ? queryTerms.some((term) => document.searchText.includes(term))
+        : true);
+    let ordered;
+    if (queryTerms.length > 0) {
+        ordered = docs
+            .map((document) => ({ document, relevance: (0, search_relevance_1.scoreMailSearchDocument)(document, queryTerms) }))
+            .sort(search_relevance_1.compareByRelevanceThenRecency)
+            .map((entry) => entry.document);
+    }
+    else {
+        ordered = docs.sort((left, right) => right.receivedAt.localeCompare(left.receivedAt));
+    }
+    return typeof filters.limit === "number" ? ordered.slice(0, filters.limit) : ordered;
+}
+function resetMailSearchCacheForTests() {
+    cacheStates.clear();
+}