@ouro.bot/cli 0.1.0-alpha.92 → 0.1.0-alpha.920

package/dist/repertoire/tools-user-profile.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userProfileToolDefinitions = void 0;
+const user_profile_1 = require("./user-profile");
+const credential_access_1 = require("./credential-access");
+const runtime_1 = require("../nerves/runtime");
+function requireFamilyContext(ctx) {
+    if (!ctx?.context?.friend?.id) {
+        return "no friend context — cannot access user profile.";
+    }
+    if (ctx.context.friend.trustLevel !== "family") {
+        return "user profile access requires family trust level.";
+    }
+    return { friendId: ctx.context.friend.id };
+}
+exports.userProfileToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "user_profile_store",
+                description: "Store or update user profile fields (legal name, DOB, passport, etc.) in the agent's vault. Fields are merged with any existing profile. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        fields: {
+                            type: "string",
+                            description: 'JSON object with profile fields to store/update. Keys: legalName, dateOfBirth, gender, nationality, passport, driverLicense, email, phone, addresses, loyaltyPrograms, preferences, emergencyContact.',
+                        },
+                    },
+                    required: ["fields"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_user_profile_store",
+                message: "user_profile_store invoked",
+                meta: { tool: "user_profile_store" },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            let fields;
+            try {
+                fields = JSON.parse(args.fields);
+            }
+            catch {
+                return "invalid JSON in fields parameter.";
+            }
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                await (0, user_profile_1.updateUserProfileFields)(guard.friendId, fields, store);
+                return `profile fields stored for ${guard.friendId}.`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: updateUserProfileFields errors are always Error instances @preserve */
+                return `failed to store profile: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["fields"],
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "stores user profile vault fields" },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "user_profile_get",
+                description: "Retrieve a specific field from a user's profile. Only returns the requested field, never the full profile. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        field: {
+                            type: "string",
+                            description: "The profile field to retrieve: legalName, dateOfBirth, gender, nationality, passport, driverLicense, email, phone, addresses, loyaltyPrograms, preferences, emergencyContact.",
+                        },
+                    },
+                    required: ["field"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_user_profile_get",
+                message: "user_profile_get invoked",
+                meta: { tool: "user_profile_get", field: args.field },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                const value = await (0, user_profile_1.getUserProfileField)(guard.friendId, args.field, store);
+                if (value === undefined) {
+                    return `field "${args.field}" is not set on the profile.`;
+                }
+                /* v8 ignore next -- platform-dependent v8 branch counting on ternary @preserve */
+                return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: getUserProfileField errors are always Error instances @preserve */
+                return `failed to get profile field: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: ["field"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "user_profile_delete",
+                description: "Delete a user's entire profile from the vault. This is irreversible. Requires family trust level.",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        },
+        handler: async (_args, ctx) => {
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.tool_user_profile_delete",
+                message: "user_profile_delete invoked",
+                meta: { tool: "user_profile_delete" },
+            });
+            const guard = requireFamilyContext(ctx);
+            if (typeof guard === "string")
+                return guard;
+            try {
+                const store = (0, credential_access_1.getCredentialStore)();
+                const deleted = await (0, user_profile_1.deleteUserProfile)(guard.friendId, store);
+                return deleted
+                    ? `profile deleted for ${guard.friendId}.`
+                    : `no profile found for ${guard.friendId}.`;
+            }
+            catch (err) {
+                /* v8 ignore next -- defensive: deleteUserProfile errors are always Error instances @preserve */
+                return `failed to delete profile: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+        summaryKeys: [],
+        riskProfile: { mutates: "durable_state_write", risk: "high", reason: "deletes user profile vault item" },
+    },
+];

package/dist/repertoire/tools-vault.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultToolDefinitions = void 0;
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+exports.vaultToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "vault_setup",
+                description: "Set up the agent's credential vault. Creates a Bitwarden account on the configured Vaultwarden server. One-time operation — idempotent if vault already exists.",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        },
+        handler: async () => {
+            const agentName = (0, identity_1.getAgentName)();
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.vault_tool_call",
+                message: "vault_setup invoked",
+                meta: { tool: "vault_setup", agentName },
+            });
+            return [
+                "Vault setup is human-required.",
+                "",
+                "Why I cannot do it here:",
+                "  Creating or unlocking a vault requires secret entry that must stay out of agent context.",
+                "",
+                "Do this in a terminal:",
+                `  ouro vault create --agent ${agentName}`,
+                `  ouro vault unlock --agent ${agentName}`,
+            ].join("\n");
+        },
+        summaryKeys: [],
+    },
+];

package/dist/repertoire/tools-voice-local.js

@@ -0,0 +1,198 @@
+"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.voiceLocalAudioToolDefinition = void 0;
+exports.localAudioToolGate = localAudioToolGate;
+exports.ownerConsentsToSilentJoin = ownerConsentsToSilentJoin;
+exports.createVoiceLocalAudioToolDefinition = createVoiceLocalAudioToolDefinition;
+exports.defaultLocalAudioToolDeps = defaultLocalAudioToolDeps;
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+/**
+ * The tool that lets a family-trusted owner ask the agent to join a call on this Mac through the
+ * BlackHole virtual devices. It has no device arguments: the lane always captures BlackHole 16ch
+ * and plays into BlackHole 2ch, so it can never listen to a physical microphone.
+ */
+const TOOL_NAME = "voice_join_local_audio";
+/** Direct (one person to one agent) text channels. Voice, inner, mail, a2a and mcp never get this tool. */
+const DIRECT_TEXT_CHANNELS = new Set(["cli", "bluebubbles", "telegram"]);
+const DEVICE_ARGUMENTS = new Set(["device", "input_device", "output_device", "microphone", "input", "output", "capture_device", "playback_device"]);
+const ACTIONS = new Set(["join", "leave", "status"]);
+/** One predicate for both the offer (tool selection) and the execution-time re-check. */
+function localAudioToolGate(input) {
+    const context = input.context;
+    if (!context?.friend || !context.channel)
+        return { ok: false, reason: "no resolved friend for this session" };
+    if (input.habitSession || input.autonomousTurnKind || input.currentExternalEvent || input.delegatedCommand || input.relationshipAuthorization || input.voiceCall) {
+        return { ok: false, reason: "this turn is automatic, delegated, relationship-scoped or a live call, not a direct conversation" };
+    }
+    if (!DIRECT_TEXT_CHANNELS.has(context.channel.channel)) {
+        return { ok: false, reason: "it works only in a direct text session (cli, bluebubbles, telegram); Teams cannot confirm a one-to-one chat yet" };
+    }
+    if (context.isGroupChat)
+        return { ok: false, reason: "it is not available in a group chat" };
+    if (context.friend.trustLevel !== "family")
+        return { ok: false, reason: "only a family-trust friend can start it" };
+    return { ok: true };
+}
+const normalizeSentence = (text) => text.replace(/\s+/g, " ").trim().replace(/[.!?;:,\s]+$/u, "").toLowerCase();
+const CONSENT_WORDING = /\b(consent(s|ed)?|agree[sd]?|okay with|ok with|fine with|permission)\b/iu;
+const SILENT_WORDING = /\b(silent(ly)?|quiet(ly)?|no announcement|without (an |the )?announc\w*|don'?t announce|do not announce|skip the announcement)\b/iu;
+const MIN_CONSENT_WORDS = 5;
+/**
+ * True only when the statement is one whole sentence of the owner's current message, word for word,
+ * and that sentence both states consent and asks for a silent join. A fragment ("the call") or a
+ * sentence about something else never counts, so text the model was steered into quoting cannot
+ * turn an ordinary request into a covert recording.
+ */
+function ownerConsentsToSilentJoin(message, statement) {
+    const wanted = normalizeSentence(statement);
+    if (wanted.split(" ").length < MIN_CONSENT_WORDS || !CONSENT_WORDING.test(wanted) || !SILENT_WORDING.test(wanted))
+        return false;
+    const sentences = (message ?? "").split(/(?<=[.!?])\s+|\n+/u).map(normalizeSentence);
+    return sentences.includes(wanted);
+}
+function readString(args, key) {
+    const value = args[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function createVoiceLocalAudioToolDefinition(deps) {
+    return {
+        tool: {
+            type: "function",
+            function: {
+                name: TOOL_NAME,
+                description: [
+                    "join, leave, or check a call on this Mac through the BlackHole virtual audio devices (any call app: FaceTime, Zoom, Meet, a recorder).",
+                    "The call app must use BlackHole 2ch as its microphone and BlackHole 16ch as its speaker. This tool never listens to a physical microphone and takes no device names.",
+                    "Joining announces you aloud as an AI assistant that is transcribing. Skip the announcement only when the owner's current message has a sentence saying everyone consented to a silent join; pass that whole sentence in silent_consent exactly as they wrote it. A paraphrase or a fragment is refused.",
+                    "Several people may share this audio, and you cannot tell voices apart. Use action=leave to hang up.",
+                ].join(" "),
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: { type: "string", enum: ["join", "leave", "status"], description: "join (default), leave, or status" },
+                        participants: { type: "string", description: "who is on the call, as the owner described them" },
+                        occasion: { type: "string", description: "what the call is for" },
+                        owner_alone: { type: "boolean", description: "true only when the owner said they are alone on the call" },
+                        silent_consent: { type: "string", description: "the owner's own words consenting to a silent join (no spoken announcement), copied verbatim from their current message; omit otherwise" },
+                    },
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            const gate = ctx ? localAudioToolGate(ctx) : { ok: false, reason: "no session context" };
+            if (!gate.ok)
+                return `${TOOL_NAME} is not available: ${gate.reason}.`;
+            const provided = Object.keys(args).find((key) => DEVICE_ARGUMENTS.has(key));
+            if (provided) {
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "tools", event: "tool.voice_local_audio_device_refused", message: "local audio tool refused a device argument", meta: { argument: provided } });
+                return "This tool only uses the BlackHole virtual devices and never listens to a physical microphone or any other device. Remove the device argument.";
+            }
+            const action = readString(args, "action") ?? "join";
+            if (!ACTIONS.has(action))
+                return "action must be join, leave, or status.";
+            const agentName = ctx?.agentName;
+            if (!agentName)
+                return `${TOOL_NAME} is not available: no agent name for this session.`;
+            if (action === "leave")
+                return deps.leave(agentName);
+            if (action === "status")
+                return deps.status(agentName);
+            const silentConsent = readString(args, "silent_consent");
+            if (silentConsent && !ownerConsentsToSilentJoin(ctx.currentUserMessage, silentConsent)) {
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "tools", event: "tool.voice_local_audio_silent_refused", message: "silent join refused: consent not in the owner's current message", meta: { agentName } });
+                return "I can't do a silent join from here: the consent has to be one whole sentence of the owner's current message, copied exactly, that says everyone consented to a silent join, and I can't confirm that. Join with the spoken announcement instead, or the owner can run `ouro voice join --silent-consent \"...\"` themselves.";
+            }
+            const friend = ctx.context.friend;
+            const channel = ctx.context.channel.channel;
+            const session = ctx.currentSession;
+            const notify = session
+                ? { friendId: session.friendId, channel: session.channel, key: session.key }
+                : channel === "cli" ? { friendId: friend.id, channel: "cli", key: "session" } : undefined;
+            const request = {
+                agentName,
+                friendId: friend.id,
+                mode: "conversation",
+                ownerName: friend.name,
+                ...(readString(args, "participants") ? { participants: readString(args, "participants") } : {}),
+                ...(readString(args, "occasion") ? { occasion: readString(args, "occasion") } : {}),
+                ...(String(args.owner_alone) === "true" ? { ownerAlone: true } : {}),
+                ...(silentConsent ? { silentConsent } : {}),
+                ...(notify ? { notify } : {}),
+            };
+            (0, runtime_1.emitNervesEvent)({
+                component: "tools",
+                event: "tool.voice_local_audio_join_requested",
+                message: "local audio join requested by the owner",
+                meta: { agentName, silent: String(Boolean(request.silentConsent)), ownerAlone: String(Boolean(request.ownerAlone)), notify: String(Boolean(notify)) },
+            });
+            const result = await deps.launch(request);
+            if (!result.ok)
+                return `I did not join the call: ${result.message}`;
+            return [
+                result.message,
+                request.silentConsent
+                    ? "I joined silently on the owner's stated consent."
+                    : "I am announcing myself aloud as an AI assistant that is transcribing; if I cannot confirm that was spoken I leave and tell the owner.",
+                "The call app must use BlackHole 2ch as its microphone and BlackHole 16ch as its speaker for me to hear and be heard.",
+                notify ? "The owner is notified when I join and when I leave." : "I could not notify the owner's session (no session to notify), so tell them yourself.",
+            ].join(" ");
+        },
+    };
+}
+/** Loaded lazily: the join runner pulls in the whole Realtime session, which itself imports the tool registry. */
+function defaultLocalAudioToolDeps(options = {}) {
+    const agentRoot = options.agentRoot ?? ((agentName) => (0, identity_1.getAgentRoot)(agentName));
+    return {
+        launch: async (request) => {
+            const join = await Promise.resolve().then(() => __importStar(require("../senses/voice/local-audio-join")));
+            const control = await Promise.resolve().then(() => __importStar(require("../senses/voice/local-audio-control")));
+            const launch = options.launch ?? {
+                execPath: process.execPath,
+                cliEntry: path.resolve(__dirname, "../heart/daemon/ouro-entry.js"),
+                spawn: join.defaultLaunchSpawn(control.localAudioPaths(agentRoot(request.agentName))),
+                sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+                now: Date.now,
+                timeoutMs: 300_000,
+            };
+            return join.launchLocalAudioJoin(request, { agentRoot, ...launch });
+        },
+        leave: async (agentName) => (await Promise.resolve().then(() => __importStar(require("../senses/voice/local-audio-join")))).runLocalAudioLeave(agentName, { agentRoot }),
+        status: async (agentName) => (await Promise.resolve().then(() => __importStar(require("../senses/voice/local-audio-join")))).runLocalAudioStatus(agentName, { agentRoot }),
+    };
+}
+exports.voiceLocalAudioToolDefinition = createVoiceLocalAudioToolDefinition(defaultLocalAudioToolDeps());

