@ouro.bot/cli 0.1.0-alpha.733 → 0.1.0-alpha.734

package/dist/heart/runtime-credentials.js

@@ -39,7 +39,9 @@ exports.readRuntimeCredentialConfig = readRuntimeCredentialConfig;
 exports.readMachineRuntimeCredentialConfig = readMachineRuntimeCredentialConfig;
 exports.cacheRuntimeCredentialConfig = cacheRuntimeCredentialConfig;
 exports.cacheMachineRuntimeCredentialConfig = cacheMachineRuntimeCredentialConfig;
+exports.isRuntimeCredentialBootstrapMessage = isRuntimeCredentialBootstrapMessage;
 exports.applyRuntimeCredentialBootstrapMessage = applyRuntimeCredentialBootstrapMessage;
+exports.persistRuntimeCredentialBootstrapMessage = persistRuntimeCredentialBootstrapMessage;
 exports.waitForRuntimeCredentialBootstrap = waitForRuntimeCredentialBootstrap;
 exports.refreshRuntimeCredentialConfig = refreshRuntimeCredentialConfig;
 exports.refreshMachineRuntimeCredentialConfig = refreshMachineRuntimeCredentialConfig;
@@ -68,25 +70,54 @@ function isCredentialRecord(value) {
         return false;
     return Object.values(value).every(isCredentialValue);
 }
+function isPresentCredentialValue(value) {
+    if (typeof value === "string")
+        return value.trim().length > 0;
+    return typeof value === "number" && Number.isFinite(value) && value !== 0;
+}
+function hasExactKeys(value, keys) {
+    return Object.keys(value).sort().join(",") === [...keys].sort().join(",");
+}
+function isCanonicalTimestamp(value) {
+    if (typeof value !== "string")
+        return false;
+    try {
+        return new Date(value).toISOString() === value;
+    }
+    catch {
+        return false;
+    }
+}
 function isProviderCredentialRecord(value) {
     if (!isRecord(value))
         return false;
-    if (typeof value.provider !== "string")
+    if (!hasExactKeys(value, ["provider", "revision", "updatedAt", "credentials", "config", "provenance"]))
+        return false;
+    if (typeof value.provider !== "string" || !Object.prototype.hasOwnProperty.call(identity_1.PROVIDER_CREDENTIALS, value.provider))
+        return false;
+    if (typeof value.revision !== "string" || !/^vault_[0-9a-f]{16}$/u.test(value.revision))
         return false;
-    if (typeof value.revision !== "string" || value.revision.trim().length === 0)
+    if (!isCanonicalTimestamp(value.updatedAt))
         return false;
-    if (typeof value.updatedAt !== "string" || value.updatedAt.trim().length === 0)
+    const credentials = value.credentials;
+    const config = value.config;
+    if (!isCredentialRecord(credentials))
         return false;
-    if (!isCredentialRecord(value.credentials))
+    if (!isCredentialRecord(config))
         return false;
-    if (!isCredentialRecord(value.config))
+    const provider = value.provider;
+    const canonicalCredentials = (0, provider_credentials_1.splitProviderCredentialFields)(provider, credentials).credentials;
+    const canonicalConfig = (0, provider_credentials_1.splitProviderCredentialFields)(provider, config).config;
+    if (!identity_1.PROVIDER_CREDENTIALS[provider].required.every((field) => (isPresentCredentialValue(canonicalCredentials[field]) || isPresentCredentialValue(canonicalConfig[field]))))
         return false;
     const provenance = value.provenance;
     if (!isRecord(provenance))
         return false;
+    if (!hasExactKeys(provenance, ["source", "updatedAt"]))
+        return false;
     if (provenance.source !== "auth-flow" && provenance.source !== "manual")
         return false;
-    if (typeof provenance.updatedAt !== "string" || provenance.updatedAt.trim().length === 0)
+    if (!isCanonicalTimestamp(provenance.updatedAt) || provenance.updatedAt !== value.updatedAt)
         return false;
     return true;
 }
@@ -98,6 +129,55 @@ function stableJson(value) {
     }
     return JSON.stringify(value);
 }
