@sovovs/bycli 1.8.0

package/clis/chatgpt-app/ax.js

@@ -0,0 +1,385 @@
+import { execFileSync, execSync } from 'node:child_process';
+const AX_READ_SCRIPT = `
+import Cocoa
+import ApplicationServices
+
+func attr(_ el: AXUIElement, _ name: String) -> AnyObject? {
+    var value: CFTypeRef?
+    guard AXUIElementCopyAttributeValue(el, name as CFString, &value) == .success else { return nil }
+    return value as AnyObject?
+}
+
+func s(_ el: AXUIElement, _ name: String) -> String? {
+    if let v = attr(el, name) as? String, !v.isEmpty { return v }
+    return nil
+}
+
+func children(_ el: AXUIElement) -> [AXUIElement] {
+    (attr(el, kAXChildrenAttribute as String) as? [AnyObject] ?? []).map { $0 as! AXUIElement }
+}
+
+func collectLists(_ el: AXUIElement, into out: inout [AXUIElement]) {
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    if role == kAXListRole as String { out.append(el) }
+    for c in children(el) { collectLists(c, into: &out) }
+}
+
+func collectTexts(_ el: AXUIElement, into out: inout [String]) {
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    if role == kAXStaticTextRole as String {
+        if let text = s(el, kAXDescriptionAttribute as String), !text.isEmpty {
+            out.append(text)
+        }
+    }
+    for c in children(el) { collectTexts(c, into: &out) }
+}
+
+guard let app = NSRunningApplication.runningApplications(withBundleIdentifier: "com.openai.chat").first else {
+    fputs("ChatGPT not running\\n", stderr)
+    exit(1)
+}
+
+let axApp = AXUIElementCreateApplication(app.processIdentifier)
+guard let win = attr(axApp, kAXFocusedWindowAttribute as String) as! AXUIElement? else {
+    fputs("No focused ChatGPT window\\n", stderr)
+    exit(1)
+}
+
+var lists: [AXUIElement] = []
+collectLists(win, into: &lists)
+
+var best: [String] = []
+for list in lists {
+    var texts: [String] = []
+    collectTexts(list, into: &texts)
+    if texts.count > best.count {
+        best = texts
+    }
+}
+
+let data = try! JSONSerialization.data(withJSONObject: best, options: [])
+print(String(data: data, encoding: .utf8)!)
+`;
+const AX_SEND_SCRIPT = `
+import Cocoa
+import ApplicationServices
+
+func attr(_ el: AXUIElement, _ name: String) -> AnyObject? {
+    var value: CFTypeRef?
+    guard AXUIElementCopyAttributeValue(el, name as CFString, &value) == .success else { return nil }
+    return value as AnyObject?
+}
+
+func s(_ el: AXUIElement, _ name: String) -> String? {
+    if let v = attr(el, name) as? String { return v }
+    return nil
+}
+
+func isEnabled(_ el: AXUIElement) -> Bool {
+    (attr(el, kAXEnabledAttribute as String) as? Bool) ?? true
+}
+
+func children(_ el: AXUIElement) -> [AXUIElement] {
+    (attr(el, kAXChildrenAttribute as String) as? [AnyObject] ?? []).map { $0 as! AXUIElement }
+}
+
+func collectEditableInputs(_ el: AXUIElement, into out: inout [AXUIElement], depth: Int = 0) {
+    guard depth < 25 else { return }
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    if (role == kAXTextAreaRole as String || role == kAXTextFieldRole as String) && isEnabled(el) {
+        out.append(el)
+    }
+    for c in children(el) { collectEditableInputs(c, into: &out, depth: depth + 1) }
+}
+
+func isInput(_ el: AXUIElement) -> Bool {
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    return role == kAXTextAreaRole as String || role == kAXTextFieldRole as String
+}
+
+func focusedInput(_ axApp: AXUIElement) -> AXUIElement? {
+    guard let focused = attr(axApp, kAXFocusedUIElementAttribute as String) as! AXUIElement? else {
+        return nil
+    }
+    return isInput(focused) && isEnabled(focused) ? focused : nil
+}
+
+func findByDescriptions(_ el: AXUIElement, _ targets: [String], depth: Int = 0) -> AXUIElement? {
+    guard depth < 25 else { return nil }
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    let desc = s(el, kAXDescriptionAttribute as String) ?? ""
+    if role == "AXButton" && targets.contains(desc) && isEnabled(el) { return el }
+    for c in children(el) {
+        if let found = findByDescriptions(c, targets, depth: depth + 1) { return found }
+    }
+    return nil
+}
+
+func press(_ el: AXUIElement) {
+    AXUIElementPerformAction(el, kAXPressAction as CFString)
+}
+
+let args = CommandLine.arguments
+guard args.count > 1 else {
+    fputs("Missing prompt text\\n", stderr)
+    exit(1)
+}
+let text = args[1]
+
+guard let app = NSRunningApplication.runningApplications(withBundleIdentifier: "com.openai.chat").first else {
+    fputs("ChatGPT not running\\n", stderr)
+    exit(1)
+}
+
+let axApp = AXUIElementCreateApplication(app.processIdentifier)
+guard let win = attr(axApp, kAXFocusedWindowAttribute as String) as! AXUIElement? else {
+    fputs("No focused ChatGPT window\\n", stderr)
+    exit(1)
+}
+
+var inputs: [AXUIElement] = []
+collectEditableInputs(win, into: &inputs)
+guard let input = focusedInput(axApp) ?? inputs.last else {
+    fputs("Could not find editable input area\\n", stderr)
+    exit(1)
+}
+
+guard AXUIElementSetAttributeValue(input, kAXValueAttribute as CFString, text as CFTypeRef) == .success else {
+    fputs("Failed to set input value\\n", stderr)
+    exit(1)
+}
+
+Thread.sleep(forTimeInterval: 0.2)
+
+guard s(input, kAXValueAttribute as String) == text else {
+    fputs("Failed to verify input value after AX set\\n", stderr)
+    exit(1)
+}
+
+guard let sendButton = findByDescriptions(win, ["发送", "傳送", "Send"]) else {
+    fputs("Could not find send button\\n", stderr)
+    exit(1)
+}
+
+press(sendButton)
+
+var submitted = false
+for _ in 0..<15 {
+    Thread.sleep(forTimeInterval: 0.1)
+    if s(input, kAXValueAttribute as String) != text {
+        submitted = true
+        break
+    }
+}
+
+guard submitted else {
+    fputs("Prompt did not leave input after pressing send\\n", stderr)
+    exit(1)
+}
+
+print("Sent")
+`;
+const AX_MODEL_SCRIPT = `
+import Cocoa
+import ApplicationServices
+
+func attr(_ el: AXUIElement, _ name: String) -> AnyObject? {
+    var value: CFTypeRef?
+    guard AXUIElementCopyAttributeValue(el, name as CFString, &value) == .success else { return nil }
+    return value as AnyObject?
+}
+
+func s(_ el: AXUIElement, _ name: String) -> String? {
+    if let v = attr(el, name) as? String, !v.isEmpty { return v }
+    return nil
+}
+
+func children(_ el: AXUIElement) -> [AXUIElement] {
+    (attr(el, kAXChildrenAttribute as String) as? [AnyObject] ?? []).map { $0 as! AXUIElement }
+}
+
+func press(_ el: AXUIElement) {
+    AXUIElementPerformAction(el, kAXPressAction as CFString)
+}
+
+func findByDesc(_ el: AXUIElement, _ target: String, prefix: Bool = false, depth: Int = 0) -> AXUIElement? {
+    guard depth < 20 else { return nil }
+    let desc = s(el, kAXDescriptionAttribute as String) ?? ""
+    if prefix ? desc.hasPrefix(target) : (desc == target) { return el }
+    for c in children(el) {
+        if let found = findByDesc(c, target, prefix: prefix, depth: depth + 1) { return found }
+    }
+    return nil
+}
+
+func findPopover(_ el: AXUIElement, depth: Int = 0) -> AXUIElement? {
+    guard depth < 20 else { return nil }
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    if role == "AXPopover" { return el }
+    for c in children(el) {
+        if let found = findPopover(c, depth: depth + 1) { return found }
+    }
+    return nil
+}
+
+func pressEscape() {
+    let src = CGEventSource(stateID: .combinedSessionState)
+    if let esc = CGEvent(keyboardEventSource: src, virtualKey: 0x35, keyDown: true) { esc.post(tap: .cghidEventTap) }
+    if let esc = CGEvent(keyboardEventSource: src, virtualKey: 0x35, keyDown: false) { esc.post(tap: .cghidEventTap) }
+}
+
+guard let app = NSRunningApplication.runningApplications(withBundleIdentifier: "com.openai.chat").first else {
+    fputs("ChatGPT not running\\n", stderr); exit(1)
+}
+let axApp = AXUIElementCreateApplication(app.processIdentifier)
+guard let win = attr(axApp, kAXFocusedWindowAttribute as String) as! AXUIElement? else {
+    fputs("No focused ChatGPT window\\n", stderr); exit(1)
+}
+
+let args = CommandLine.arguments
+let target = args.count > 1 ? args[1] : ""
+let needsLegacy = args.count > 2 && args[2] == "legacy"
+
+// Step 1: Click the "Options" button to open the popover (support English, Simplified and Traditional Chinese UI)
+var optionsBtn: AXUIElement? = nil
+if let btn = findByDesc(win, "Options") { optionsBtn = btn }
+else if let btn = findByDesc(win, "选项") { optionsBtn = btn }
+else if let btn = findByDesc(win, "選項") { optionsBtn = btn }
+guard let options = optionsBtn else {
+    fputs("Could not find Options button\\n", stderr); exit(1)
+}
+press(options)
+Thread.sleep(forTimeInterval: 0.8)
+
+// Step 2: Find the popover that appeared, search ONLY within it
+guard let popover = findPopover(win) else {
+    pressEscape()
+    fputs("Popover did not appear\\n", stderr); exit(1)
+}
+
+// Step 3: If legacy, click "Legacy models" to expand submenu
+if needsLegacy {
+    guard let legacyBtn = findByDesc(popover, "Legacy models") else {
+        pressEscape()
+        fputs("Could not find Legacy models button\\n", stderr); exit(1)
+    }
+    press(legacyBtn)
+    Thread.sleep(forTimeInterval: 0.8)
+}
+
+// Step 4: Click the target model button within the popover (prefix match)
+guard let modelBtn = findByDesc(popover, target, prefix: true) else {
+    pressEscape()
+    fputs("Could not find button starting with '\\(target)' in popover\\n", stderr); exit(1)
+}
+press(modelBtn)
+print("Selected: \\(target)")
+`;
+const AX_GENERATING_SCRIPT = `
+import Cocoa
+import ApplicationServices
+
+func attr(_ el: AXUIElement, _ name: String) -> AnyObject? {
+    var value: CFTypeRef?
+    guard AXUIElementCopyAttributeValue(el, name as CFString, &value) == .success else { return nil }
+    return value as AnyObject?
+}
+
+func s(_ el: AXUIElement, _ name: String) -> String? {
+    if let v = attr(el, name) as? String, !v.isEmpty { return v }
+    return nil
+}
+
+func children(_ el: AXUIElement) -> [AXUIElement] {
+    (attr(el, kAXChildrenAttribute as String) as? [AnyObject] ?? []).map { $0 as! AXUIElement }
+}
+
+func hasButton(_ el: AXUIElement, desc target: String, depth: Int = 0) -> Bool {
+    guard depth < 15 else { return false }
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    let desc = s(el, kAXDescriptionAttribute as String) ?? ""
+    if role == "AXButton" && desc == target { return true }
+    for c in children(el) {
+        if hasButton(c, desc: target, depth: depth + 1) { return true }
+    }
+    return false
+}
+
+guard let app = NSRunningApplication.runningApplications(withBundleIdentifier: "com.openai.chat").first else {
+    print("false"); exit(0)
+}
+let axApp = AXUIElementCreateApplication(app.processIdentifier)
+guard let win = attr(axApp, kAXFocusedWindowAttribute as String) as! AXUIElement? else {
+    print("false"); exit(0)
+}
+let targets = ["Stop generating", "停止生成"]
+print(targets.contains(where: { hasButton(win, desc: $0) }) ? "true" : "false")
+`;
+const MODEL_MAP = {
+    'auto': { desc: 'Auto' },
+    'instant': { desc: 'Instant' },
+    'thinking': { desc: 'Thinking' },
+    '5.2-instant': { desc: 'GPT-5.2 Instant', legacy: true },
+    '5.2-thinking': { desc: 'GPT-5.2 Thinking', legacy: true },
+};
+export const MODEL_CHOICES = Object.keys(MODEL_MAP);
+export function activateChatGPT(delaySeconds = 0.5) {
+    execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
+    execSync(`osascript -e 'delay ${delaySeconds}'`);
+}
+export function selectModel(model) {
+    const entry = MODEL_MAP[model];
+    if (!entry) {
+        throw new Error(`Unknown model "${model}". Choose from: ${MODEL_CHOICES.join(', ')}`);
+    }
+    const swiftArgs = ['-', entry.desc];
+    if (entry.legacy)
+        swiftArgs.push('legacy');
+    const output = execFileSync('swift', swiftArgs, {
+        input: AX_MODEL_SCRIPT,
+        encoding: 'utf-8',
+        maxBuffer: 10 * 1024 * 1024,
+    }).trim();
+    return output;
+}
+export function sendPrompt(text) {
+    return execFileSync('swift', ['-', text], {
+        input: AX_SEND_SCRIPT,
+        encoding: 'utf-8',
+        maxBuffer: 10 * 1024 * 1024,
+    }).trim();
+}
+export function isGenerating() {
+    try {
+        const output = execFileSync('swift', ['-'], {
+            input: AX_GENERATING_SCRIPT,
+            encoding: 'utf-8',
+            maxBuffer: 10 * 1024 * 1024,
+        }).trim();
+        return output === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+export function getVisibleChatMessages() {
+    const output = execFileSync('swift', ['-'], {
+        input: AX_READ_SCRIPT,
+        encoding: 'utf-8',
+        maxBuffer: 10 * 1024 * 1024,
+    }).trim();
+    if (!output)
+        return [];
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed
+        .filter((item) => typeof item === 'string')
+        .map((item) => item.replace(/[\uFFFC\u200B-\u200D\uFEFF]/g, '').trim())
+        .filter((item) => item.length > 0);
+}
+export const __test__ = {
+    AX_SEND_SCRIPT,
+    AX_MODEL_SCRIPT,
+    AX_GENERATING_SCRIPT,
+};

package/clis/chatgpt-app/ax.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './ax.js';
+
+describe('chatgpt-app AX send script', () => {
+    it('prefers the focused composer before falling back to the last editable input', () => {
+        expect(__test__.AX_SEND_SCRIPT).toContain('kAXFocusedUIElementAttribute');
+    });
+
+    it('fails fast when the AX set does not round-trip into the composer value', () => {
+        expect(__test__.AX_SEND_SCRIPT).toContain('Failed to verify input value after AX set');
+    });
+
+    it('does not report success until the prompt leaves the composer after send', () => {
+        expect(__test__.AX_SEND_SCRIPT).toContain('Prompt did not leave input after pressing send');
+    });
+
+    it('supports english, zh-CN, and zh-TW send button labels', () => {
+        expect(__test__.AX_SEND_SCRIPT).toContain('["发送", "傳送", "Send"]');
+    });
+});
+
+describe('chatgpt-app AX model script', () => {
+    it('supports english, zh-CN, and zh-TW options button labels', () => {
+        expect(__test__.AX_MODEL_SCRIPT).toContain('findByDesc(win, "Options")');
+        expect(__test__.AX_MODEL_SCRIPT).toContain('findByDesc(win, "选项")');
+        expect(__test__.AX_MODEL_SCRIPT).toContain('findByDesc(win, "選項")');
+    });
+});
+
+describe('chatgpt-app generating detection', () => {
+    it('supports both english and zh-CN stop-generating labels', () => {
+        expect(__test__.AX_GENERATING_SCRIPT).toContain('Stop generating');
+        expect(__test__.AX_GENERATING_SCRIPT).toContain('停止生成');
+    });
+});

package/clis/chatgpt-app/model.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ConfigError } from '@sovovs/bycli/errors';
+import { activateChatGPT, selectModel, MODEL_CHOICES } from './ax.js';
+export const modelCommand = cli({
+    site: 'chatgpt-app',
+    name: 'model',
+    access: 'read',
+    description: 'Switch ChatGPT Desktop model/mode (auto, instant, thinking, 5.2-instant, 5.2-thinking)',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'model', required: true, positional: true, help: 'Model to switch to', choices: MODEL_CHOICES },
+    ],
+    columns: ['Status', 'Model'],
+    func: async (kwargs) => {
+        if (process.platform !== 'darwin') {
+            throw new ConfigError('ChatGPT Desktop integration requires macOS');
+        }
+        const model = kwargs.model;
+        activateChatGPT();
+        const result = selectModel(model);
+        return [{ Status: 'Success', Model: result }];
+    },
+});

