@ouro.bot/cli 0.1.0-alpha.62 → 0.1.0-alpha.637

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.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 durationMs = typeof args.durationMs === "string" && args.durationMs.trim()
+                ? Number(args.durationMs)
+                : undefined;
+            const toneHz = typeof args.toneHz === "string" && args.toneHz.trim()
+                ? Number(args.toneHz)
+                : 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" },
+    }];