ff1-cli 1.0.2 → 1.0.3

package/README.md

@@ -42,15 +42,17 @@ ff1 play "https://example.com/video.mp4" -d "Living Room Display" --skip-verify
 ```bash
 npm install
 npm run dev -- config init
-npm run dev chat
+npm run dev -- chat
 npm run dev -- play "https://example.com/video.mp4" -d "Living Room Display" --skip-verify
 ```
 
 ## Documentation
 
-- Getting started, config, and usage: `./docs/README.md`
+- Getting started and usage: `./docs/README.md`
+- Configuration: `./docs/CONFIGURATION.md`
 - Function calling architecture: `./docs/FUNCTION_CALLING.md`
 - Examples: `./docs/EXAMPLES.md`
+- SSH access: `ff1 ssh enable|disable` in `./docs/README.md`
 
 ## Scripts
 

package/config.json.example

@@ -1,14 +1,14 @@
 {
-  "defaultModel": "gemini",
+  "defaultModel": "grok",
   "models": {
     "grok": {
       "apiKey": "YOUR_GROK_API_KEY_FROM_X_AI_CONSOLE",
       "baseURL": "https://api.x.ai/v1",
-      "model": "grok-4-fast-non-reasoning",
+      "model": "grok-beta",
       "availableModels": [
-        "grok-4-fast-reasoning",
-        "grok-4-fast-non-reasoning",
-        "grok-code-fast-1"
+        "grok-beta",
+        "grok-2-1212",
+        "grok-2-vision-1212"
       ],
       "timeout": 120000,
       "maxRetries": 3,
@@ -16,11 +16,13 @@
       "maxTokens": 4000,
       "supportsFunctionCalling": true
     },
-    "gpt": {
+    "chatgpt": {
       "apiKey": "YOUR_OPENAI_API_KEY_FROM_PLATFORM_OPENAI_COM",
       "baseURL": "https://api.openai.com/v1",
-      "model": "gpt-4o-mini",
+      "model": "gpt-4.1",
       "availableModels": [
+        "gpt-4.1",
+        "gpt-4.1-mini",
         "gpt-4o",
         "gpt-4o-mini",
         "gpt-4-turbo"
@@ -63,7 +65,7 @@
     }
   ],
   "playlist": {
-    "privateKey": "YOUR_ED25519_PRIVATE_KEY_BASE64_ENCODED_RUN_NODE_INDEX_JS_GENERATE_KEYS"
+    "privateKey": "YOUR_ED25519_PRIVATE_KEY_BASE64_OR_HEX"
   },
   "ff1Devices": {
     "devices": [

package/dist/index.js

@@ -38,7 +38,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 // Suppress punycode deprecation warnings from dependencies
-process.removeAllListeners('warning');
 process.on('warning', (warning) => {
     if (warning.name === 'DeprecationWarning' && warning.message.includes('punycode')) {
         return; // Ignore punycode deprecation warnings from dependencies
@@ -55,6 +54,8 @@ const fs_2 = require("fs");
 const path_1 = require("path");
 const config_1 = require("./src/config");
 const main_1 = require("./src/main");
+const ff1_discovery_1 = require("./src/utilities/ff1-discovery");
+const playlist_source_1 = require("./src/utilities/playlist-source");
 // Load version from package.json
 // Try built location first (dist/index.js -> ../package.json)
 // Fall back to dev location (index.ts -> ./package.json)
@@ -76,7 +77,7 @@ const placeholderPattern = /YOUR_|your_/;
  * @param {string} outputPath - Path where the playlist was saved
  */
 function displayPlaylistSummary(playlist, outputPath) {
-    console.log(chalk_1.default.green('\nPlaylist created'));
+    console.log(chalk_1.default.green('\nPlaylist saved'));
     console.log(chalk_1.default.dim(`  Output: ./${outputPath}`));
     console.log(chalk_1.default.dim('  Next: send last | publish playlist'));
     console.log();
@@ -116,8 +117,49 @@ async function ensureConfigFile() {
     const createdPath = await (0, config_1.createSampleConfig)(userPath);
     return { path: createdPath, created: true };
 }
+/**
+ * Parse TTL duration string into seconds.
+ *
+ * @param {string} ttl - Duration string (e.g. "900", "15m", "2h")
+ * @returns {number} TTL in seconds
+ * @throws {Error} When ttl format is invalid
+ */
+function parseTtlSeconds(ttl) {
+    const trimmed = ttl.trim();
+    const match = trimmed.match(/^(\d+)([smh]?)$/i);
+    if (!match) {
+        throw new Error('TTL must be a number of seconds or a duration like 15m or 2h');
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    if (Number.isNaN(value)) {
+        throw new Error('TTL value is not a number');
+    }
+    if (unit === 'm') {
+        return value * 60;
+    }
+    if (unit === 'h') {
+        return value * 60 * 60;
+    }
+    return value;
+}
+/**
+ * Read an SSH public key from a file.
+ *
+ * @param {string} keyPath - Path to public key file
+ * @returns {Promise<string>} Public key contents
+ * @throws {Error} When the file is empty or unreadable
+ */
+async function readPublicKeyFile(keyPath) {
+    const content = await fs_1.promises.readFile(keyPath, 'utf-8');
+    const trimmed = content.trim();
+    if (!trimmed) {
+        throw new Error('Public key file is empty');
+    }
+    return trimmed;
+}
 function normalizeDeviceHost(host) {
-    let normalized = host.trim();
+    let normalized = host.trim().replace(/\.$/, '');
     if (!normalized) {
         return normalized;
     }
@@ -133,6 +175,81 @@ function normalizeDeviceHost(host) {
         return normalized;
     }
 }
+/**
+ * Print a focused failure for playlist source loading problems.
+ *
+ * @param {string} source - Playlist source value
+ * @param {Error} error - Load or parse error
+ */
+function printPlaylistSourceLoadFailure(source, error) {
+    const isUrl = (0, playlist_source_1.isPlaylistSourceUrl)(source);
+    if (isUrl) {
+        console.error(chalk_1.default.red('\nCould not load hosted playlist URL'));
+        console.error(chalk_1.default.red(`  Source: ${source}`));
+        console.error(chalk_1.default.red(`  Error: ${error.message}`));
+        console.log(chalk_1.default.yellow('\n  Hint:'));
+        console.log(chalk_1.default.yellow('    • Check the URL is reachable'));
+        console.log(chalk_1.default.yellow('    • Confirm the response is JSON'));
+        console.log(chalk_1.default.yellow('    • Use a local file path if network access is unavailable'));
+        return;
+    }
+    console.error(chalk_1.default.red(`\nCould not load playlist file`));
+    console.error(chalk_1.default.red(`  Source: ${source}`));
+    console.error(chalk_1.default.red(`  Error: ${error.message}`));
+}
+/**
+ * Print playlist verification failure details consistently.
+ *
+ * @param {Object} verifyResult - DP-1 verification result
+ * @param {string} [source] - Optional source label
+ */
+function printPlaylistVerificationFailure(verifyResult, source) {
+    console.error(chalk_1.default.red(`\nPlaylist verification failed:${source ? ` (${source})` : ''}`), verifyResult.error);
+    if (verifyResult.details && verifyResult.details.length > 0) {
+        console.log(chalk_1.default.yellow('\n   Validation errors:'));
+        verifyResult.details.forEach((detail) => {
+            console.log(chalk_1.default.yellow(`     • ${detail.path}: ${detail.message}`));
+        });
+    }
+    console.log(chalk_1.default.yellow('\n   Use --skip-verify to send anyway (not recommended)\n'));
+}
+/**
+ * Load and verify a DP-1 playlist from local file or hosted URL.
+ *
+ * @param {string} source - Playlist source value
+ * @returns {Promise<Object>} Verification result with parsed playlist when valid
+ */
+async function verifyPlaylistSource(source) {
+    const loaded = await (0, playlist_source_1.loadPlaylistSource)(source);
+    const verifier = await Promise.resolve().then(() => __importStar(require('./src/utilities/playlist-verifier')));
+    const { verifyPlaylist } = verifier;
+    const verifyResult = verifyPlaylist(loaded.playlist);
+    return {
+        ...verifyResult,
+        playlist: verifyResult.valid ? loaded.playlist : undefined,
+    };
+}
+/**
+ * Run a shared verify/validate command flow.
+ *
+ * @param {string} source - Playlist source path or URL
+ */
+async function runVerifyCommand(source) {
+    try {
+        console.log(chalk_1.default.blue('\nVerify playlist\n'));
+        const verifier = await Promise.resolve().then(() => __importStar(require('./src/utilities/playlist-verifier')));
+        const { printVerificationResult } = verifier;
+        const result = await verifyPlaylistSource(source);
+        printVerificationResult(result, source);
+        if (!result.valid) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        printPlaylistSourceLoadFailure(source, error);
+        process.exit(1);
+    }
+}
 async function promptYesNo(ask, question, defaultYes = true) {
     const suffix = defaultYes ? 'Y/n' : 'y/N';
     const answer = (await ask(`${question} [${suffix}] `)).trim().toLowerCase();
@@ -203,7 +320,6 @@ program
         const keyHelpUrls = {
             grok: 'https://console.x.ai/',
             gpt: 'https://platform.openai.com/api-keys',
-            chatgpt: 'https://platform.openai.com/api-keys',
             gemini: 'https://aistudio.google.com/app/apikey',
         };
         if (!hasApiKeyForModel) {
@@ -248,6 +364,41 @@ program
             };
         }
         const existingDevice = config.ff1Devices?.devices?.[0];
+        const discoveryResult = await (0, ff1_discovery_1.discoverFF1Devices)({ timeoutMs: 2000 });
+        const discoveredDevices = discoveryResult.devices;
+        let selectedDeviceIndex = null;
+        if (discoveryResult.error && discoveredDevices.length === 0) {
+            const errorMessage = discoveryResult.error.endsWith('.')
+                ? discoveryResult.error
+                : `${discoveryResult.error}.`;
+            console.log(chalk_1.default.dim(`mDNS discovery failed: ${errorMessage} Continuing with manual entry.`));
+        }
+        else if (discoveryResult.error) {
+            console.log(chalk_1.default.dim(`mDNS discovery warning: ${discoveryResult.error}`));
+        }
+        if (discoveredDevices.length > 0) {
+            console.log(chalk_1.default.green('\nFF1 devices on your network:'));
+            discoveredDevices.forEach((device, index) => {
+                const displayId = device.id || device.name || device.host;
+                console.log(chalk_1.default.dim(`  ${index + 1}) ${displayId}`));
+            });
+            const selectionAnswer = await ask(`Select device [1-${discoveredDevices.length}] or press Enter to skip: `);
+            if (selectionAnswer) {
+                const parsedIndex = Number.parseInt(selectionAnswer, 10);
+                if (Number.isNaN(parsedIndex) ||
+                    parsedIndex < 1 ||
+                    parsedIndex > discoveredDevices.length) {
+                    console.log(chalk_1.default.red('Invalid selection. Skipping auto-discovery.'));
+                }
+                else {
+                    selectedDeviceIndex = parsedIndex - 1;
+                }
+            }
+        }
+        else if (!discoveryResult.error) {
+            console.log(chalk_1.default.dim('No FF1 devices found via mDNS. Continuing with manual entry.'));
+        }
+        const selectedDevice = selectedDeviceIndex === null ? null : discoveredDevices[selectedDeviceIndex];
         {
             const existingHost = existingDevice?.host || '';
             let rawDefaultDeviceId = '';
@@ -263,25 +414,32 @@ program
                 }
             }
             const defaultDeviceId = isMissingConfigValue(rawDefaultDeviceId) ? '' : rawDefaultDeviceId;
-            const idPrompt = defaultDeviceId
-                ? `Device ID (e.g. ff1-ABCD1234) [${defaultDeviceId}]: `
-                : 'Device ID (e.g. ff1-ABCD1234): ';
-            const idAnswer = await ask(idPrompt);
-            const rawDeviceId = idAnswer || defaultDeviceId;
             let hostValue = '';
-            if (rawDeviceId) {
-                const looksLikeHost = rawDeviceId.includes('.') ||
-                    rawDeviceId.includes(':') ||
-                    rawDeviceId.startsWith('http');
-                if (looksLikeHost) {
-                    hostValue = normalizeDeviceHost(rawDeviceId);
-                }
-                else {
-                    const deviceId = rawDeviceId.startsWith('ff1-') ? rawDeviceId : `ff1-${rawDeviceId}`;
-                    hostValue = normalizeDeviceHost(`${deviceId}.local`);
+            if (selectedDevice) {
+                hostValue = normalizeDeviceHost(`${selectedDevice.host}:${selectedDevice.port}`);
+                console.log(chalk_1.default.dim(`Using discovered device: ${selectedDevice.name} (${selectedDevice.host}:${selectedDevice.port})`));
+            }
+            else {
+                const idPrompt = defaultDeviceId
+                    ? `Device ID (e.g. ff1-ABCD1234) [${defaultDeviceId}]: `
+                    : 'Device ID (e.g. ff1-ABCD1234): ';
+                const idAnswer = await ask(idPrompt);
+                const rawDeviceId = idAnswer || defaultDeviceId;
+                if (rawDeviceId) {
+                    const looksLikeHost = rawDeviceId.includes('.') ||
+                        rawDeviceId.includes(':') ||
+                        rawDeviceId.startsWith('http');
+                    if (looksLikeHost) {
+                        hostValue = normalizeDeviceHost(rawDeviceId);
+                    }
+                    else {
+                        const deviceId = rawDeviceId.startsWith('ff1-') ? rawDeviceId : `ff1-${rawDeviceId}`;
+                        hostValue = normalizeDeviceHost(`${deviceId}.local`);
+                    }
                 }
             }
-            const rawName = existingDevice?.name || 'ff1';
+            const discoveredName = selectedDevice?.name || selectedDevice?.id || '';
+            const rawName = existingDevice?.name || discoveredName || 'ff1';
             const defaultName = isMissingConfigValue(rawName) ? '' : rawName;
             const namePrompt = defaultName
                 ? `Device name (kitchen, office, etc.) [${defaultName}]: `
@@ -434,7 +592,7 @@ program
                 });
                 // Print final summary
                 if (result && result.playlist) {
-                    console.log(chalk_1.default.green('\nPlaylist created'));
+                    console.log(chalk_1.default.green('\nPlaylist saved'));
                     console.log(chalk_1.default.dim(`  Title: ${result.playlist.title}`));
                     console.log(chalk_1.default.dim(`  Items: ${result.playlist.items?.length || 0}`));
                     console.log(chalk_1.default.dim(`  Output: ${options.output}\n`));
@@ -537,48 +695,16 @@ program
 program
     .command('verify')
     .description('Verify a DP1 playlist file against DP-1 specification')
-    .argument('<file>', 'Path to the playlist file')
+    .argument('<file>', 'Path to the playlist file or hosted playlist URL')
     .action(async (file) => {
-    try {
-        console.log(chalk_1.default.blue('\nVerify playlist\n'));
-        // Import the verification utility
-        const verifier = await Promise.resolve().then(() => __importStar(require('./src/utilities/playlist-verifier')));
-        const { verifyPlaylistFile, printVerificationResult } = verifier;
-        // Verify the playlist
-        const result = await verifyPlaylistFile(file);
-        // Print results
-        printVerificationResult(result, file);
-        if (!result.valid) {
-            process.exit(1);
-        }
-    }
-    catch (error) {
-        console.error(chalk_1.default.red('\nError:'), error.message);
-        process.exit(1);
-    }
+    await runVerifyCommand(file);
 });
 program
     .command('validate')
     .description('Validate a DP1 playlist file (alias for verify)')
-    .argument('<file>', 'Path to the playlist file')
+    .argument('<file>', 'Path to the playlist file or hosted playlist URL')
     .action(async (file) => {
-    try {
-        console.log(chalk_1.default.blue('\nVerify playlist\n'));
-        // Import the verification utility
-        const verifier = await Promise.resolve().then(() => __importStar(require('./src/utilities/playlist-verifier')));
-        const { verifyPlaylistFile, printVerificationResult } = verifier;
-        // Verify the playlist
-        const result = await verifyPlaylistFile(file);
-        // Print results
-        printVerificationResult(result, file);
-        if (!result.valid) {
-            process.exit(1);
-        }
-    }
-    catch (error) {
-        console.error(chalk_1.default.red('\nError:'), error.message);
-        process.exit(1);
-    }
+    await runVerifyCommand(file);
 });
 program
     .command('sign')
@@ -638,14 +764,7 @@ program
             const { verifyPlaylist } = verifier;
             const verifyResult = verifyPlaylist(playlist);
             if (!verifyResult.valid) {
-                console.error(chalk_1.default.red('\nPlaylist verification failed:'), verifyResult.error);
-                if (verifyResult.details && verifyResult.details.length > 0) {
-                    console.log(chalk_1.default.yellow('\n   Validation errors:'));
-                    verifyResult.details.forEach((detail) => {
-                        console.log(chalk_1.default.yellow(`     • ${detail.path}: ${detail.message}`));
-                    });
-                }
-                console.log(chalk_1.default.yellow('\n   Use --skip-verify to send anyway (not recommended)\n'));
+                printPlaylistVerificationFailure(verifyResult);
                 process.exit(1);
             }
         }
@@ -680,31 +799,23 @@ program
 });
 program
     .command('send')
-    .description('Send a playlist file to an FF1 device')
-    .argument('<file>', 'Path to the playlist file')
+    .description('Send a playlist to an FF1 device')
+    .argument('<file>', 'Playlist file path or hosted playlist URL')
     .option('-d, --device <name>', 'Device name (uses first device if not specified)')
     .option('--skip-verify', 'Skip playlist verification before sending')
     .action(async (file, options) => {
     try {
         console.log(chalk_1.default.blue('\nSend playlist to FF1\n'));
-        // Read the playlist file
-        const content = await fs_1.promises.readFile(file, 'utf-8');
-        const playlist = JSON.parse(content);
+        const playlistResult = await (0, playlist_source_1.loadPlaylistSource)(file);
+        const playlist = playlistResult.playlist;
         // Verify playlist before sending (unless skipped)
         if (!options.skipVerify) {
-            console.log(chalk_1.default.cyan('Verify playlist'));
+            console.log(chalk_1.default.cyan(`Verify playlist (${playlistResult.sourceType}: ${playlistResult.source})`));
             const verifier = await Promise.resolve().then(() => __importStar(require('./src/utilities/playlist-verifier')));
             const { verifyPlaylist } = verifier;
             const verifyResult = verifyPlaylist(playlist);
             if (!verifyResult.valid) {
-                console.error(chalk_1.default.red('\nPlaylist verification failed:'), verifyResult.error);
-                if (verifyResult.details && verifyResult.details.length > 0) {
-                    console.log(chalk_1.default.yellow('\n   Validation errors:'));
-                    verifyResult.details.forEach((detail) => {
-                        console.log(chalk_1.default.yellow(`     • ${detail.path}: ${detail.message}`));
-                    });
-                }
-                console.log(chalk_1.default.yellow('\n   Use --skip-verify to send anyway (not recommended)\n'));
+                printPlaylistVerificationFailure(verifyResult, `source: ${playlistResult.source}`);
                 process.exit(1);
             }
             console.log(chalk_1.default.green('✓ Verified\n'));
@@ -872,7 +983,7 @@ program
             outputPath: options.output,
         });
         if (result && result.playlist) {
-            console.log(chalk_1.default.green('\nPlaylist created'));
+            console.log(chalk_1.default.green('\nPlaylist saved'));
             console.log(chalk_1.default.dim(`  Title: ${result.playlist.title}`));
             console.log(chalk_1.default.dim(`  Items: ${result.playlist.items?.length || 0}`));
             console.log(chalk_1.default.dim(`  Output: ${options.output}\n`));
@@ -943,4 +1054,68 @@ program
         process.exit(1);
     }
 });
+program
+    .command('ssh')
+    .description('Enable or disable SSH access on an FF1 device')
+    .argument('<action>', 'Action: enable or disable')
+    .option('-d, --device <name>', 'Device name (uses first device if not specified)')
+    .option('--pubkey <path>', 'SSH public key file (required for enable)')
+    .option('--ttl <duration>', 'Auto-disable after duration (e.g. 30m, 2h, 900s)')
+    .action(async (action, options) => {
+    try {
+        const normalizedAction = action.trim().toLowerCase();
+        if (normalizedAction !== 'enable' && normalizedAction !== 'disable') {
+            console.error(chalk_1.default.red('\nUnknown action:'), action);
+            console.log(chalk_1.default.yellow('Available actions: enable, disable\n'));
+            process.exit(1);
+        }
+        const isEnable = normalizedAction === 'enable';
+        let publicKey;
+        if (isEnable) {
+            if (!options.pubkey) {
+                console.error(chalk_1.default.red('\nPublic key is required to enable SSH'));
+                console.log(chalk_1.default.yellow('Use: ff1 ssh enable --pubkey ~/.ssh/id_ed25519.pub\n'));
+                process.exit(1);
+            }
+            publicKey = await readPublicKeyFile(options.pubkey);
+        }
+        let ttlSeconds;
+        if (options.ttl) {
+            ttlSeconds = parseTtlSeconds(options.ttl);
+        }
+        const { sendSshAccessCommand } = await Promise.resolve().then(() => __importStar(require('./src/utilities/ssh-access')));
+        const result = await sendSshAccessCommand({
+            enabled: isEnable,
+            deviceName: options.device,
+            publicKey,
+            ttlSeconds,
+        });
+        if (result.success) {
+            console.log(chalk_1.default.green(`SSH ${isEnable ? 'enabled' : 'disabled'}`));
+            if (result.deviceName) {
+                console.log(chalk_1.default.dim(`  Device: ${result.deviceName}`));
+            }
+            if (result.device) {
+                console.log(chalk_1.default.dim(`  Host: ${result.device}`));
+            }
+            if (result.response && typeof result.response === 'object') {
+                const expiresAt = result.response.expiresAt;
+                if (expiresAt) {
+                    console.log(chalk_1.default.dim(`  Expires: ${expiresAt}`));
+                }
+            }
+            console.log();
+            return;
+        }
+        console.error(chalk_1.default.red('\nSSH request failed:'), result.error);
+        if (result.details) {
+            console.error(chalk_1.default.dim(`  Details: ${result.details}`));
+        }
+        process.exit(1);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nError:'), error.message);
+        process.exit(1);
+    }
+});
 program.parse();

package/dist/src/ai-orchestrator/index.js

@@ -7,6 +7,18 @@ const registry = require('./registry');
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function stableStringify(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+    }
+    const keys = Object.keys(value).sort();
+    return `{${keys
+        .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`)
+        .join(',')}}`;
+}
 async function createCompletionWithRetry(client, requestParams, maxRetries = 0) {
     for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
         try {
@@ -456,8 +468,9 @@ KEY RULES
 - The registry system handles full objects internally
 
 OUTPUT RULES
+- Do NOT print JSON arguments.
 - Before each function call, print exactly one sentence: "→ I'm …" describing the action.
-- Then call exactly one function with JSON arguments.
+- Call the function ONLY via tool calls and do not include tool names, JSON, or arguments in assistant content.
 - No chain‑of‑thought or extra narration; keep public output minimal.
 
 STOPPING CONDITIONS
@@ -529,6 +542,7 @@ async function buildPlaylistWithAI(params, options = {}) {
     let collectedItems = [];
     let verificationFailures = 0;
     let sentToDevice = false;
+    const queryRequirementCache = new Map();
     const maxIterations = 20;
     const maxVerificationRetries = 3;
     while (iterationCount < maxIterations) {
@@ -626,10 +640,32 @@ async function buildPlaylistWithAI(params, options = {}) {
                 continue; // Go to next iteration
             }
         }
+        const contentText = message.content || '';
+        const looksLikeToolAttempt = !message.tool_calls &&
+            contentText &&
+            (contentText.includes("→ I'm") ||
+                contentText.includes('"requirement"') ||
+                contentText.trim().startsWith('{'));
+        if (looksLikeToolAttempt && iterationCount < maxIterations - 1) {
+            if (verbose) {
+                console.log(chalk.yellow('AI returned tool arguments in text. Forcing function call with a system reminder.'));
+            }
+            messages.push(message);
+            messages.push({
+                role: 'system',
+                content: 'CRITICAL: You MUST call the required function via tool_calls. Do not output JSON or arguments in plain text. Call the function now.',
+            });
+            continue;
+        }
         messages.push(message);
-        // Always print AI content when present
+        // Only print non-json assistant content while keeping function-call noise low.
         if (message.content) {
-            console.log(chalk.cyan(message.content));
+            const trimmed = message.content.trim();
+            const hasToolCalls = message.tool_calls && message.tool_calls.length > 0;
+            const isJson = trimmed.startsWith('{') || trimmed.startsWith('[');
+            if (!isJson && (verbose || !hasToolCalls)) {
+                console.log(chalk.cyan(trimmed));
+            }
         }
         if (verbose) {
             console.log(chalk.dim(`\nIteration ${iterationCount}:`));
@@ -647,12 +683,33 @@ async function buildPlaylistWithAI(params, options = {}) {
                     console.log(chalk.dim(`    Input: ${JSON.stringify(args, null, 2).split('\n').join('\n    ')}`));
                 }
                 try {
-                    const result = await executeFunction(functionName, args);
+                    let result;
+                    let usedCache = false;
+                    if (functionName === 'query_requirement') {
+                        const cacheKey = stableStringify({
+                            requirement: args.requirement,
+                            duration: args.duration,
+                        });
+                        if (queryRequirementCache.has(cacheKey)) {
+                            result = queryRequirementCache.get(cacheKey);
+                            usedCache = true;
+                            if (verbose) {
+                                console.log(chalk.dim('    ↺ Using cached result for duplicate query_requirement'));
+                            }
+                        }
+                        else {
+                            result = await executeFunction(functionName, args);
+                            queryRequirementCache.set(cacheKey, result);
+                        }
+                    }
+                    else {
+                        result = await executeFunction(functionName, args);
+                    }
                     if (verbose) {
                         console.log(chalk.dim(`    Output: ${JSON.stringify(result, null, 2).split('\n').join('\n    ')}`));
                     }
                     // Track collected item IDs from query_requirement
-                    if (functionName === 'query_requirement' && Array.isArray(result)) {
+                    if (functionName === 'query_requirement' && Array.isArray(result) && !usedCache) {
                         // Result now contains minimal item objects with id field
                         const itemIds = result.map((item) => item.id).filter((id) => id);
                         collectedItems = collectedItems.concat(itemIds); // Now storing IDs, not full items