@loadmill/droid-cua 2.22.0 → 2.24.0

package/README.md

@@ -134,6 +134,27 @@ Install:
 npm install -g @loadmill/droid-cua
 ```
 
+Install the bundled Agent Skill for your coding agent:
+
+```sh
+# Global installation (default)
+droid-cua skill install cursor
+droid-cua skill install claude-code
+droid-cua skill install codex
+
+# Or install in the current project
+droid-cua skill install codex --local
+```
+
+Use `droid-cua skill status <agent>` to inspect an installation and
+`droid-cua skill uninstall <agent>` to remove it. Installed skill
+files are never overwritten or removed after local modification unless `--force`
+is supplied. After upgrading the npm package, update an installed skill explicitly:
+
+```sh
+droid-cua skill install <agent> --force
+```
+
 Examples:
 ```sh
 # Interactive CLI
@@ -230,6 +251,10 @@ Supported CLI options include:
 - `--report`
 - `--debug`
 
+`--cua-model` accepts `loadmill-smart`, `loadmill-beacon`, `gpt-5.6-terra`,
+`gpt-5.6-luna`, and `gpt-5.4`. OpenAI models use direct OpenAI mode and require
+`OPENAI_API_KEY`.
+
 Config and precedence rules:
 - Use `--config <file>` to supply prompt-affecting settings for headless runs.
 - CLI flags override config file values.

package/build/index.js

@@ -15,7 +15,7 @@ import { selectDevice } from "./src/cli/device-selector.js";
 import { resolveExecutionAppContext } from "./src/core/app-context.js";
 import { resolveExecutionTestData } from "./src/core/test-data.js";
 import { getDefaultSecretsPath, resolveExecutionSecrets } from "./src/core/secrets.js";
-import { createRunContext, resolveRuntimeConfigFromEnv, resolveRuntimeCredentialsFromEnv, } from "./src/core/runtime-config.js";
+import { assertRuntimeCredentialsForProvider, createRunContext, resolveRuntimeConfigFromEnv, resolveRuntimeCredentialsFromEnv, } from "./src/core/runtime-config.js";
 import { resolveHeadlessExecutionConfig } from "./src/cli/headless-execution-config.js";
 import { resolveHeadlessTarget } from "./src/cli/headless-target.js";
 import { createHeadlessDebugArtifacts } from "./src/cli/headless-debug.js";
@@ -29,8 +29,20 @@ import { createStatusLine } from "./src/cli/cloud-status-line.js";
 import { createLoadmillApiClient } from "./src/integrations/loadmill/client.js";
 import { getCloudProviderAdapter } from "./src/device/cloud/registry.js";
 import { setCloudProgressListener } from "./src/device/cloud/progress.js";
+import { runSkillCommand } from "./src/cli/skill-command.js";
 dotenv.config();
 const args = minimist(process.argv.slice(2));
+if (args._[0] === "skill") {
+    try {
+        await runSkillCommand({ args });
+        process.exit(0);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`\nSkill command failed: ${message}`);
+        process.exit(1);
+    }
+}
 const targetConfig = resolveHeadlessTarget(args);
 let avdName = targetConfig.avdName;
 let platform = targetConfig.platform || null; // 'ios' or 'android'
@@ -71,6 +83,33 @@ function createCliRuntimeContext(configOverrides = {}) {
         loadmillClient,
     };
 }
+async function assertCliRuntimeCredentials({ llmProviderMode }) {
+    const credentials = resolveRuntimeCredentialsFromEnv(process.env);
+    assertRuntimeCredentialsForProvider({
+        llmProviderMode,
+        credentials,
+    });
+    if (llmProviderMode !== "loadmill") {
+        return;
+    }
+    const loadmillClient = createLoadmillApiClient({
+        token: credentials.loadmillApiToken,
+        baseUrl: credentials.loadmillBaseUrl,
+    });
+    let tokenValidation = null;
+    try {
+        tokenValidation = await loadmillClient.validateApiToken();
+    }
+    catch {
+        throw new Error("Could not validate LOADMILL_API_TOKEN.");
+    }
+    if (tokenValidation?.reason === "invalid") {
+        throw new Error("LOADMILL_API_TOKEN is invalid.");
+    }
+    if (!tokenValidation?.valid) {
+        throw new Error("Could not validate LOADMILL_API_TOKEN.");
+    }
+}
 function createLambdaTestCliBuildName() {
     return `loadmill-droid-cua-cli-${new Date().toISOString().replace(/[:.]/g, "-")}`;
 }