package/dist/repertoire/tools-voice.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.voiceToolDefinitions = void 0;
+const runtime_1 = require("../nerves/runtime");
+exports.voiceToolDefinitions = [{
+        tool: {
+            type: "function",
+            function: {
+                name: "voice_end_call",
+                description: [
+                    "request that the current live voice call end.",
+                    "Use this only in a voice session when the conversation is actually finished or the caller asked to hang up.",
+                    "After calling it, settle with a brief goodbye if you have not already spoken one; the transport will try to let already-sent speech finish before hanging up.",
+                ].join(" "),
+                parameters: {
+                    type: "object",
+                    properties: {
+                        reason: {
+                            type: "string",
+                            description: "short reason for ending the call, such as caller said goodbye",
+                        },
+                    },
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            const reason = typeof args.reason === "string" && args.reason.trim().length > 0
+                ? args.reason.trim()
+                : undefined;
+            (0, runtime_1.emitNervesEvent)({
+                component: "tools",
+                event: "tool.voice_end_call_start",
+                message: "voice end-call tool requested",
+                meta: { hasActiveCall: String(Boolean(ctx?.voiceCall)), ...(reason ? { reasonLength: reason.length } : {}) },
+            });
+            if (!ctx?.voiceCall) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "tools",
+                    event: "tool.voice_end_call_end",
+                    message: "voice end-call tool had no active call",
+                    meta: { hasActiveCall: "false" },
+                });
+                return "no active voice call to end";
+            }
+            await ctx.voiceCall.requestEnd(reason);
+            (0, runtime_1.emitNervesEvent)({
+                component: "tools",
+                event: "tool.voice_end_call_end",
+                message: "voice end-call request accepted",
+                meta: { hasActiveCall: "true" },
+            });
+            return "(voice call ending)";
+        },
+    }, {
+        tool: {
+            type: "function",
+            function: {
+                name: "voice_play_audio",
+                description: [
+                    "play a short non-speech audio clip into the current live voice call.",
+                    "Use this when the caller asks to hear a tone, sample, clip, or other audio over the phone.",
+                    "For a simple test use source=tone. For clips, use source=url or source=file with a short audio asset; the transport may cap duration.",
+                    "Do not use it for your normal spoken response.",
+                ].join(" "),
+                parameters: {
+                    type: "object",
+                    properties: {
+                        source: {
+                            type: "string",
+                            enum: ["tone", "url", "file"],
+                            description: "audio source type; defaults to tone",
+                        },
+                        url: {
+                            type: "string",
+                            description: "http(s) URL of a short audio clip when source=url",
+                        },
+                        path: {
+                            type: "string",
+                            description: "path to a short local audio clip when source=file",
+                        },
+                        label: {
+                            type: "string",
+                            description: "short human-readable label for the audio",
+                        },
+                        toneHz: {
+                            type: "number",
+                            description: "tone frequency in Hz when source=tone",
+                        },
+                        durationMs: {
+                            type: "number",
+                            description: "requested duration in milliseconds; short clips only",
+                        },
+                    },
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            const source = args.source === "url" || args.source === "file" || args.source === "tone"
+                ? args.source
+                : "tone";
+            const duration = args.durationMs;
+            const frequency = args.toneHz;
+            const durationMs = typeof duration === "number" ? duration
+                : typeof duration === "string" && duration.trim() ? Number(duration) : undefined;
+            const toneHz = typeof frequency === "number" ? frequency
+                : typeof frequency === "string" && frequency.trim() ? Number(frequency) : undefined;
+            const request = {
+                source,
+                /* v8 ignore next -- sparse playback argument permutations are covered in the transport-level voice_play_audio tests @preserve */
+                ...(typeof args.url === "string" ? { url: args.url } : {}),
+                /* v8 ignore next -- sparse playback argument permutations are covered in the transport-level voice_play_audio tests @preserve */
+                ...(typeof args.path === "string" ? { path: args.path } : {}),
+                /* v8 ignore next -- sparse playback argument permutations are covered in the transport-level voice_play_audio tests @preserve */
+                ...(typeof args.label === "string" ? { label: args.label } : {}),
+                ...(Number.isFinite(toneHz) ? { toneHz } : {}),
+                ...(Number.isFinite(durationMs) ? { durationMs } : {}),
+            };
+            (0, runtime_1.emitNervesEvent)({
+                component: "tools",
+                event: "tool.voice_play_audio_start",
+                message: "voice play-audio tool requested",
+                meta: { hasActiveCallAudio: String(Boolean(ctx?.voiceCall?.playAudio)), source },
+            });
+            if (!ctx?.voiceCall?.playAudio) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "tools",
+                    event: "tool.voice_play_audio_end",
+                    message: "voice play-audio tool had no active audio-capable call",
+                    meta: { hasActiveCallAudio: "false", source },
+                });
+                return "no active voice call audio path";
+            }
+            const result = await ctx.voiceCall.playAudio(request);
+            (0, runtime_1.emitNervesEvent)({
+                component: "tools",
+                event: "tool.voice_play_audio_end",
+                message: "voice play-audio request accepted",
+                meta: { hasActiveCallAudio: "true", source, durationMs: String(result.durationMs) },
+            });
+            if (result.toolResult?.trim())
+                return result.toolResult.trim();
+            return `(played audio: ${result.label}, ${Math.round(result.durationMs)}ms)`;
+        },
+        riskProfile: { mutates: "external_side_effect", risk: "high", reason: "plays audio into a live voice call" },
+    }];