package/clis/chatgpt-app/new.js

@@ -0,0 +1,28 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ConfigError, getErrorMessage } from '@sovovs/bycli/errors';
+export const newCommand = cli({
+    site: 'chatgpt-app',
+    name: 'new',
+    access: 'read',
+    description: 'Open a new chat in ChatGPT Desktop App',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['Status'],
+    func: async () => {
+        if (process.platform !== 'darwin') {
+            throw new ConfigError('ChatGPT Desktop integration requires macOS (osascript is not available on this platform)');
+        }
+        try {
+            execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
+            execSync("osascript -e 'delay 0.5'");
+            execSync("osascript -e 'tell application \"System Events\" to keystroke \"n\" using command down'");
+            return [{ Status: 'Success' }];
+        }
+        catch (err) {
+            return [{ Status: "Error: " + getErrorMessage(err) }];
+        }
+    },
+});

package/clis/chatgpt-app/read.js

@@ -0,0 +1,32 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { CommandExecutionError, ConfigError, getErrorMessage } from '@sovovs/bycli/errors';
+import { getVisibleChatMessages } from './ax.js';
+export const readCommand = cli({
+    site: 'chatgpt-app',
+    name: 'read',
+    access: 'read',
+    description: 'Read the last visible message from the focused ChatGPT Desktop window',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['Role', 'Text'],
+    func: async () => {
+        if (process.platform !== 'darwin') {
+            throw new ConfigError('ChatGPT Desktop integration requires macOS (osascript is not available on this platform)');
+        }
+        try {
+            execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
+            execSync("osascript -e 'delay 0.3'");
+            const messages = getVisibleChatMessages();
+            if (!messages.length) {
+                return [{ Role: 'System', Text: 'No visible chat messages were found in the current ChatGPT window.' }];
+            }
+            return [{ Role: 'Assistant', Text: messages[messages.length - 1] }];
+        }
+        catch (err) {
+            throw new CommandExecutionError("Failed to read from ChatGPT: " + getErrorMessage(err));
+        }
+    },
+});

