@desplega.ai/agent-swarm 1.152.1 → 1.153.0

package/src/commands/provider-credentials.ts

@@ -22,6 +22,7 @@ import { checkClaudeCredentials } from "../providers/claude-adapter";
 import { checkClaudeManagedCredentials } from "../providers/claude-managed-adapter";
 import { checkCodexCredentials } from "../providers/codex-adapter";
 import { checkDevinCredentials } from "../providers/devin-adapter";
+import { checkDshCredentials } from "../providers/dsh-adapter";
 import { checkOpencodeCredentials } from "../providers/opencode-adapter";
 import type { CredCheckOptions, CredStatus } from "../providers/types";
 import type {
@@ -41,7 +42,8 @@ export type SupportedProvider =
   | "devin"
   | "opencode"
   | "pi"
-  | "acp";
+  | "acp"
+  | "dsh";
 
 /**
  * True when the pi harness authenticates against Bedrock rather than a provider
@@ -105,6 +107,7 @@ export const REQUIRED_CRED_VARS_BY_PROVIDER: Record<SupportedProvider, readonly
   pi: ["ANTHROPIC_API_KEY", "OPENROUTER_API_KEY", "OPENAI_API_KEY"],
   // The ACP target process owns its own auth, so the swarm requires nothing.
   acp: [],
+  dsh: ["DEEPSEEK_API_KEY", "OPENROUTER_API_KEY"],
 };
 
 type CredentialChecker = (
@@ -114,6 +117,7 @@ type CredentialChecker = (
 
 /** The handlers used by the credential-readiness dispatcher. */
 export const CREDENTIAL_PROVIDER_CHECKERS: Record<SupportedProvider, CredentialChecker> = {
+  dsh: (env) => checkDshCredentials(env),
   claude: (env) => checkClaudeCredentials(env),
   "claude-managed": (env) => checkClaudeManagedCredentials(env),
   codex: (env, opts) => checkCodexCredentials(env, opts),
@@ -416,12 +420,20 @@ export async function validateProviderCredentials(provider: string): Promise<Liv
           latency_ms: r.latency_ms,
         };
       }
+      case "dsh":
+        return checkDshCredentials(env).ready
+          ? presenceCheckOk()
+          : {
+              ok: false,
+              error: "Set DEEPSEEK_API_KEY or OPENROUTER_API_KEY for dsh.",
+              latency_ms: Date.now() - startedAt,
+            };
       case "acp":
         return presenceCheckOk();
       default:
         return {
           ok: false,
-          error: `Unknown provider "${provider}". Supported: claude, claude-managed, codex, devin, opencode, pi, acp.`,
+          error: `Unknown provider "${provider}". Supported: claude, claude-managed, codex, devin, opencode, pi, acp, dsh.`,
           latency_ms: Date.now() - startedAt,
         };
     }

package/src/extensions/lifecycle.ts

@@ -1,7 +1,6 @@
 import {
   activateExtensionVersionSnapshot,
   getExtensionById,
-  getExtensionFiles,
   getExtensionVersion,
   insertExtensionRun,
   listExtensions,
@@ -66,28 +65,23 @@ function maxUpdatedAt(extensions: Extension[]): string {
 }
 
 async function loadableExtension(record: Extension): Promise<LoadableExtension> {
-  if (record.activeVersion !== record.version) {
-    const version = await getExtensionVersion(record.id, record.activeVersion);
-    if (!version) {
-      throw new ExtensionLifecycleError(
-        `Extension version ${record.activeVersion} was not found`,
-        404,
-      );
-    }
-    return {
-      record: {
-        ...record,
-        manifestJson: version.manifestJson,
-        contentHash: version.contentHash,
-      },
-      manifest: ExtensionManifestSchema.parse(JSON.parse(version.manifestJson)),
-      files: JSON.parse(version.filesJson) as Record<string, string>,
-    };
+  // Always load the immutable selected version. The mutable current-file projection
+  // can advance while an agent stages a draft after we read the extension row.
+  const version = await getExtensionVersion(record.id, record.activeVersion);
+  if (!version) {
+    throw new ExtensionLifecycleError(
+      `Extension version ${record.activeVersion} was not found`,
+      404,
+    );
   }
   return {
-    record,
-    manifest: ExtensionManifestSchema.parse(JSON.parse(record.manifestJson)),
-    files: await getExtensionFiles(record.id),
+    record: {
+      ...record,
+      manifestJson: version.manifestJson,
+      contentHash: version.contentHash,
+    },
+    manifest: ExtensionManifestSchema.parse(JSON.parse(version.manifestJson)),
+    files: JSON.parse(version.filesJson) as Record<string, string>,
   };
 }
 

package/src/http/agents.ts

@@ -181,7 +181,7 @@ const setAgentHarnessProviderRoute = route({
   },
 });
 
-const LocalHarnessProviderSchema = z.enum(["claude", "codex", "pi", "opencode", "acp"]);
+const LocalHarnessProviderSchema = z.enum(["claude", "codex", "pi", "opencode", "acp", "dsh"]);
 const AcpRuntimeConfigSchema = z
   .object({
     target: z.enum(ACP_TARGET_IDS),
@@ -1046,7 +1046,7 @@ export async function handleAgentsRest(
               })
             )[0]?.value ?? "");
       const allowedLevels =