+function reconcileBootstrapFields(base, bootstrap, prefix) {
+    const conflicts = [];
+    const merge = (current, incoming, pathPrefix) => {
+        const next = { ...current };
+        for (const [key, incomingValue] of Object.entries(incoming)) {
+            const fieldPath = `${pathPrefix}.${key}`;
+            if (!Object.prototype.hasOwnProperty.call(current, key)) {
+                next[key] = incomingValue;
+                continue;
+            }
+            const currentValue = current[key];
+            if (isRecord(currentValue) && isRecord(incomingValue)) {
+                next[key] = merge(currentValue, incomingValue, fieldPath);
+            }
+            else if (stableJson(currentValue) !== stableJson(incomingValue)) {
+                conflicts.push(fieldPath);
+            }
+        }
+        return next;
+    };
+    const merged = merge(base, bootstrap, prefix);
+    if (conflicts.length > 0) {
+        throw new Error(`container credential bootstrap conflicts with existing fields: ${conflicts.sort().join(", ")}`);
+    }
+    return merged;
+}
+function assertBootstrapReadback(actual, expected, prefix) {
+    const failures = [];
+    const inspect = (current, intended, pathPrefix) => {
+        for (const [key, intendedValue] of Object.entries(intended)) {
+            const fieldPath = `${pathPrefix}.${key}`;
+            if (!Object.prototype.hasOwnProperty.call(current, key)) {
+                failures.push(fieldPath);
+                continue;
+            }
+            const currentValue = current[key];
+            if (isRecord(currentValue) && isRecord(intendedValue)) {
+                inspect(currentValue, intendedValue, fieldPath);
+            }
+            else if (stableJson(currentValue) !== stableJson(intendedValue)) {
+                failures.push(fieldPath);
+            }
+        }
+    };
+    inspect(actual, expected, prefix);
+    if (failures.length > 0) {
+        throw new Error(`container credential bootstrap readback did not contain intended fields: ${failures.sort().join(", ")}`);
+    }
+}
 function runtimeConfigVaultPath(agentName, itemName = exports.RUNTIME_CONFIG_ITEM_NAME) {
     return `vault:${agentName}:${itemName}`;
 }
@@ -198,20 +278,41 @@ function isRuntimeCredentialBootstrapMessage(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
     const record = value;
+    if (!Object.keys(record).every((key) => [
+        "type",
+        "agentName",
+        "runtimeConfig",
+        "machineRuntimeConfig",
+        "machineId",
+        "providerCredentialRecords",
+    ].includes(key)))
+        return false;
     if (record.type !== "ouro.runtimeCredentialBootstrap")
         return false;
     if (typeof record.agentName !== "string" || record.agentName.trim().length === 0)
         return false;
-    if (record.runtimeConfig !== undefined && !isRecord(record.runtimeConfig))
+    if (record.runtimeConfig !== undefined
+        && (!isRecord(record.runtimeConfig) || Object.keys(record.runtimeConfig).length === 0))
         return false;
-    if (record.machineRuntimeConfig !== undefined && !isRecord(record.machineRuntimeConfig))
+    if (record.machineRuntimeConfig !== undefined
+        && (!isRecord(record.machineRuntimeConfig) || Object.keys(record.machineRuntimeConfig).length === 0))
         return false;
     if (record.machineId !== undefined && (typeof record.machineId !== "string" || record.machineId.trim().length === 0))
         return false;
     if (record.providerCredentialRecords !== undefined
         && (!Array.isArray(record.providerCredentialRecords)
+            || record.providerCredentialRecords.length === 0
             || !record.providerCredentialRecords.every(isProviderCredentialRecord)))
         return false;
+    if (Array.isArray(record.providerCredentialRecords)) {
+        const providers = record.providerCredentialRecords.map((providerRecord) => providerRecord.provider);
+        if (new Set(providers).size !== providers.length)
+            return false;
+    }
+    if (record.runtimeConfig === undefined
+        && record.machineRuntimeConfig === undefined
+        && (!Array.isArray(record.providerCredentialRecords) || record.providerCredentialRecords.length === 0))
+        return false;
     return true;
 }
 function applyRuntimeCredentialBootstrapMessage(message) {
@@ -241,6 +342,114 @@ function applyRuntimeCredentialBootstrapMessage(message) {
     });
     return true;
 }