package/clis/chatgpt-app/send.js

@@ -0,0 +1,34 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { getErrorMessage } from '@sovovs/bycli/errors';
+import { activateChatGPT, selectModel, MODEL_CHOICES, sendPrompt } from './ax.js';
+export const sendCommand = cli({
+    site: 'chatgpt-app',
+    name: 'send',
+    access: 'write',
+    description: 'Send a message to the active ChatGPT Desktop App window',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'text', required: true, positional: true, help: 'Message to send' },
+        { name: 'model', required: false, help: 'Model/mode to use: auto, instant, thinking, 5.2-instant, 5.2-thinking', choices: MODEL_CHOICES },
+    ],
+    columns: ['Status'],
+    func: async (kwargs) => {
+        const text = kwargs.text;
+        const model = kwargs.model;
+        try {
+            // Switch model before sending if requested
+            if (model) {
+                activateChatGPT();
+                selectModel(model);
+            }
+            activateChatGPT();
+            sendPrompt(text);
+            return [{ Status: 'Success' }];
+        }
+        catch (err) {
+            return [{ Status: "Error: " + getErrorMessage(err) }];
+        }
+    },
+});

package/clis/chatgpt-app/status.js

@@ -0,0 +1,26 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { CommandExecutionError, ConfigError } from '@sovovs/bycli/errors';
+export const statusCommand = cli({
+    site: 'chatgpt-app',
+    name: 'status',
+    access: 'read',
+    description: 'Check if ChatGPT Desktop App is running natively on macOS',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['Status'],
+    func: async () => {
+        if (process.platform !== 'darwin') {
+            throw new ConfigError('ChatGPT Desktop integration requires macOS (osascript is not available on this platform)');
+        }
+        try {
+            const output = execSync("osascript -e 'application \"ChatGPT\" is running'", { encoding: 'utf-8' }).trim();
+            return [{ Status: output === 'true' ? 'Running' : 'Stopped' }];
+        }
+        catch {
+            throw new CommandExecutionError('Error querying ChatGPT application state');
+        }
+    },
+});