-        harness_provider === "acp"
+        harness_provider === "acp" || harness_provider === "dsh"
           ? []
           : reasoningCapability(harness_provider, modelForValidation ?? "").levels;
       if (!allowedLevels.includes(reasoning_effort)) {

package/src/http/config.ts

@@ -37,7 +37,7 @@ const SECRETS_FORCE_MASK_NOTE =
 // bootstrap admin key would let a compromised worker administer the shared org.
 // The API materializes these into its own process.env at boot via
 // getInjectableGlobalConfigs, so no HTTP consumer legitimately needs them.
-const API_ONLY_CONFIG_KEYS = new Set(["API_AGENT_FS_API_KEY"]);
+const API_ONLY_CONFIG_KEYS = new Set(["API_AGENT_FS_API_KEY", "SLACK_SIGNING_SECRET"]);
 
 function stripApiOnlyKeys<T extends { key: string }>(configs: T[]): T[] {
   return configs.filter((config) => !API_ONLY_CONFIG_KEYS.has(config.key));

package/src/http/core.ts

@@ -150,6 +150,10 @@ async function reloadGlobalConfigsAndIntegrationsInner(): Promise<ReloadConfigRe
 
   const updated = await loadGlobalConfigsIntoEnv(true);
 
+  // Retire the old transport before any other integration can fail during
+  // reload. HTTP/invalid selection must never leave the previous socket live.
+  await stopSlackApp();
+
   // File-storage provider selection reads process.env once and memoizes; the
   // env we just (re)hydrated may flip it (local-fs → agent-fs after late
   // provisioning, or a rotated bootstrap key). Reset so the next fs request
@@ -206,9 +210,7 @@ async function reloadGlobalConfigsAndIntegrationsInner(): Promise<ReloadConfigRe
   resetJira();
   if (await initJira()) integrations.push("jira");
 
-  await stopSlackApp();
-  await startSlackApp();
-  integrations.push("slack");
+  if (await startSlackApp()) integrations.push("slack");
 
   return {
     configsLoaded: updated.length,

package/src/http/extensions.ts

@@ -4,9 +4,11 @@ import { resolveHttpAuditUserId } from "../be/audit-user";
 import { getAgentById } from "../be/db";
 import {
   deleteExtension,
+  ExtensionOwnershipError,
   getExtensionById,
   getExtensionByName,
   getExtensionFiles,
+  type InstallExtensionResult,
   installExtension,
   listExtensionRuns,
   listExtensions,
@@ -23,8 +25,15 @@ import {
   reloadExtension,
 } from "../extensions/lifecycle";
 import { ExtensionConfigError } from "../extensions/loader";
-import { can, type PermissionVerb, type RbacPrincipal } from "../rbac";
 import {
+  can,
+  LEGACY_RULES,
+  type PermissionVerb,
+  type RbacPrincipal,
+  type RbacResource,
+} from "../rbac";
+import {
+  type Extension,
   ExtensionInstallBodySchema,
   ExtensionManifestSchema,
   ExtensionRunSchema,
@@ -44,6 +53,8 @@ const installRoute = route({
   pattern: ["api", "extensions", "install"],
   operationId: "extensions_install",
   summary: "Validate and install an extension bundle",
+  description:
+    "Any authenticated agent can install a disabled draft owned by its agent ID. Workers can update only their own bundles; activation remains lead/operator-only.",
   tags: ["Extensions"],
   body: ExtensionInstallBodySchema,
   responses: {
@@ -153,6 +164,8 @@ const patchRoute = route({
   pattern: ["api", "extensions", null],
   operationId: "extensions_update",
   summary: "Update extension priority, config, or description",
+  description:
+    "Workers may edit their own disabled extensions. Leads, operators, and dashboard users retain access to all extensions.",
   tags: ["Extensions"],
   params: idParamsSchema,
   body: z
@@ -177,6 +190,8 @@ const deleteRoute = route({
   pattern: ["api", "extensions", null],
   operationId: "extensions_delete",
   summary: "Uninstall a disabled extension",
+  description:
+    "Workers may uninstall their own disabled extensions. Leads, operators, and dashboard users retain access to all extensions.",
   tags: ["Extensions"],
   params: idParamsSchema,
   responses: {
@@ -316,14 +331,23 @@ async function extensionPrincipal(
   return { kind: "agent", agentId: "", isLead: false };
 }
 
+/** Restrict ordinary agents; retain the existing blanket access for elevated writers. */
+function ownerOnlyAgentId(principal: RbacPrincipal): string | undefined {
+  return principal.kind === "agent" &&
+    !LEGACY_RULES["lead-or-operator-or-user"].evaluate(principal, undefined)
+    ? principal.agentId
+    : undefined;
+}
+
 async function requirePermission(
   req: IncomingMessage,
   res: ServerResponse,
   callerAgentId: string | undefined,
   verb: Extract<PermissionVerb, "extension.write" | "extension.activate">,
+  resource: RbacResource = { kind: "none" },
 ): Promise<RbacPrincipal | null> {
   const principal = await extensionPrincipal(req, callerAgentId);
-  const decision = can({ principal, verb, resource: { kind: "none" }, source: "http" });
+  const decision = can({ principal, verb, resource, source: "http" });
   if (decision.allow) return principal;
   jsonError(res, `Forbidden: ${decision.reason}`, 403);
   return null;
@@ -331,11 +355,13 @@ async function requirePermission(
 
 function respondLifecycleError(res: ServerResponse, error: unknown): void {
   const status =
-    error instanceof ExtensionConfigError
-      ? 400
-      : error instanceof ExtensionLifecycleError
-        ? error.status
-        : 500;
+    error instanceof ExtensionOwnershipError
+      ? 403
+      : error instanceof ExtensionConfigError
+        ? 400
+        : error instanceof ExtensionLifecycleError
+          ? error.status
+          : 500;
   jsonError(res, scrubSecrets(error instanceof Error ? error.message : String(error)), status);
 }
 
@@ -349,26 +375,41 @@ export async function handleExtensions(
   if (installRoute.match(req.method, pathSegments)) {
     const parsed = await installRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    const principal = await requirePermission(req, res, agentId, "extension.write");
+    const existing = await getExtensionByName(parsed.body.manifest.name);
+    const principal = await requirePermission(req, res, agentId, "extension.write", {
+      kind: "extension",
+      extensionId: existing?.id,
+      createdByAgentId: existing?.createdByAgentId,
+    });
     if (!principal) return true;
     const validation = await validateBundle(parsed.body);
     if (!validation.ok) {
       json(res, { error: "extension_validation_failed", diagnostics: validation.diagnostics }, 400);
       return true;
     }
-    const existing = await getExtensionByName(validation.manifest.name);
     const writerAgentId = principal.kind === "agent" ? principal.agentId : undefined;
     const updatedBy = await resolveHttpAuditUserId(req, writerAgentId);
     const shouldActivate = principal.kind !== "agent" && existing?.enabled === true;
-    const result = await installExtension({
-      manifest: validation.manifest,
-      files: parsed.body.files,
-      priority: parsed.body.priority,
-      config: parsed.body.config,
-      agentId: writerAgentId,
-      createdBy: updatedBy,
-      activate: shouldActivate,
-    });
+    // Enforce ownership again inside the upsert transaction: validation can yield
+    // while another agent installs the same name.
+    const ownerOnly = ownerOnlyAgentId(principal);
+    let result: InstallExtensionResult;
+    try {
+      result = await installExtension({
+        manifest: validation.manifest,
+        files: parsed.body.files,
+        priority: parsed.body.priority,
+        config: parsed.body.config,
+        agentId: writerAgentId,
+        createdBy: updatedBy,
+        activate: shouldActivate,
+        ownerOnly,
+      });
+    } catch (error) {
+      if (!(error instanceof ExtensionOwnershipError)) throw error;
+      jsonError(res, error.message, 403);
+      return true;
+    }
     let extension = result.extension;
     if (shouldActivate) {
       try {
@@ -446,19 +487,42 @@ export async function handleExtensions(
   if (patchRoute.match(req.method, pathSegments)) {
     const parsed = await patchRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    const principal = await requirePermission(req, res, agentId, "extension.write");
+    const stored = await getExtensionById(parsed.params.id);
+    if (!stored) {
+      jsonError(res, "Extension not found", 404);
+      return true;
+    }
+    const principal = await requirePermission(req, res, agentId, "extension.write", {
+      kind: "extension",
+      extensionId: stored.id,
+      createdByAgentId: stored.createdByAgentId,
+    });
     if (!principal) return true;
     const writerAgentId = principal.kind === "agent" ? principal.agentId : undefined;
-    const stored = parsed.body.config ? await getExtensionById(parsed.params.id) : null;
-    const config =
-      parsed.body.config && stored
-        ? preserveRedactedConfigValues(parsed.body.config, stored.configJson)
-        : parsed.body.config;
-    let extension = await updateExtensionMeta(parsed.params.id, {
-      ...parsed.body,
-      ...(config === undefined ? {} : { config }),
-      updatedBy: await resolveHttpAuditUserId(req, writerAgentId),
-    });
+    const ownerOnly = ownerOnlyAgentId(principal);
+    // PATCH reloads live code; ordinary owners may edit only disabled drafts.
+    if (
+      stored.enabled &&
+      ownerOnly &&
+      !(await requirePermission(req, res, agentId, "extension.activate"))
+    ) {
+      return true;
+    }
+    const config = parsed.body.config
+      ? preserveRedactedConfigValues(parsed.body.config, stored.configJson)
+      : parsed.body.config;
+    let extension: Extension | null;
+    try {
+      extension = await updateExtensionMeta(parsed.params.id, {
+        ...parsed.body,
+        ...(config === undefined ? {} : { config }),
+        updatedBy: await resolveHttpAuditUserId(req, writerAgentId),
+        ownerOnly,
+      });
+    } catch (error) {
+      respondLifecycleError(res, error);
+      return true;
+    }
     if (!extension) {
       jsonError(res, "Extension not found", 404);
       return true;
@@ -478,18 +542,28 @@ export async function handleExtensions(
   if (deleteRoute.match(req.method, pathSegments)) {
     const parsed = await deleteRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    const principal = await requirePermission(req, res, agentId, "extension.write");
-    if (!principal) return true;
-    const extension = await getExtensionById(parsed.params.id);
-    if (!extension) {
+    const stored = await getExtensionById(parsed.params.id);
+    if (!stored) {
       jsonError(res, "Extension not found", 404);
       return true;
     }
+    const principal = await requirePermission(req, res, agentId, "extension.write", {
+      kind: "extension",
+      extensionId: stored.id,
+      createdByAgentId: stored.createdByAgentId,
+    });
+    if (!principal) return true;
+    const extension = stored;
     if (extension.enabled) {
       jsonError(res, "Disable the extension before uninstalling it", 409);
       return true;
     }
-    await deleteExtension(extension.id);
+    try {
+      await deleteExtension(extension.id, ownerOnlyAgentId(principal));
+    } catch (error) {
+      respondLifecycleError(res, error);
+      return true;
+    }
     deleteRoute.respond(res, 200, { deleted: true });
     return true;
   }

package/src/http/status.ts

@@ -34,6 +34,7 @@ import {
 } from "../be/db";
 import { getEmbeddingProvider } from "../be/memory";
 import { getFileStorageProvider } from "../fs/registry";
+import { getSlackConfiguration } from "../slack/config";
 import { type AgentCredStatus, AutomationIntegrationIdSchema, ProviderNameSchema } from "../types";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
@@ -407,26 +408,37 @@ function embeddingsMilestone(): SetupMilestone {
 }
 
 function slackMilestone(state: AutomationSetupStates["slack"]): SetupMilestone {
-  const disable = process.env.SLACK_DISABLE;
-  const disabled = disable === "true" || disable === "1";
+  const config = getSlackConfiguration();
 
   if (state === "unverified") {
+    let hint: string;
+    if (config.disabled) {
+      hint = "Slack is explicitly disabled (SLACK_DISABLE=true).";
+    } else if (!config.mode) {
+      hint = "Invalid SLACK_MODE. Use socket or http.";
+    } else if (config.mode === "http" && config.missingCredentials.length === 0) {
+      hint =
+        "HTTP credentials are configured, but HTTP ingress is unavailable until the receiver is installed.";
+    } else {
+      hint = `Set ${config.missingCredentials.join(" + ")} for Slack ${config.mode} mode.`;
+    }
     return {
       id: "slack",
-      label: "Slack connected",
+      label: "Slack configured",
       state: "unverified",
-      hint: disabled
-        ? "Slack is explicitly disabled (SLACK_DISABLE=true)."
-        : "Set SLACK_BOT_TOKEN + SLACK_APP_TOKEN to connect Slack.",
+      hint,
       action_url: automationIntegrationFixUrl("slack"),
     };
   }
-  // Socket Mode connection state isn't surfaced today — Phase 2+ enhancement.
-  // For now treat env-present as `verified` so the UX matches the brainstorm.
+
   return {
     id: "slack",
-    label: "Slack connected",
-    state: "verified",
+    label: "Slack configured",
+    state: "configured",
+    hint:
+      config.mode === "http"
+        ? "HTTP credentials are configured, but HTTP ingress is unavailable until the receiver is installed."
+        : "Socket Mode credentials are configured; a live connection has not been verified.",
     action_url: automationIntegrationFixUrl("slack"),
   };
 }

package/src/prompts/base-prompt.ts

@@ -16,6 +16,7 @@
  */
 
 import type { ProviderTraits } from "../providers/types";
+import { getSlackConfiguration } from "../slack/config";
 import type { ProviderName } from "../types";
 import { isSteeringEnabled } from "../utils/steering-enabled";
 import { matchesDefaultClaudeMd, matchesDefaultIdentityMd } from "./defaults";
@@ -54,11 +55,18 @@ const CLAUDE_MD_INJECT_PROVIDERS: ReadonlySet<string> = new Set(["codex", "openc
 /** Providers that get the repo CLAUDE.md inlined until native loading is verified. */
 const REPO_CLAUDE_MD_INLINE_PROVIDERS: ReadonlySet<string> = new Set(["opencode"]);
 
-export function areSlackPromptToolsEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
-  const slackDisable = env.SLACK_DISABLE;
-  if (slackDisable === "true" || slackDisable === "1") return false;
-
-  return Boolean(env.SLACK_BOT_TOKEN && env.SLACK_APP_TOKEN);
+export function areSlackPromptToolsEnabled(
+  env: NodeJS.ProcessEnv = process.env,
+  serverCapabilities?: string[],
+): boolean {
+  const config = getSlackConfiguration(env);
+  if (config.disabled || !config.mode) return false;
+
+  // Preserve the socket credential gate. For the HTTP contract, workers use
+  // the server tool capability without needing the API-owned signing secret.
+  if (serverCapabilities && !serverCapabilities.includes("slack")) return false;
+  if (config.mode === "http" && serverCapabilities) return true;
+  return config.missingCredentials.length === 0;
 }
 
 export type BasePromptArgs = {
@@ -185,8 +193,8 @@ export const getBasePrompt = async (args: BasePromptArgs): Promise<string> => {
 
   // H. Slack. One block for both roles; the scripts-only variant covers Slack
   // via ctx.swarm.slack_* for Slack-originated tasks.
-  const slackPromptToolsEnabled = areSlackPromptToolsEnabled();
-  if (hasMcp && slackPromptToolsEnabled && !scriptsOnlyMode && serverHasCapability("slack", true)) {
+  const slackPromptToolsEnabled = areSlackPromptToolsEnabled(process.env, args.serverCapabilities);
+  if (hasMcp && slackPromptToolsEnabled && !scriptsOnlyMode) {
     const slackResult = await resolveTemplateAsync("system.agent.slack", {});
     prompt += slackResult.text;
   }

package/src/providers/claude-managed-models.ts

@@ -27,6 +27,7 @@
 export const CLAUDE_MANAGED_MODELS = [
   "claude-fable-5-1",
   "claude-mythos-5-1",
+  "claude-opus-5-5",
   "claude-opus-5",
   "claude-fable-5",
   "claude-mythos-5",
@@ -69,6 +70,7 @@ export interface ClaudeManagedModelPricing extends ClaudeManagedTokenPricing {
  * - claude-mythos-5-1: $10 / $50 / $0.25 / $12.50  (invite only, verified 2026-09-02)
  * - claude-fable-5:   $10 / $50 / $1.00 / $12.50   (verified 2026-06-10)
  * - claude-mythos-5:  $10 / $50 / $1.00 / $12.50   (limited availability, verified 2026-06-10)
+ * - claude-opus-5-5:  $4 / $20 / $0.20 / $5.00     (verified 2026-09-22)
  * - claude-opus-5:    $5 / $25 / $0.50 / $6.25     (verified 2026-07-25)
  * - claude-sonnet-5:  $2 / $10 / $0.20 / $2.50     (standard rate, verified 2026-08-29)
  * - claude-sonnet-4-6: $3 / $15 / $0.30 / $3.75    (in / out / cache-read / cache-write)
@@ -90,6 +92,12 @@ export const CLAUDE_MANAGED_MODEL_PRICING: Record<ClaudeManagedModel, ClaudeMana
     cacheReadPerMillion: 0.25,
     cacheWritePerMillion: 12.5,
   },
+  "claude-opus-5-5": {
+    inputPerMillion: 4.0,
+    outputPerMillion: 20.0,
+    cacheReadPerMillion: 0.2,
+    cacheWritePerMillion: 5.0,
+  },
   "claude-opus-5": {
     inputPerMillion: 5.0,
     outputPerMillion: 25.0,

package/src/providers/codex-models.ts

@@ -1,6 +1,6 @@
 /**
  * Codex API-addressable models, verified from https://developers.openai.com/api/docs/models
- * and https://developers.openai.com/api/docs/deprecations as of 2026-09-05.
+ * and https://developers.openai.com/api/docs/deprecations as of 2026-09-23.
  *
  * NOTE: `gpt-5.3-codex-spark` is intentionally excluded. It is a ChatGPT Pro
  * research preview and is NOT API-addressable via the Codex SDK at launch.
@@ -20,6 +20,8 @@ import modelsDevCache from "../be/modelsdev-cache.json";
  */
 export const CODEX_MODELS = [
   "gpt-6-astra", // most capable model for complex reasoning, coding, and agentic work
+  "gpt-6-sol", // complex coding and agentic workflows
+  "gpt-6-luna", // focused, high-volume tasks
   "gpt-5.6-sol", // frontier GPT-5.6 tier for complex reasoning/coding
   "gpt-5.6-terra", // balanced GPT-5.6 tier
   "gpt-5.6-luna", // fast/cheap GPT-5.6 tier for high-volume workloads
@@ -83,6 +85,8 @@ const MODELSDEV_OPENAI_MODELS =
 
 const FALLBACK_CODEX_MODEL_CONTEXT_WINDOWS: Record<CodexModel, number> = {
   "gpt-6-astra": 1_050_000,
+  "gpt-6-sol": 1_050_000,
+  "gpt-6-luna": 1_050_000,
   "gpt-5.6-sol": 1_050_000,
   "gpt-5.6-terra": 1_050_000,
   "gpt-5.6-luna": 1_050_000,
@@ -153,6 +157,16 @@ export const FALLBACK_CODEX_MODEL_PRICING: Record<CodexModel, CodexModelPricing>
     cachedInputPerMillion: 1.0,
     outputPerMillion: 50.0,
   },
+  "gpt-6-sol": {
+    inputPerMillion: 2.0,
+    cachedInputPerMillion: 0.2,
+    outputPerMillion: 10.0,
+  },
+  "gpt-6-luna": {
+    inputPerMillion: 0.1,
+    cachedInputPerMillion: 0.01,
+    outputPerMillion: 0.5,
+  },
   "gpt-5.6-sol": {
     inputPerMillion: 4.0,
     cachedInputPerMillion: 0.4,