+async function persistRuntimeCredentialBootstrapMessage(message, options) {
+    if (!isRuntimeCredentialBootstrapMessage(message))
+        return false;
+    const agentName = message.agentName.trim();
+    const now = options.now ?? new Date();
+    if (message.machineId !== undefined && message.machineId.trim() !== options.machineId.trim()) {
+        throw new Error("container credential bootstrap machineId does not match this machine");
+    }
+    let runtimePlan = null;
+    let machinePlan = null;
+    let expectedRuntime = null;
+    let expectedMachine = null;
+    const providerPlans = [];
+    const expectedProviders = new Map();
+    if (message.runtimeConfig) {
+        const current = await refreshRuntimeCredentialConfig(agentName);
+        if (!current.ok && current.reason !== "missing") {
+            throw new Error(`cannot reconcile runtimeConfig at ${current.itemPath}: ${current.error}`);
+        }
+        const base = current.ok ? current.config : {};
+        const merged = reconcileBootstrapFields(base, message.runtimeConfig, "runtimeConfig");
+        expectedRuntime = merged;
+        if (stableJson(merged) !== stableJson(base))
+            runtimePlan = merged;
+    }
+    if (message.machineRuntimeConfig) {
+        const machineId = message.machineId ?? options.machineId;
+        const current = await refreshMachineRuntimeCredentialConfig(agentName, machineId);
+        if (!current.ok && current.reason !== "missing") {
+            throw new Error(`cannot reconcile machineRuntimeConfig at ${current.itemPath}: ${current.error}`);
+        }
+        const base = current.ok ? current.config : {};
+        const merged = reconcileBootstrapFields(base, message.machineRuntimeConfig, "machineRuntimeConfig");
+        expectedMachine = merged;
+        if (stableJson(merged) !== stableJson(base))
+            machinePlan = merged;
+    }
+    for (const record of message.providerCredentialRecords ?? []) {
+        const current = await (0, provider_credentials_1.refreshProviderCredentialPool)(agentName, { providers: [record.provider], skipCache: true });
+        if (!current.ok && current.reason !== "missing") {
+            throw new Error(`cannot reconcile providerCredentialRecords.${record.provider} at ${current.poolPath}: ${current.error}`);
+        }
+        const existing = current.ok ? current.pool.providers[record.provider] : undefined;
+        const credentials = reconcileBootstrapFields(existing?.credentials ?? {}, record.credentials, `providerCredentialRecords.${record.provider}.credentials`);
+        const config = reconcileBootstrapFields(existing?.config ?? {}, record.config, `providerCredentialRecords.${record.provider}.config`);
+        expectedProviders.set(record.provider, { credentials, config });
+        if (!existing || stableJson(credentials) !== stableJson(existing.credentials) || stableJson(config) !== stableJson(existing.config)) {
+            providerPlans.push({
+                provider: record.provider,
+                credentials,
+                config,
+                provenanceSource: existing?.provenance.source ?? record.provenance.source,
+            });
+        }
+    }
+    if (runtimePlan)
+        await upsertRuntimeCredentialConfig(agentName, runtimePlan, now);
+    if (machinePlan) {
+        await upsertMachineRuntimeCredentialConfig(agentName, message.machineId ?? options.machineId, machinePlan, now);
+    }
+    for (const plan of providerPlans) {
+        await (0, provider_credentials_1.upsertProviderCredential)({
+            agentName,
+            provider: plan.provider,
+            credentials: plan.credentials,
+            config: plan.config,
+            provenance: { source: plan.provenanceSource },
+            now,
+        });
+    }
+    if (message.runtimeConfig) {
+        const refreshed = await refreshRuntimeCredentialConfig(agentName);
+        if (!refreshed.ok)
+            throw new Error(`cannot read back runtimeConfig at ${refreshed.itemPath}: ${refreshed.error}`);
+        assertBootstrapReadback(refreshed.config, expectedRuntime, "runtimeConfig");
+    }
+    if (message.machineRuntimeConfig) {
+        const refreshed = await refreshMachineRuntimeCredentialConfig(agentName, message.machineId ?? options.machineId);
+        if (!refreshed.ok)
+            throw new Error(`cannot read back machineRuntimeConfig at ${refreshed.itemPath}: ${refreshed.error}`);
+        assertBootstrapReadback(refreshed.config, expectedMachine, "machineRuntimeConfig");
+    }
+    if ((message.providerCredentialRecords?.length ?? 0) > 0) {
+        const refreshed = await (0, provider_credentials_1.refreshProviderCredentialPool)(agentName);
+        if (!refreshed.ok)
+            throw new Error(`cannot read back providerCredentialRecords at ${refreshed.poolPath}: ${refreshed.error}`);
+        for (const [provider, expected] of expectedProviders) {
+            const record = refreshed.pool.providers[provider];
+            if (!record) {
+                throw new Error(`container credential bootstrap readback did not contain intended fields: providerCredentialRecords.${provider}`);
+            }
+            assertBootstrapReadback(record.credentials, expected.credentials, `providerCredentialRecords.${provider}.credentials`);
+            assertBootstrapReadback(record.config, expected.config, `providerCredentialRecords.${provider}.config`);
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config.runtime_credentials_bootstrap_persisted",
+        message: "persisted container credential bootstrap in the agent vault",
+        meta: {
+            agentName,
+            runtimeConfig: !!message.runtimeConfig,
+            machineRuntimeConfig: !!message.machineRuntimeConfig,
+            providerCredentialRecords: message.providerCredentialRecords?.length ?? 0,
+        },
+    });
+    return true;
+}
 function waitForRuntimeCredentialBootstrap(agentName, options = {}) {
     const timeoutMs = options.timeoutMs ?? 1_500;
     return new Promise((resolve) => {

package/dist/heart/sense-truth.js

@@ -10,6 +10,7 @@ const SENSES = [
     { sense: "mail", label: "Mail", daemonManaged: true },
     { sense: "voice", label: "Voice", daemonManaged: true },
     { sense: "a2a", label: "A2A", daemonManaged: true },
+    { sense: "telegram", label: "Telegram", daemonManaged: true },
     { sense: "workbench", label: "Workbench", daemonManaged: false },
 ];
 function configuredSenses(senses) {
@@ -22,6 +23,7 @@ function configuredSenses(senses) {
         mail: configured.mail ?? { ...identity_1.DEFAULT_AGENT_SENSES.mail },
         voice: configured.voice ?? { ...identity_1.DEFAULT_AGENT_SENSES.voice },
         a2a: configured.a2a ?? { ...identity_1.DEFAULT_AGENT_SENSES.a2a },
+        telegram: configured.telegram ?? { ...identity_1.DEFAULT_AGENT_SENSES.telegram },
         workbench: configured.workbench ?? { ...identity_1.DEFAULT_AGENT_SENSES.workbench },
     };
 }

package/dist/heart/tool-approval.js

@@ -297,6 +297,7 @@ async function executeApprovalDecision(options) {
     catch (error) {
         if (!(error instanceof ApprovalExecutionFailedError))
             throw error;
+        await options.hooks?.afterHandler?.();
         return options.approvalStore.complete({
             approvalId: attempted.approvalId,
             ownerId: attempted.ownerId,

package/dist/heart/turn-context.js

@@ -164,6 +164,7 @@ function readSenseStatusLines() {
         mail: configuredSenses.mail ?? { enabled: false },
         voice: configuredSenses.voice ?? { enabled: false },
         a2a: configuredSenses.a2a ?? { enabled: false },
+        telegram: configuredSenses.telegram ?? { enabled: false },
         workbench: configuredSenses.workbench ?? { enabled: false },
     };
     const payload = (0, config_1.loadConfig)();
@@ -210,6 +211,9 @@ function readSenseStatusLines() {
                 ? openAIRealtimeVoiceReady
                 : cascadeVoiceReady,
         a2a: true,
+        telegram: hasTextField(runtimePayload, "telegramBotToken")
+            && hasTextField(runtimePayload, "telegramAuthorizedUserId")
+            && hasTextField(runtimePayload, "telegramAuthorizedChatId"),
         workbench: false,
     };
     const rows = [
@@ -234,6 +238,10 @@ function readSenseStatusLines() {
             label: "A2A",
             status: senses.a2a.enabled ? "ready" : "disabled",
         },
+        {
+            label: "Telegram",
+            status: !senses.telegram.enabled ? "disabled" : configured.telegram ? "ready" : "needs_config",
+        },
         {
             label: "Workbench",
             // Workbench can be injected at runtime (the Workbench app spawns

package/dist/mind/prompt.js

@@ -348,6 +348,7 @@ const PROCESS_TYPE_LABELS = {
     voice: "voice handler",
     a2a: "a2a handler",
     mcp: "mcp bridge",
+    telegram: "telegram handler",
 };
 function processTypeLabel(channel) {
     return PROCESS_TYPE_LABELS[channel];
@@ -468,6 +469,7 @@ function localSenseStatusLines() {
         mail: configuredSenses.mail ?? { enabled: false },
         voice: configuredSenses.voice ?? { enabled: false },
         a2a: configuredSenses.a2a ?? { enabled: false },
+        telegram: configuredSenses.telegram ?? { enabled: false },
         workbench: configuredSenses.workbench ?? { enabled: false },
     };
     const payload = (0, config_1.loadConfig)();
@@ -493,6 +495,9 @@ function localSenseStatusLines() {
             && hasTextField(voice, "whisperCliPath")
             && hasTextField(voice, "whisperModelPath"),
         a2a: true,
+        telegram: hasTextField(runtimePayload, "telegramBotToken")
+            && hasTextField(runtimePayload, "telegramAuthorizedUserId")
+            && hasTextField(runtimePayload, "telegramAuthorizedChatId"),
         workbench: false,
     };
     const rows = [
@@ -517,6 +522,10 @@ function localSenseStatusLines() {
             label: "A2A",
             status: senses.a2a.enabled ? "ready" : "disabled",
         },
+        {
+            label: "Telegram",
+            status: !senses.telegram.enabled ? "disabled" : configured.telegram ? "ready" : "needs_config",
+        },
         {
             label: "Workbench",
             // Workbench can be injected at runtime (the Workbench app spawns

package/dist/nerves/coverage/source-scanner.js

@@ -1,22 +1,22 @@
 "use strict";
 /**
- * Static source scanner for emitNervesEvent calls.
+ * Static source scanner for emitNervesEvent and emitNervesEventDurable calls.
  *
  * Extracts component:event keys from production source files by
- * regex-matching emitNervesEvent({ component: "...", event: "..." })
+ * regex-matching either static emitter with literal component/event fields.
  * calls. Only accepts static string literals (single or double quotes).
  * Template literals and variable references are rejected.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanSourceForNervesKeys = scanSourceForNervesKeys;
-const EMIT_CALL_RE = /emitNervesEvent\s*\(\s*\{([\s\S]*?)\}\s*\)/g;
+const EMIT_CALL_RE = /emitNervesEvent(?:Durable)?\s*\(\s*\{([\s\S]*?)\}\s*\)/g;
 function extractStringLiteral(block, field) {
     const re = new RegExp(`${field}\\s*:\\s*(['"])((?:(?!\\1).)+)\\1`);
     const match = re.exec(block);
     return match ? match[2] : null;
 }
 /**
- * Scan a source file's content for emitNervesEvent calls and extract
+ * Scan a source file's content for synchronous or durable Nerves calls and extract
  * component:event keys. Only static string literals are accepted.
  */
 function scanSourceForNervesKeys(source) {

package/dist/nerves/index.js

@@ -61,6 +61,24 @@ const LEVEL_PRIORITY = {
     warn: 30,
     error: 40,
 };
+function fsyncFileAndDirectory(filePath) {
+    if ((0, fs_1.existsSync)(filePath)) {
+        const fileDescriptor = (0, fs_1.openSync)(filePath, "r");
+        try {
+            (0, fs_1.fsyncSync)(fileDescriptor);
+        }
+        finally {
+            (0, fs_1.closeSync)(fileDescriptor);
+        }
+    }
+    const directoryDescriptor = (0, fs_1.openSync)((0, path_1.dirname)(filePath), "r");
+    try {
+        (0, fs_1.fsyncSync)(directoryDescriptor);
+    }
+    finally {
+        (0, fs_1.closeSync)(directoryDescriptor);
+    }
+}
 const GLOBAL_SINKS_KEY = Symbol.for("ouroboros.nerves.global-sinks");
 function resolveGlobalSinks() {
     const scope = globalThis;
@@ -248,6 +266,7 @@ function rotateIfNeeded(filePath, optionsOrMaxSize) {
         if ((0, fs_1.existsSync)(plain1)) {
             (0, fs_1.unlinkSync)(plain1);
         }
+        fsyncFileAndDirectory(filePath);
         (0, fs_1.renameSync)(filePath, plain1);
         // Step 3: gzip (or keep plain) the renamed file into the .1 generation.
         if (compress) {
@@ -259,8 +278,10 @@ function rotateIfNeeded(filePath, optionsOrMaxSize) {
             const buf = (0, fs_1.readFileSync)(plain1);
             const compressed = zlib.gzipSync(buf);
             (0, fs_1.writeFileSync)(gz1, compressed);
+            fsyncFileAndDirectory(gz1);
             (0, fs_1.unlinkSync)(plain1);
         }
+        fsyncFileAndDirectory(compress ? generationGzPath(base, ext, 1) : plain1);
         completed = true;
         (0, runtime_1.emitNervesEvent)({
             component: "nerves",
@@ -298,6 +319,33 @@ function createNdjsonFileSink(filePath, optionsOrMaxSize) {
     const queue = [];
     let flushing = false;
     let bytesSinceCheck = 0;
+    let enqueued = 0;
+    let completed = 0;
+    let appendFailure = null;
+    const barriers = [];
+    function settleBarriers() {
+        const ready = barriers.filter((barrier) => barrier.target <= completed);
+        if (ready.length === 0)
+            return;
+        for (const barrier of ready)
+            barriers.splice(barriers.indexOf(barrier), 1);
+        if (appendFailure) {
+            for (const barrier of ready)
+                barrier.reject(appendFailure);
+            return;
+        }
+        try {
+            fsyncFileAndDirectory(filePath);
+            for (const barrier of ready)
+                barrier.resolve();
+        }
+        catch (error) {
+            const failure = error instanceof Error ? error : new Error(String(error));
+            appendFailure = failure;
+            for (const barrier of ready)
+                barrier.reject(failure);
+        }
+    }
     function flush() {
         if (flushing || queue.length === 0)
             return;
@@ -310,31 +358,42 @@ function createNdjsonFileSink(filePath, optionsOrMaxSize) {
             try {
                 rotateIfNeeded(filePath, options);
             }
-            catch {
-                // Rotation errors are surfaced via nerves events; never block writes.
+            catch (rotationError) {
+                appendFailure ??= rotationError instanceof Error ? rotationError : new Error(String(rotationError));
             }
         }
-        (0, fs_1.appendFile)(filePath, line, "utf8", () => {
+        (0, fs_1.appendFile)(filePath, line, "utf8", (error) => {
+            completed += 1;
+            if (error)
+                appendFailure ??= error;
             if (checkAfterAppend) {
                 try {
+                    fsyncFileAndDirectory(filePath);
                     rotateIfNeeded(filePath, options);
                 }
-                catch {
-                    // Rotation errors are surfaced via nerves events; never block writes.
+                catch (rotationError) {
+                    appendFailure ??= rotationError instanceof Error ? rotationError : new Error(String(rotationError));
                 }
             }
+            settleBarriers();
             flushing = false;
             flush();
         });
     }
-    return (entry) => {
+    const sink = ((entry) => {
         const line = verbose
             ? `${JSON.stringify(entry)}\n`
             : `${(0, redact_1.redactString)(JSON.stringify((0, redact_1.redactLogEntry)(entry)))}\n`;
         bytesSinceCheck += line.length;
+        enqueued += 1;
         queue.push(line);
         flush();
-    };
+    });
+    sink.barrier = () => new Promise((resolve, reject) => {
+        barriers.push({ target: enqueued, resolve, reject });
+        settleBarriers();
+    });
+    return sink;
 }
 function registerGlobalLogSink(sink) {
     globalSinks.add(sink);
@@ -356,9 +415,10 @@ function createLogger(options = {}) {
     const configuredLevel = options.level ?? "info";
     const sinks = options.sinks ?? [createStderrSink()];
     const sink = createFanoutSink(sinks);
+    const durableSinks = sinks.filter((candidate) => "barrier" in candidate && typeof candidate.barrier === "function");
     const now = options.now ?? (() => new Date());
-    function emit(level, entry) {
-        if (!shouldEmit(configuredLevel, level)) {
+    function emit(level, entry, force = false) {
+        if (!force && !shouldEmit(configuredLevel, level)) {
             return;
         }
         const payload = {
@@ -378,5 +438,11 @@ function createLogger(options = {}) {
         info: (entry) => emit("info", entry),
         warn: (entry) => emit("warn", entry),
         error: (entry) => emit("error", entry),
+        durabilityBarrier: async () => {
+            if (durableSinks.length === 0)
+                throw new Error("No durable Nerves sink is configured");
+            await Promise.all(durableSinks.map((durableSink) => durableSink.barrier()));
+        },
+        emitDurable: (level, entry) => emit(level, entry, true),
     };
 }

package/dist/nerves/runtime.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setRuntimeLogger = setRuntimeLogger;
 exports.emitNervesEvent = emitNervesEvent;
+exports.emitNervesEventDurable = emitNervesEventDurable;
 const index_1 = require("./index");
 let runtimeLogger = null;
 function getRuntimeLogger() {
@@ -40,3 +41,14 @@ function emitNervesEvent(event) {
         logger.info(payload);
     }
 }
+async function emitNervesEventDurable(event) {
+    const logger = getRuntimeLogger();
+    logger.emitDurable(event.level ?? "info", {
+        event: event.event,
+        trace_id: (0, index_1.ensureTraceId)(event.trace_id),
+        component: event.component,
+        message: event.message,
+        meta: event.meta ?? {},
+    });
+    await logger.durabilityBarrier();
+}

package/dist/repertoire/tool-arguments.js

@@ -16,6 +16,34 @@ const ajv = new ajv_1.default({
     useDefaults: false,
 });
 const validators = new WeakMap();
+function unsupportedSchemaFeature(value, seen = new WeakSet()) {
+    if (value === null)
+        return "null schema values are unsupported";
+    if (typeof value !== "object")
+        return undefined;
+    if (seen.has(value))
+        return "cyclic schemas are unsupported";
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            const reason = unsupportedSchemaFeature(entry, seen);
+            if (reason)
+                return reason;
+        }
+        return undefined;
+    }
+    for (const [key, entry] of Object.entries(value)) {
+        if (key === "patternProperties")
+            return "patternProperties is unsupported";
+        if (key === "type" && (entry === "null" || (Array.isArray(entry) && entry.includes("null")))) {
+            return "null schema types are unsupported";
+        }
+        const reason = unsupportedSchemaFeature(entry, seen);
+        if (reason)
+            return reason;
+    }
+    return undefined;
+}
 function canonicalize(value) {
     if (value === null || typeof value !== "object")
         return JSON.stringify(value);
@@ -33,6 +61,17 @@ function digestJson(value) {
     return digest(canonicalize(value));
 }
 function validateAdvertisedToolArguments(rawArguments, schema) {
+    const unsupported = unsupportedSchemaFeature(schema);
+    if (unsupported) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "repertoire",
+            event: "repertoire.tool_schema_unsupported",
+            message: "advertised tool schema used an unsupported feature",
+            meta: { reason: unsupported },
+        });
+        return { ok: false, reason: `advertised schema is unsupported: ${unsupported}` };
+    }
     let parsed;
     try {
         parsed = JSON.parse(rawArguments);