package/clis/chatwise/ask.js

@@ -0,0 +1,54 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { selectorError, TimeoutError } from '@sovovs/bycli/errors';
+import {
+    buildChatwiseInjectTextJs,
+    buildChatwiseMessageCountJs,
+    buildChatwiseResponseAfterJs,
+    requirePositiveTimeout,
+} from './utils.js';
+export const askCommand = cli({
+    site: 'chatwise',
+    name: 'ask',
+    access: 'write',
+    description: 'Send a prompt and wait for the AI response (send + wait + read)',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'text', required: true, positional: true, help: 'Prompt to send' },
+        { name: 'timeout', type: 'int', required: false, help: 'Max seconds to wait (default: 30)', default: 30 },
+    ],
+    columns: ['Role', 'Text'],
+    func: async (page, kwargs) => {
+        const text = kwargs.text;
+        const timeout = requirePositiveTimeout(kwargs.timeout);
+        // Snapshot content length
+        const beforeLen = await page.evaluate(buildChatwiseMessageCountJs());
+        // Send message
+        const injected = await page.evaluate(buildChatwiseInjectTextJs(text));
+        if (!injected)
+            throw selectorError('ChatWise input element');
+        await page.wait(0.5);
+        await page.pressKey('Enter');
+        // Poll for response
+        const pollInterval = 2;
+        const maxPolls = Math.ceil(timeout / pollInterval);
+        let response = '';
+        for (let i = 0; i < maxPolls; i++) {
+            await page.wait(pollInterval);
+            const result = await page.evaluate(buildChatwiseResponseAfterJs(beforeLen, text));
+            if (result) {
+                const next = String(result).trim();
+                if (next === response) break;
+                response = next;
+            }
+        }
+        if (!response) {
+            throw new TimeoutError('ChatWise response', timeout, 'Confirm ChatWise is done generating, then retry with a larger --timeout if needed.');
+        }
+        return [
+            { Role: 'User', Text: text },
+            { Role: 'Assistant', Text: response },
+        ];
+    },
+});