@@ -184,6 +223,9 @@ async function main() {
     let preloadedSecrets = null;
     if (isHeadlessInstructionsRun) {
         preloadedHeadlessConfig = await resolveHeadlessExecutionConfig(args);
+        await assertCliRuntimeCredentials({
+            llmProviderMode: preloadedHeadlessConfig.llmProviderMode,
+        });
         preloadedHeadlessTarget = await resolveHeadlessInstructionsTarget(instructionsFile);
         preloadedSecrets = await resolveExecutionSecrets({
             secretsPath: getDefaultSecretsPath(process.cwd()),

package/build/src/browser/playwright/actions.js

@@ -3,7 +3,8 @@ import { emitDesktopDebug, truncateForDebug } from "../../utils/desktop-debug.js
 import { getConfiguredStepDelayMs } from "../../utils/step-delay.js";
 import { buildActionEventMeta } from "../../device/action-event-meta.js";
 import { actionForErrorLog, buildActionErrorOutput, buildDebugTextField, buildSensitiveDebugFields, buildTypeActionPayload, buildTypeActionText, isSensitiveAction, } from "../../device/sensitive-action.js";
-import { getActiveBrowserPage } from "./session-state.js";
+import { normalizeAutomationUrl } from "./url.js";
+import { getActiveBrowserSession, getActiveBrowserPage } from "./session-state.js";
 const KEY_ALIASES = {
     CTRL: "Control",
     CONTROL: "Control",
@@ -58,8 +59,47 @@ function buildMeta(context, action, payload = {}) {
         payload,
     });
 }
+function handleNavigationTimeout(error, description) {
+    if (!(error instanceof Error) || error.name !== "TimeoutError") {
+        throw error;
+    }
+    console.warn(`Page load did not finish within the timeout for ${description}. Continuing with the current page state.`);
+}
+async function gotoWithTimeoutTolerance(page, url) {
+    try {
+        await page.goto(url, { waitUntil: "load" });
+    }
+    catch (error) {
+        handleNavigationTimeout(error, url);
+    }
+}
+async function goBackWithTimeoutTolerance(page) {
+    try {
+        await page.goBack({ waitUntil: "load" });
+    }
+    catch (error) {
+        handleNavigationTimeout(error, "browser history back");
+    }
+}
+async function goForwardWithTimeoutTolerance(page) {
+    try {
+        await page.goForward({ waitUntil: "load" });
+    }
+    catch (error) {
+        handleNavigationTimeout(error, "browser history forward");
+    }
+}
+function updateSessionUrlFromPage(session, page) {
+    const currentUrl = typeof page.url === "function" ? page.url() : null;
+    if (!currentUrl) {
+        return;
+    }
+    session.pageUrls?.set?.(page, currentUrl);
+    session.url = currentUrl;
+}
 export async function handleModelAction(browserSessionId, action, scale = 1, context = null) {
     const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+    const session = getActiveBrowserSession(browserSessionId);
     const page = getActiveBrowserPage(browserSessionId);
     try {
         emitDesktopDebug("browser.action.execute", "device", {
@@ -166,6 +206,30 @@ export async function handleModelAction(browserSessionId, action, scale = 1, con
                 await page.waitForTimeout(timeoutMs);
                 break;
             }
+            case "goto": {
+                const normalizedUrl = normalizeAutomationUrl(action.url);
+                addOutput({
+                    type: "action",
+                    text: `Navigating to ${normalizedUrl}`,
+                    ...buildMeta(context, action, { url: normalizedUrl }),
+                });
+                await gotoWithTimeoutTolerance(page, normalizedUrl);
+                session.pageUrls?.set?.(page, normalizedUrl);
+                session.url = normalizedUrl;
+                break;
+            }
+            case "back": {
+                addOutput({ type: "action", text: "Going back", ...buildMeta(context, action) });
+                await goBackWithTimeoutTolerance(page);
+                updateSessionUrlFromPage(session, page);
+                break;
+            }
+            case "forward": {
+                addOutput({ type: "action", text: "Going forward", ...buildMeta(context, action) });
+                await goForwardWithTimeoutTolerance(page);
+                updateSessionUrlFromPage(session, page);
+                break;
+            }
             default:
                 addOutput({ type: "info", text: `Unknown action: ${JSON.stringify(action)}` });
         }

package/build/src/cli/skill-command.js

@@ -0,0 +1,240 @@
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { cp, lstat, mkdir, readdir, readFile, rm } from "node:fs/promises";
+const SKILL_NAME = "droid-cua";
+const AGENTS = Object.freeze({
+    cursor: { displayName: "Cursor", relativePath: path.join(".cursor", "skills", SKILL_NAME) },
+    "claude-code": { displayName: "Claude Code", relativePath: path.join(".claude", "skills", SKILL_NAME) },
+    codex: { displayName: "Codex", relativePath: path.join(".agents", "skills", SKILL_NAME) },
+});
+const SUBCOMMANDS = new Set(["install", "status", "uninstall"]);
+const ALLOWED_OPTIONS = new Set(["_", "local", "force", "h", "help"]);
+const COMMAND_DESCRIPTIONS = Object.freeze({
+    install: "Install Droid CUA skill for a coding agent",
+    status: "Show Droid CUA skill status for a coding agent",
+    uninstall: "Uninstall Droid CUA skill for a coding agent",
+});
+function skillCommandHelp(subcommand) {
+    const localDescriptions = {
+        install: "Install in current project instead of global",
+        status: "Check current project instead of global",
+        uninstall: "Uninstall from current project instead of global",
+    };
+    const options = [
+        `  --local      ${localDescriptions[subcommand]}`,
+    ];
+    if (subcommand !== "status") {
+        options.push("  --force      Overwrite or remove modified skill files");
+    }
+    options.push("  -h, --help  display help for command");
+    return [
+        `Usage: droid-cua skill ${subcommand} [options] [agent]`,
+        "",
+        COMMAND_DESCRIPTIONS[subcommand],
+        "",
+        "Agents:",
+        "  cursor",
+        "  claude-code",
+        "  codex",
+        "",
+        "Example:",
+        `  droid-cua skill ${subcommand} claude-code`,
+        "",
+        "Options:",
+        ...options,
+    ].join("\n");
+}
+function skillRootHelp() {
+    return [
+        "Usage: droid-cua skill <command> [options] [agent]",
+        "",
+        "Manage the bundled Droid CUA skill",
+        "",
+        "Commands:",
+        "  install    Install the skill",
+        "  status     Show installation status",
+        "  uninstall  Uninstall the skill",
+    ].join("\n");
+}
+async function pathType(targetPath) {
+    try {
+        const stats = await lstat(targetPath);
+        if (stats.isDirectory())
+            return "directory";
+        if (stats.isFile())
+            return "file";
+        if (stats.isSymbolicLink())
+            return "symlink";
+        return "other";
+    }
+    catch (error) {
+        if (error?.code === "ENOENT")
+            return "missing";
+        throw error;
+    }
+}
+async function snapshotDirectory(rootPath, relativePath = "") {
+    const absolutePath = relativePath ? path.join(rootPath, relativePath) : rootPath;
+    const entries = await readdir(absolutePath, { withFileTypes: true });
+    const snapshot = [];
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        const childRelativePath = relativePath ? path.join(relativePath, entry.name) : entry.name;
+        if (entry.isDirectory()) {
+            snapshot.push({ path: `${childRelativePath}/`, type: "directory" });
+            snapshot.push(...await snapshotDirectory(rootPath, childRelativePath));
+        }
+        else if (entry.isFile()) {
+            const contents = await readFile(path.join(rootPath, childRelativePath));
+            snapshot.push({ path: childRelativePath, type: "file", contents: contents.toString("base64") });
+        }
+        else {
+            snapshot.push({ path: childRelativePath, type: entry.isSymbolicLink() ? "symlink" : "other" });
+        }
+    }
+    return snapshot;
+}
+async function directoryMatches(sourcePath, destinationPath) {
+    if (await pathType(destinationPath) !== "directory")
+        return false;
+    const [sourceSnapshot, destinationSnapshot] = await Promise.all([
+        snapshotDirectory(sourcePath),
+        snapshotDirectory(destinationPath),
+    ]);
+    return JSON.stringify(sourceSnapshot) === JSON.stringify(destinationSnapshot);
+}
+async function getInstallationState(sourcePath, destinationPath) {
+    if (await pathType(destinationPath) === "missing")
+        return "not-installed";
+    return await directoryMatches(sourcePath, destinationPath) ? "installed" : "modified";
+}
+function normalizeStringOption(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${label} requires a value.`);
+    }
+    return value.trim().toLowerCase();
+}
+function parseSkillCommandArgs(args) {
+    const unknownOption = Object.keys(args).find((key) => !ALLOWED_OPTIONS.has(key));
+    if (unknownOption)
+        throw new Error(`Unknown skill option --${unknownOption}.`);
+    if (!Array.isArray(args._) || args._[0] !== "skill") {
+        throw new Error("Usage: droid-cua skill <command> [options] [agent]");
+    }
+    if (args._.length === 1) {
+        return { help: skillRootHelp() };
+    }
+    const subcommand = normalizeStringOption(args._[1], "Skill subcommand");
+    if (!SUBCOMMANDS.has(subcommand)) {
+        throw new Error(`Unknown skill subcommand "${subcommand}". Expected install, status, or uninstall.`);
+    }
+    for (const option of ["local", "force", "h", "help"]) {
+        if (args[option] != null && typeof args[option] !== "boolean") {
+            throw new Error(`--${option === "h" ? "help" : option} does not accept a value.`);
+        }
+    }
+    if (args.help === true || args.h === true || args._.length === 2) {
+        return { help: skillCommandHelp(subcommand) };
+    }
+    if (args._.length !== 3)
+        throw new Error(skillCommandHelp(subcommand));
+    if (subcommand === "status" && args.force != null) {
+        throw new Error("--force is only supported by install and uninstall.");
+    }
+    const agent = normalizeStringOption(args._[2], "Agent");
+    if (!Object.hasOwn(AGENTS, agent)) {
+        throw new Error(`Unknown agent "${agent}". Expected cursor, claude-code, or codex.`);
+    }
+    return {
+        subcommand,
+        agent,
+        local: args.local === true,
+        force: args.force === true,
+    };
+}
+export function resolveSkillDestination({ agent, local = false, cwd = process.cwd(), home = os.homedir() }) {
+    const basePath = local ? cwd : home;
+    return {
+        agent,
+        ...AGENTS[agent],
+        path: path.join(basePath, AGENTS[agent].relativePath),
+    };
+}
+export async function resolveBundledSkillPath({ startDir = path.dirname(fileURLToPath(import.meta.url)) } = {}) {
+    let currentPath = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(currentPath, "skill", SKILL_NAME);
+        if (await pathType(path.join(candidate, "SKILL.md")) === "file")
+            return candidate;
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath)
+            break;
+        currentPath = parentPath;
+    }
+    throw new Error("Bundled Droid CUA skill was not found. Reinstall @loadmill/droid-cua and try again.");
+}
+function stateLabel(state) {
+    if (state === "not-installed")
+        return "not installed";
+    return state;
+}
+function shouldUseColor() {
+    return Boolean(process.stdout.isTTY) && !Object.hasOwn(process.env, "NO_COLOR");
+}
+function formatInstallSuccess(destination, { alreadyInstalled, color }) {
+    const checkmark = color ? "\u001b[32m✓\u001b[39m" : "✓";
+    const skillFilePath = path.join(destination.path, "SKILL.md");
+    const displayedPath = color ? `\u001b[2m${skillFilePath}\u001b[22m` : skillFilePath;
+    const message = alreadyInstalled
+        ? `${destination.agent} skill already installed`
+        : `Installed ${destination.agent} skill`;
+    return `${checkmark} ${message}\n${displayedPath}`;
+}
+export async function runSkillCommand({ args, cwd = process.cwd(), home = os.homedir(), sourcePath = null, output = console, color = shouldUseColor(), } = {}) {
+    const command = parseSkillCommandArgs(args ?? {});
+    if (command.help) {
+        output.log(command.help);
+        return [];
+    }
+    const bundledSkillPath = sourcePath ?? await resolveBundledSkillPath();
+    if (await pathType(path.join(bundledSkillPath, "SKILL.md")) !== "file") {
+        throw new Error(`Invalid bundled skill at ${bundledSkillPath}: SKILL.md is missing.`);
+    }
+    const destination = resolveSkillDestination({ agent: command.agent, local: command.local, cwd, home });
+    const states = [{
+            ...destination,
+            state: await getInstallationState(bundledSkillPath, destination.path),
+        }];
+    if (command.subcommand !== "status" && !command.force) {
+        const conflicts = states.filter(({ state }) => state === "modified");
+        if (conflicts.length > 0) {
+            const paths = conflicts.map(({ path: destinationPath }) => destinationPath).join(", ");
+            throw new Error(`Refusing to ${command.subcommand} modified skill files at ${paths}. Re-run with --force to replace them.`);
+        }
+    }
+    for (const destination of states) {
+        if (command.subcommand === "status") {
+            output.log(`${destination.displayName}: ${stateLabel(destination.state)} at ${destination.path}`);
+        }
+        else if (command.subcommand === "install") {
+            if (destination.state === "installed") {
+                output.log(formatInstallSuccess(destination, { alreadyInstalled: true, color }));
+            }
+            else {
+                if (destination.state !== "not-installed")
+                    await rm(destination.path, { recursive: true, force: true });
+                await mkdir(path.dirname(destination.path), { recursive: true });
+                await cp(bundledSkillPath, destination.path, { recursive: true });
+                output.log(formatInstallSuccess(destination, { alreadyInstalled: false, color }));
+            }
+        }
+        else if (destination.state === "not-installed") {
+            output.log(`${destination.displayName}: not installed at ${destination.path}`);
+        }
+        else {
+            await rm(destination.path, { recursive: true, force: true });
+            output.log(`${destination.displayName}: uninstalled from ${destination.path}`);
+        }
+    }
+    return states.map(({ agent, path: destinationPath, state }) => ({ agent, path: destinationPath, state }));
+}

package/build/src/commands/help.js

@@ -1,6 +1,7 @@
 /**
  * Help command handler
  */
+import { CUA_MODELS } from '../core/cua-models.js';
 /**
  * Handle /help command
  * @param {string} args - Command arguments
@@ -32,7 +33,7 @@ export async function handleHelp(args, session, context) {
     addOutput({ type: 'info', text: '  --session-mode <mode>  Browser session mode for web runs: persistent or fresh' });
     addOutput({ type: 'info', text: '  --config <file>        Headless execution JSON config for prompt parity' });
     addOutput({ type: 'info', text: '  --llm-provider <mode>  Headless AI provider: loadmill or openai' });
-    addOutput({ type: 'info', text: '  --cua-model <model>    Headless CUA model override: gpt-5.4, loadmill-smart, or gpt-5.4-mini' });
+    addOutput({ type: 'info', text: `  --cua-model <model>    Headless CUA model override: ${CUA_MODELS.join(', ')}` });
     addOutput({ type: 'info', text: '  --aim-assist <mode>    Headless Aim Assist mode: off, smart, or always' });
     addOutput({ type: 'info', text: '  --context <file>       Optional app context file injected into execution runs' });
     addOutput({ type: 'info', text: '  --no-context           Disable app context for headless execution' });

package/build/src/core/cua-models.js

@@ -1,32 +1,50 @@
 export const DEFAULT_OPENAI_CUA_MODEL = "gpt-5.4";
 export const DEFAULT_LOADMILL_CUA_MODEL = "loadmill-smart";
 export const DEFAULT_CUA_MODEL = DEFAULT_LOADMILL_CUA_MODEL;
-export const OPENAI_CUA_MODELS = ["gpt-5.4", "gpt-5.4-mini"];
-export const LOADMILL_CUA_MODELS = [DEFAULT_LOADMILL_CUA_MODEL];
-export const CUA_MODELS = ["gpt-5.4", "loadmill-smart", "gpt-5.4-mini"];
 export const CUA_MODEL_OPTIONS = Object.freeze([
     Object.freeze({
         id: "loadmill-smart",
         providerMode: "loadmill",
         providerLabel: "Loadmill",
-        name: "Loadmill Smart",
-        label: "Loadmill Smart (recommended)",
+        name: "Loadmill - Smart",
+        label: "Loadmill - Smart (recommended)",
     }),
     Object.freeze({
-        id: "gpt-5.4",
+        id: "loadmill-beacon",
+        providerMode: "loadmill",
+        providerLabel: "Loadmill",
+        name: "Loadmill - Beacon",
+        label: "Loadmill - Beacon",
+    }),
+    Object.freeze({
+        id: "gpt-5.6-terra",
         providerMode: "openai",
         providerLabel: "OpenAI",
-        name: "GPT-5.4",
-        label: "OpenAI GPT-5.4",
+        name: "GPT-5.6 Terra",
+        label: "OpenAI GPT-5.6 Terra",
     }),
     Object.freeze({
-        id: "gpt-5.4-mini",
+        id: "gpt-5.6-luna",
         providerMode: "openai",
         providerLabel: "OpenAI",
-        name: "GPT-5.4 mini",
-        label: "OpenAI GPT-5.4 mini (faster)",
+        name: "GPT-5.6 Luna",
+        label: "OpenAI GPT-5.6 Luna",
+    }),
+    Object.freeze({
+        id: "gpt-5.4",
+        providerMode: "openai",
+        providerLabel: "OpenAI",
+        name: "GPT-5.4",
+        label: "OpenAI GPT-5.4",
     }),
 ]);
+export const CUA_MODELS = Object.freeze(CUA_MODEL_OPTIONS.map((option) => option.id));
+export const OPENAI_CUA_MODELS = Object.freeze(CUA_MODEL_OPTIONS
+    .filter((option) => option.providerMode === "openai")
+    .map((option) => option.id));
+export const LOADMILL_CUA_MODELS = Object.freeze(CUA_MODEL_OPTIONS
+    .filter((option) => option.providerMode === "loadmill")
+    .map((option) => option.id));
 const VALID_CUA_MODELS = new Set(CUA_MODELS);
 const OPENAI_CUA_MODEL_SET = new Set(OPENAI_CUA_MODELS);
 const LOADMILL_CUA_MODEL_SET = new Set(LOADMILL_CUA_MODELS);

package/build/src/core/droid-cua-run-usage.js

@@ -2,16 +2,22 @@ const TOKENS_PER_MILLION = 1_000_000;
 const OPENAI_GPT_5_4_PRICING = Object.freeze({
     inputPerMillionUsd: 2.5,
 });
-const OPENAI_GPT_5_4_MINI_PRICING = Object.freeze({
-    inputPerMillionUsd: 0.75,
+const OPENAI_GPT_5_6_TERRA_PRICING = Object.freeze({
+    inputPerMillionUsd: 2.5,
+});
+const OPENAI_GPT_5_6_LUNA_PRICING = Object.freeze({
+    inputPerMillionUsd: 1,
 });
 const MODEL_PRICING = Object.freeze({
+    "gpt-5.6-terra": Object.freeze({
+        ...OPENAI_GPT_5_6_TERRA_PRICING,
+    }),
+    "gpt-5.6-luna": Object.freeze({
+        ...OPENAI_GPT_5_6_LUNA_PRICING,
+    }),
     "gpt-5.4": Object.freeze({
         ...OPENAI_GPT_5_4_PRICING,
     }),
-    "gpt-5.4-mini": Object.freeze({
-        ...OPENAI_GPT_5_4_MINI_PRICING,
-    }),
     // Loadmill Smart currently routes to GPT-5.4 behind the Loadmill LLM gateway.
     // Keep this explicit so pricing can be updated here if the backing model changes.
     "loadmill-smart": Object.freeze({
@@ -32,8 +38,11 @@ export function normalizeDroidCuaCostModel(model) {
     if (typeof model !== "string") {
         return null;
     }
-    if (model === "gpt-5.4-mini" || model.startsWith("gpt-5.4-mini-")) {
-        return "gpt-5.4-mini";
+    if (model === "gpt-5.6-terra" || model.startsWith("gpt-5.6-terra-")) {
+        return "gpt-5.6-terra";
+    }
+    if (model === "gpt-5.6-luna" || model.startsWith("gpt-5.6-luna-")) {
+        return "gpt-5.6-luna";
     }
     if (model === "gpt-5.4" || model.startsWith("gpt-5.4-")) {
         return "gpt-5.4";