mastracode 0.22.3 → 0.23.0

package/dist/{chunk-FDDVVRPH.js → chunk-RDIIIT54.js}

@@ -1,25 +1,24 @@
-import { setAuthStorage, setAuthStorage3, setAuthStorage2, loadSettings, MEMORY_GATEWAY_PROVIDER, getDynamicModel, getAvailableModePacks, getAvailableOmPacks, resolveModelDefaults, resolveOmRoleModel, releaseThreadLock, acquireThreadLock, getCustomProviderId, toCustomProviderModelId, getCopilotModelCatalog, saveSettings, resolveModel, mastra, OBSERVABILITY_AUTH_PREFIX } from './chunk-W7Y7QIJA.js';
-import { DEFAULT_OM_MODEL_ID, DEFAULT_CONFIG_DIR, AuthStorage, validateConfigDirName, detectProject, getResourceIdOverride, getStorageConfig, getObservabilityDatabasePath, getVectorDatabasePath, getCurrentGitBranchAsync, getOmScope, DEFAULT_REF_THRESHOLD, DEFAULT_OBS_THRESHOLD, getDatabasePath, getAppDataDir } from './chunk-5FT2NNFO.js';
-import { MC_TOOLS, getToolCategory, TOOL_NAME_OVERRIDES } from './chunk-UOFNLVKF.js';
-import { createHash } from 'crypto';
-import * as os from 'os';
-import os__default, { hostname, homedir } from 'os';
+import { loadSettings, MEMORY_GATEWAY_PROVIDER, getAvailableModePacks, getAvailableOmPacks, resolveModelDefaults, resolveOmRoleModel, releaseThreadLock, acquireThreadLock, saveSettings, OBSERVABILITY_AUTH_PREFIX, mastra, getCustomProviderId } from './chunk-FXYM4OEI.js';
+import { AuthStorage, DEFAULT_OM_MODEL_ID, DEFAULT_CONFIG_DIR, validateConfigDirName, detectProject, getResourceIdOverride, getStorageConfig, getObservabilityDatabasePath, getVectorDatabasePath, getCurrentGitBranchAsync, getOmScope, DEFAULT_REF_THRESHOLD, DEFAULT_OBS_THRESHOLD, getGitHubCopilotBaseUrl, fetchCopilotModels, getDatabasePath, COPILOT_HEADERS, getAppDataDir } from './chunk-5FT2NNFO.js';
+import { getToolCategory, MC_TOOLS, TOOL_NAME_OVERRIDES } from './chunk-UOFNLVKF.js';
 import * as path from 'path';
 import path__default, { normalize, join, dirname } from 'path';
 import { Agent } from '@mastra/core/agent';
 import { Harness } from '@mastra/core/harness';
-import { GatewayRegistry, PROVIDER_REGISTRY } from '@mastra/core/llm';
+import { PROVIDER_REGISTRY, MastraModelGateway, MastraGateway, ModelRouterLanguageModel, GATEWAY_AUTH_HEADER, GatewayRegistry } from '@mastra/core/llm';
 import { StreamErrorRetryProcessor, PrefillErrorHandler, ProviderHistoryCompat, AgentsMDInjector } from '@mastra/core/processors';
 import { RequestContext } from '@mastra/core/request-context';
 import { TaskSignalProvider } from '@mastra/core/signals';
 import { InMemoryHarness, MastraCompositeStore } from '@mastra/core/storage';
+import { createTool, DEFAULT_GOAL_JUDGE_PROMPT } from '@mastra/core/tools';
 import { DuckDBStore } from '@mastra/duckdb';
 import { GithubSignals } from '@mastra/github-signals';
 import { Observability, SensitiveDataFilter, MastraStorageExporter, MastraPlatformExporter } from '@mastra/observability';
 import { spawn, execFile } from 'child_process';
-import { createTool } from '@mastra/core/tools';
 import { createTavilySearchTool, createTavilyExtractTool } from '@mastra/tavily';
 import { estimateTokenCount, sliceByTokens } from 'tokenx';
+import * as os from 'os';
+import os__default, { homedir } from 'os';
 import { LocalFilesystem, Workspace, LocalSandbox } from '@mastra/core/workspace';
 import { z } from 'zod';
 import * as fs from 'fs';
@@ -29,9 +28,13 @@ import { fastembed } from '@mastra/fastembed';
 import { Memory } from '@mastra/memory';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createOpenAI } from '@ai-sdk/openai';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { wrapLanguageModel } from 'ai';
+import { GoogleSchemaCompatLayer, applyCompatLayer } from '@mastra/schema-compat';
 import { createNotificationInboxTool, NotificationsStorage } from '@mastra/core/notifications';
 import { createScorer, filterRun } from '@mastra/core/evals';
 import { MCPClient, MCPOAuthClientProvider } from '@mastra/mcp';
+import { createHash } from 'crypto';
 import { mkdir } from 'fs/promises';
 import { PubSub, UnixSocketPubSub } from '@mastra/core/events';
 import { LibSQLStore, LibSQLVector } from '@mastra/libsql';
@@ -1027,6 +1030,982 @@ async function getDynamicInstructions({ requestContext }) {
   };
   return buildFullPrompt(promptCtx);
 }
+var claudeCodeIdentity = "You are Claude Code, Anthropic's official CLI for Claude.";
+var OAUTH_REQUIRED_BETAS = [
+  "oauth-2025-04-20",
+  "claude-code-20250219",
+  "interleaved-thinking-2025-05-14",
+  "fine-grained-tool-streaming-2025-05-14"
+];
+var authStorageInstance = null;
+function getAuthStorage() {
+  if (!authStorageInstance) {
+    authStorageInstance = new AuthStorage();
+  }
+  return authStorageInstance;
+}
+function setAuthStorage(storage) {
+  authStorageInstance = storage ?? null;
+}
+var claudeCodeMiddleware = {
+  specificationVersion: "v3",
+  transformParams: async ({ params }) => {
+    const systemMessage = {
+      role: "system",
+      content: claudeCodeIdentity
+    };
+    if (params.temperature) {
+      delete params.topP;
+    }
+    return {
+      ...params,
+      prompt: [systemMessage, ...params.prompt]
+    };
+  }
+};
+var promptCacheMiddleware = {
+  specificationVersion: "v3",
+  transformParams: async ({ params }) => {
+    const prompt = [...params.prompt];
+    const cacheControl = { type: "ephemeral", ttl: "5m" };
+    const addCacheToMessage = (msg) => {
+      if (typeof msg.content === "string") {
+        return {
+          ...msg,
+          providerOptions: {
+            ...msg.providerOptions,
+            anthropic: { ...msg.providerOptions?.anthropic, cacheControl }
+          }
+        };
+      }
+      if (Array.isArray(msg.content) && msg.content.length > 0) {
+        const content = [...msg.content];
+        const lastPart = content[content.length - 1];
+        content[content.length - 1] = {
+          ...lastPart,
+          providerOptions: {
+            ...lastPart.providerOptions,
+            anthropic: { ...lastPart.providerOptions?.anthropic, cacheControl }
+          }
+        };
+        return { ...msg, content };
+      }
+      return msg;
+    };
+    let lastSystemIdx = -1;
+    for (let i = prompt.length - 1; i >= 0; i--) {
+      if (prompt[i].role === "system") {
+        lastSystemIdx = i;
+        break;
+      }
+    }
+    if (lastSystemIdx >= 0) {
+      prompt[lastSystemIdx] = addCacheToMessage(prompt[lastSystemIdx]);
+    }
+    const lastIdx = prompt.length - 1;
+    if (lastIdx >= 0 && lastIdx !== lastSystemIdx) {
+      prompt[lastIdx] = addCacheToMessage(prompt[lastIdx]);
+    }
+    return { ...params, prompt };
+  }
+};
+function buildAnthropicOAuthFetch(opts = {}) {
+  return (async (url, init) => {
+    const storage = opts.authStorage ?? getAuthStorage();
+    storage.reload();
+    const storedCred = storage.get("anthropic");
+    if (storedCred?.type === "api_key") {
+      throw new Error("Anthropic API key credential is configured, but OAuth is required.");
+    }
+    const accessToken = await storage.getApiKey("anthropic");
+    if (!accessToken) {
+      throw new Error("Not logged in to Anthropic. Run /login first.");
+    }
+    const headers = new Headers();
+    if (init?.headers) {
+      const source = init.headers instanceof Headers ? init.headers : Array.isArray(init.headers) ? new Headers(init.headers) : new Headers(init.headers);
+      source.forEach((value, key) => {
+        const lower = key.toLowerCase();
+        if (lower !== "authorization" && lower !== "x-api-key") {
+          headers.set(key, value);
+        }
+      });
+    }
+    headers.set("Authorization", `Bearer ${accessToken}`);
+    const requestBetas = (headers.get("anthropic-beta") ?? "").split(",").map((beta) => beta.trim()).filter(Boolean);
+    headers.set("anthropic-beta", Array.from(/* @__PURE__ */ new Set([...OAUTH_REQUIRED_BETAS, ...requestBetas])).join(","));
+    headers.set("anthropic-version", "2023-06-01");
+    try {
+      return await fetch(url, { ...init, headers });
+    } catch (error) {
+      if (error && typeof error === "object") {
+        Object.assign(error, {
+          requestUrl: url instanceof URL ? url.toString() : typeof url === "string" ? url : url.url
+        });
+      }
+      throw error;
+    }
+  });
+}
+function opencodeClaudeMaxProvider(modelId = "claude-sonnet-4-20250514", options) {
+  const headers = options?.headers;
+  if (process.env.NODE_ENV === "test" || process.env.VITEST) {
+    const anthropic2 = createAnthropic({
+      apiKey: "test-api-key",
+      headers
+    });
+    return wrapLanguageModel({
+      model: anthropic2(modelId),
+      middleware: [claudeCodeMiddleware, promptCacheMiddleware]
+    });
+  }
+  const anthropic = createAnthropic({
+    apiKey: "oauth-placeholder",
+    headers,
+    fetch: buildAnthropicOAuthFetch()
+  });
+  return wrapLanguageModel({
+    model: anthropic(modelId),
+    middleware: [claudeCodeMiddleware, promptCacheMiddleware]
+  });
+}
+var COPILOT_PROVIDER_ID = "github-copilot";
+var authStorageInstance2 = null;
+function getAuthStorage2() {
+  if (!authStorageInstance2) {
+    authStorageInstance2 = new AuthStorage();
+  }
+  return authStorageInstance2;
+}
+function setAuthStorage2(storage) {
+  authStorageInstance2 = storage ?? null;
+}
+function detectIsAgent(body) {
+  if (!body || typeof body !== "object") return false;
+  const obj = body;
+  const messages = obj.messages;
+  if (Array.isArray(messages) && messages.length > 0) {
+    const last = messages[messages.length - 1];
+    if (last?.role && last.role !== "user") return true;
+    if (Array.isArray(last?.content)) {
+      const hasToolResult = last.content.some(
+        (part) => part && typeof part === "object" && part.type === "tool_result"
+      );
+      if (hasToolResult) return true;
+    }
+  }
+  const input = obj.input;
+  if (Array.isArray(input) && input.length > 0) {
+    const last = input[input.length - 1];
+    if (last?.role && last.role !== "user") return true;
+  }
+  return false;
+}
+function detectIsVision(body) {
+  if (!body || typeof body !== "object") return false;
+  const obj = body;
+  const matchPart = (part) => {
+    if (!part || typeof part !== "object") return false;
+    const t = part.type;
+    return t === "image" || t === "image_url" || t === "input_image";
+  };
+  const messages = obj.messages;
+  if (Array.isArray(messages)) {
+    return messages.some(
+      (msg) => msg && typeof msg === "object" && Array.isArray(msg.content) && msg.content.some(matchPart)
+    );
+  }
+  const input = obj.input;
+  if (Array.isArray(input)) {
+    return input.some(
+      (item) => item && typeof item === "object" && Array.isArray(item.content) && item.content.some(matchPart)
+    );
+  }
+  return false;
+}
+function buildGitHubCopilotOAuthFetch(opts = {}) {
+  return (async (url, init) => {
+    const storage = opts.authStorage ?? getAuthStorage2();
+    storage.reload();
+    const cred = storage.get(COPILOT_PROVIDER_ID);
+    if (!cred || cred.type !== "oauth") {
+      throw new Error("Not logged in to GitHub Copilot. Run /login first.");
+    }
+    const accessToken = await storage.getApiKey(COPILOT_PROVIDER_ID);
+    if (!accessToken) {
+      throw new Error("Failed to refresh GitHub Copilot token. Please /login again.");
+    }
+    storage.reload();
+    const enterpriseUrl = cred.enterpriseUrl;
+    let parsedBody;
+    if (typeof init?.body === "string") {
+      try {
+        parsedBody = JSON.parse(init.body);
+      } catch {
+        parsedBody = void 0;
+      }
+    }
+    const isAgent = detectIsAgent(parsedBody);
+    const isVision = detectIsVision(parsedBody);
+    const headers = new Headers();
+    if (init?.headers) {
+      const source = init.headers instanceof Headers ? init.headers : Array.isArray(init.headers) ? new Headers(init.headers) : new Headers(init.headers);
+      source.forEach((value, key) => {
+        const lower = key.toLowerCase();
+        if (lower !== "authorization" && lower !== "x-api-key") {
+          headers.set(key, value);
+        }
+      });
+    }
+    headers.set("Authorization", `Bearer ${accessToken}`);
+    headers.set("x-initiator", isAgent ? "agent" : "user");
+    headers.set("Openai-Intent", "conversation-edits");
+    if (isVision) {
+      headers.set("Copilot-Vision-Request", "true");
+    }
+    for (const [key, value] of Object.entries(COPILOT_HEADERS)) {
+      if (!headers.has(key)) {
+        headers.set(key, value);
+      }
+    }
+    const finalUrl = opts.rewriteUrl !== false ? rewriteToCopilotBase(url, accessToken, enterpriseUrl) : url instanceof URL ? url : typeof url === "string" ? new URL(url) : new URL(url.url);
+    try {
+      return await fetch(finalUrl, { ...init, headers });
+    } catch (error) {
+      if (error && typeof error === "object") {
+        Object.assign(error, {
+          requestUrl: finalUrl.toString()
+        });
+      }
+      throw error;
+    }
+  });
+}
+function rewriteToCopilotBase(url, token, enterpriseDomain) {
+  const original = url instanceof URL ? url : new URL(typeof url === "string" ? url : url.url);
+  const base = new URL(getGitHubCopilotBaseUrl(token, enterpriseDomain));
+  const pathname = original.pathname.replace(/^\/v1(\/|$)/, "/");
+  return new URL(`${pathname}${original.search}`, base);
+}
+function isGeminiModel(modelId) {
+  return modelId.startsWith("gemini-");
+}
+function applyGeminiSchemaCompatToTools(modelId, tools) {
+  if (!Array.isArray(tools)) {
+    return tools;
+  }
+  const compatLayer = new GoogleSchemaCompatLayer({
+    provider: COPILOT_PROVIDER_ID,
+    modelId,
+    supportsStructuredOutputs: false
+  });
+  return tools.map((tool) => {
+    if (!tool || typeof tool !== "object" || tool.type !== "function") {
+      return tool;
+    }
+    const functionTool = tool;
+    if (!functionTool.inputSchema) {
+      return tool;
+    }
+    return {
+      ...functionTool,
+      inputSchema: applyCompatLayer({
+        schema: functionTool.inputSchema,
+        compatLayers: [compatLayer],
+        mode: "aiSdkSchema"
+      }).jsonSchema
+    };
+  });
+}
+function createCopilotMiddleware(modelId) {
+  return {
+    specificationVersion: "v3",
+    transformParams: async ({ params }) => {
+      if (params.temperature !== void 0 && params.temperature !== null) {
+        delete params.topP;
+      }
+      if (isGeminiModel(modelId)) {
+        params.tools = applyGeminiSchemaCompatToTools(
+          modelId,
+          params.tools
+        );
+      }
+      return params;
+    }
+  };
+}
+function githubCopilotProvider(modelId = "gpt-4.1", options) {
+  const headers = options?.headers;
+  const copilot = createOpenAICompatible({
+    name: COPILOT_PROVIDER_ID,
+    baseURL: "https://api.githubcopilot.com",
+    apiKey: process.env.NODE_ENV === "test" || process.env.VITEST ? "test-api-key" : "oauth-placeholder",
+    headers,
+    fetch: process.env.NODE_ENV === "test" || process.env.VITEST ? void 0 : buildGitHubCopilotOAuthFetch({ rewriteUrl: false })
+  });
+  return wrapLanguageModel({
+    model: copilot.chatModel(modelId),
+    middleware: [createCopilotMiddleware(modelId)]
+  });
+}
+var COPILOT_FALLBACK_MODELS = [
+  {
+    id: "gpt-4.1",
+    name: "GPT-4.1",
+    vendor: "OpenAI",
+    supportedEndpoints: ["/chat/completions"],
+    isAnthropicShaped: false,
+    supportsVision: true,
+    supportsToolCalls: true
+  }
+];
+var CATALOG_TTL_MS = 10 * 60 * 1e3;
+var CATALOG_FAILURE_TTL_MS = 60 * 1e3;
+var CATALOG_FETCH_TIMEOUT_MS = 5e3;
+var catalogCache = null;
+var inflightFetch = null;
+async function getCopilotModelCatalog(opts = {}) {
+  const storage = opts.authStorage ?? getAuthStorage2();
+  storage.reload();
+  const cred = storage.get(COPILOT_PROVIDER_ID);
+  if (!cred || cred.type !== "oauth") {
+    return [];
+  }
+  const now = Date.now();
+  if (catalogCache && now - catalogCache.fetchedAt < catalogCache.ttl) {
+    return catalogCache.models;
+  }
+  if (inflightFetch) return inflightFetch;
+  inflightFetch = (async () => {
+    try {
+      const accessToken = await storage.getApiKey(COPILOT_PROVIDER_ID);
+      if (!accessToken) throw new Error("No Copilot bearer token");
+      storage.reload();
+      const refreshed = storage.get(COPILOT_PROVIDER_ID);
+      const enterpriseUrl = refreshed?.enterpriseUrl;
+      const baseUrl = getGitHubCopilotBaseUrl(accessToken, enterpriseUrl);
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), CATALOG_FETCH_TIMEOUT_MS);
+      try {
+        const models = await fetchCopilotModels({
+          baseUrl,
+          bearerToken: accessToken,
+          signal: controller.signal
+        });
+        catalogCache = { fetchedAt: Date.now(), ttl: CATALOG_TTL_MS, models };
+        return models;
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch (error) {
+      catalogCache = {
+        fetchedAt: Date.now(),
+        ttl: CATALOG_FAILURE_TTL_MS,
+        models: COPILOT_FALLBACK_MODELS
+      };
+      console.warn(
+        "Failed to fetch live GitHub Copilot models, using fallback list:",
+        error instanceof Error ? error.message : error
+      );
+      return COPILOT_FALLBACK_MODELS;
+    } finally {
+      inflightFetch = null;
+    }
+  })();
+  return inflightFetch;
+}
+var CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+var CODEX_ORIGINATOR = "mastracode";
+var CODEX_USER_AGENT = "mastracode";
+var authStorageInstance3 = null;
+function getAuthStorage3() {
+  if (!authStorageInstance3) {
+    authStorageInstance3 = new AuthStorage();
+  }
+  return authStorageInstance3;
+}
+function setAuthStorage3(storage) {
+  authStorageInstance3 = storage ?? null;
+}
+var CODEX_INSTRUCTIONS = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+IMPORTANT: You should be concise, direct, and helpful. Focus on solving the user's problem efficiently.`;
+var GPT5_MODEL_RE = /^gpt-5(?:\.|-|$)/;
+function getEffectiveThinkingLevel(modelId, level) {
+  if (GPT5_MODEL_RE.test(modelId) && level === "off") {
+    return "low";
+  }
+  return level;
+}
+var THINKING_LEVEL_TO_REASONING_EFFORT = {
+  off: void 0,
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "xhigh"
+};
+function createCodexMiddleware(reasoningEffort) {
+  return {
+    specificationVersion: "v3",
+    transformParams: async ({ params }) => {
+      if (params.temperature !== void 0 && params.temperature !== null) {
+        delete params.topP;
+      }
+      params.providerOptions = {
+        ...params.providerOptions,
+        openai: {
+          ...params.providerOptions?.openai ?? {},
+          instructions: CODEX_INSTRUCTIONS,
+          // Codex API requires store to be false
+          store: false,
+          // Enable reasoning for Codex models — without this, the model
+          // skips the reasoning/action phase and goes straight to final_answer,
+          // resulting in narration instead of tool calls.
+          ...reasoningEffort ? { reasoningEffort } : {}
+        }
+      };
+      return params;
+    }
+  };
+}
+function buildOpenAICodexOAuthFetch(opts = {}) {
+  return (async (url, init) => {
+    const storage = opts.authStorage ?? getAuthStorage3();
+    storage.reload();
+    const cred = storage.get("openai-codex");
+    if (!cred || cred.type !== "oauth") {
+      throw new Error("Not logged in to OpenAI Codex. Run /login first.");
+    }
+    let accessToken = cred.access;
+    if (Date.now() >= cred.expires) {
+      const refreshedToken = await storage.getApiKey("openai-codex");
+      if (!refreshedToken) {
+        throw new Error("Failed to refresh OpenAI Codex token. Please /login again.");
+      }
+      accessToken = refreshedToken;
+      storage.reload();
+    }
+    const accountId = cred.accountId;
+    const headers = new Headers();
+    if (init?.headers) {
+      if (init.headers instanceof Headers) {
+        init.headers.forEach((value, key) => {
+          if (key.toLowerCase() !== "authorization") {
+            headers.set(key, value);
+          }
+        });
+      } else if (Array.isArray(init.headers)) {
+        for (const [key, value] of init.headers) {
+          if (key.toLowerCase() !== "authorization" && value !== void 0) {
+            headers.set(key, String(value));
+          }
+        }
+      } else {
+        for (const [key, value] of Object.entries(init.headers)) {
+          if (key.toLowerCase() !== "authorization" && value !== void 0) {
+            headers.set(key, String(value));
+          }
+        }
+      }
+    }
+    headers.set("Authorization", `Bearer ${accessToken}`);
+    if (!headers.has("originator")) {
+      headers.set("originator", CODEX_ORIGINATOR);
+    }
+    if (!headers.has("User-Agent")) {
+      headers.set("User-Agent", CODEX_USER_AGENT);
+    }
+    if (accountId) {
+      headers.set("ChatGPT-Account-ID", accountId);
+    }
+    const parsed = url instanceof URL ? url : new URL(typeof url === "string" ? url : url.url);
+    const shouldRewrite = opts.rewriteUrl !== false && (parsed.pathname.includes("/v1/responses") || parsed.pathname.includes("/chat/completions"));
+    const finalUrl = shouldRewrite ? new URL(CODEX_API_ENDPOINT) : parsed;
+    try {
+      return await fetch(finalUrl, { ...init, headers });
+    } catch (error) {
+      if (error && typeof error === "object") {
+        Object.assign(error, {
+          requestUrl: finalUrl.toString()
+        });
+      }
+      throw error;
+    }
+  });
+}
+function openaiCodexProvider(modelId = "codex-mini-latest", options) {
+  const requestedLevel = options?.thinkingLevel ?? "medium";
+  const effectiveLevel = getEffectiveThinkingLevel(modelId, requestedLevel);
+  const reasoningEffort = THINKING_LEVEL_TO_REASONING_EFFORT[effectiveLevel];
+  const middleware = createCodexMiddleware(reasoningEffort);
+  const headers = options?.headers;
+  const baseURL = process.env.OPENAI_BASE_URL;
+  if (process.env.NODE_ENV === "test" || process.env.VITEST) {
+    const openai2 = createOpenAI({
+      apiKey: "test-api-key",
+      baseURL,
+      headers
+    });
+    return wrapLanguageModel({
+      model: openai2.responses(modelId),
+      middleware: [middleware]
+    });
+  }
+  const openai = createOpenAI({
+    apiKey: "oauth-dummy-key",
+    baseURL,
+    headers,
+    fetch: buildOpenAICodexOAuthFetch()
+  });
+  return wrapLanguageModel({
+    model: openai.responses(modelId),
+    middleware: [middleware]
+  });
+}
+
+// src/agents/mastracode-gateway.ts
+var OPENAI_PREFIX = "openai/";
+var MASTRA_GATEWAY_PREFIX = "mastra/";
+var MASTRACODE_GATEWAY_ID = "mastracode";
+var CODEX_OPENAI_MODEL_REMAPS = {
+  "gpt-5.3": "gpt-5.3-codex",
+  "gpt-5.2": "gpt-5.2-codex",
+  "gpt-5.1": "gpt-5.1-codex",
+  "gpt-5.1-mini": "gpt-5.1-codex-mini",
+  "gpt-5": "gpt-5-codex"
+};
+var authStorage = new AuthStorage();
+function reloadAuthStorage() {
+  authStorage.reload();
+}
+function stripMastraGatewayPrefix(modelId) {
+  return modelId.startsWith(MASTRA_GATEWAY_PREFIX) ? modelId.substring(MASTRA_GATEWAY_PREFIX.length) : modelId;
+}
+function normalizeAnthropicModelId(modelId) {
+  return modelId.replace(/\.(?=\d)/g, "-");
+}
+function remapOpenAIModelForCodexOAuth(modelId) {
+  const normalizedModelId = stripMastraGatewayPrefix(modelId);
+  if (!normalizedModelId.startsWith(OPENAI_PREFIX)) {
+    return modelId;
+  }
+  const openaiModelId = normalizedModelId.substring(OPENAI_PREFIX.length);
+  if (openaiModelId.includes("-codex")) {
+    return modelId;
+  }
+  const codexModelId = CODEX_OPENAI_MODEL_REMAPS[openaiModelId];
+  if (!codexModelId) {
+    return modelId;
+  }
+  const remappedModelId = `${OPENAI_PREFIX}${codexModelId}`;
+  return modelId.startsWith(MASTRA_GATEWAY_PREFIX) ? `${MASTRA_GATEWAY_PREFIX}${remappedModelId}` : remappedModelId;
+}
+function getAnthropicApiKey() {
+  const storedCred = authStorage.get("anthropic");
+  if (storedCred?.type === "api_key" && storedCred.key.trim().length > 0) {
+    return storedCred.key.trim();
+  }
+  const dedicatedKey = authStorage.getStoredApiKey("anthropic")?.trim();
+  if (dedicatedKey) return dedicatedKey;
+  return process.env.ANTHROPIC_API_KEY?.trim() || void 0;
+}
+function getOpenAIApiKey() {
+  const storedCred = authStorage.get("openai-codex");
+  if (storedCred?.type === "api_key" && storedCred.key.trim().length > 0) {
+    return storedCred.key.trim();
+  }
+  const dedicatedKey = authStorage.getStoredApiKey("openai-codex")?.trim();
+  if (dedicatedKey) return dedicatedKey;
+  return process.env.OPENAI_API_KEY?.trim() || void 0;
+}
+function anthropicApiKeyProvider(modelId, apiKey, headers) {
+  const anthropic = createAnthropic({ apiKey, headers });
+  return wrapLanguageModel({
+    model: anthropic(modelId),
+    middleware: [promptCacheMiddleware]
+  });
+}
+function openaiApiKeyProvider(modelId, apiKey, headers) {
+  const openai = createOpenAI({ apiKey, baseURL: process.env.OPENAI_BASE_URL, headers });
+  return wrapLanguageModel({
+    model: openai.responses(modelId),
+    middleware: []
+  });
+}
+function getAuthProviderId(providerId) {
+  return providerId === "openai" ? "openai-codex" : providerId;
+}
+function getProviderAuthKey(providerId) {
+  const authProviderId = getAuthProviderId(providerId);
+  const storedCred = authStorage.get(authProviderId);
+  if (storedCred?.type === "api_key" && storedCred.key.trim().length > 0) {
+    return storedCred.key.trim();
+  }
+  return authStorage.getStoredApiKey(authProviderId)?.trim() || void 0;
+}
+function getGatewayProviderKey(gatewayId, providerId) {
+  if (gatewayId === "models.dev") return providerId;
+  return providerId === gatewayId ? gatewayId : `${gatewayId}/${providerId}`;
+}
+function parseGatewayRouterId(routerId, gateway) {
+  const [firstPart = "", secondPart = "", ...restParts] = routerId.split("/");
+  const gatewayId = gateway.id;
+  if (firstPart === gatewayId && secondPart) {
+    return {
+      gatewayId,
+      providerId: secondPart,
+      modelId: restParts.join("/")
+    };
+  }
+  return {
+    gatewayId,
+    providerId: firstPart,
+    modelId: [secondPart, ...restParts].filter(Boolean).join("/")
+  };
+}
+function hasResolvedAuth(auth) {
+  if (!auth) return false;
+  if (auth.apiKey || auth.bearerToken) return true;
+  return auth.headers ? Object.keys(auth.headers).length > 0 : false;
+}
+async function resolveGatewayProviderAuth(gateway, routerId) {
+  if (!gateway.resolveAuth) return void 0;
+  const parsed = parseGatewayRouterId(routerId, gateway);
+  try {
+    const result = await gateway.resolveAuth({
+      gatewayId: parsed.gatewayId,
+      providerId: parsed.providerId,
+      modelId: parsed.modelId,
+      routerId
+    });
+    return hasResolvedAuth(result) ? result : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function getMastraCodeProviderConfigs(gateway) {
+  const providers = { ...PROVIDER_REGISTRY };
+  try {
+    const gatewayProviders = await gateway.fetchProviders();
+    for (const [providerId, config] of Object.entries(gatewayProviders)) {
+      providers[getGatewayProviderKey(gateway.id, providerId)] = {
+        ...config,
+        gateway: gateway.id
+      };
+    }
+  } catch (error) {
+    console.warn(`Failed to load providers from gateway ${gateway.id}:`, error);
+  }
+  return providers;
+}
+function getApiKeyEnvVar(providerConfig) {
+  const envVars = providerConfig?.apiKeyEnvVar;
+  return Array.isArray(envVars) ? envVars[0] : envVars;
+}
+var MastraCodeGateway = class _MastraCodeGateway extends MastraModelGateway {
+  id = MASTRACODE_GATEWAY_ID;
+  name = "MastraCode Gateway";
+  #mastraGateway;
+  #mastraGatewayBaseUrl;
+  #mastraGatewayApiKey;
+  #routeThroughMastraGateway;
+  #thinkingLevel;
+  #customProviders;
+  #settingsPath;
+  constructor({
+    mastraGatewayBaseUrl,
+    mastraGatewayApiKey,
+    routeThroughMastraGateway,
+    thinkingLevel,
+    customProviders,
+    settingsPath
+  }) {
+    super();
+    this.#mastraGateway = new MastraGateway({ baseUrl: mastraGatewayBaseUrl });
+    this.#mastraGatewayBaseUrl = mastraGatewayBaseUrl;
+    this.#mastraGatewayApiKey = mastraGatewayApiKey;
+    this.#routeThroughMastraGateway = routeThroughMastraGateway;
+    this.#thinkingLevel = thinkingLevel;
+    this.#customProviders = customProviders;
+    this.#settingsPath = settingsPath;
+  }
+  static getMemoryGatewayApiKey() {
+    return authStorage.getStoredApiKey(MEMORY_GATEWAY_PROVIDER) ?? process.env["MASTRA_GATEWAY_API_KEY"];
+  }
+  static resolveProviderAuth(request, memoryGatewayApiKey) {
+    if (request.gatewayId === "mastra" && memoryGatewayApiKey) {
+      return { apiKey: memoryGatewayApiKey, source: "gateway" };
+    }
+    const storedCred = authStorage.get(getAuthProviderId(request.providerId));
+    if (storedCred?.type === "oauth") {
+      return { bearerToken: "oauth", source: "gateway" };
+    }
+    const apiKey = getProviderAuthKey(request.providerId);
+    return apiKey ? { apiKey, source: "gateway" } : void 0;
+  }
+  static createModelCatalogProvider(gateway) {
+    return async () => {
+      const registry = await getMastraCodeProviderConfigs(gateway);
+      const models = [];
+      for (const [provider, providerConfig] of Object.entries(registry)) {
+        const apiKeyEnvVar = getApiKeyEnvVar(providerConfig);
+        const hasEnvKey = apiKeyEnvVar ? Boolean(process.env[apiKeyEnvVar]) : false;
+        const modelNames = providerConfig.models;
+        if (!Array.isArray(modelNames)) continue;
+        const gatewayAuth = modelNames[0] ? await resolveGatewayProviderAuth(gateway, `${provider}/${modelNames[0]}`) : void 0;
+        for (const modelName of modelNames) {
+          const id = `${provider}/${modelName}`;
+          models.push({
+            id,
+            provider,
+            modelName,
+            hasApiKey: hasEnvKey || Boolean(gatewayAuth),
+            apiKeyEnvVar: apiKeyEnvVar || void 0
+          });
+        }
+      }
+      return models;
+    };
+  }
+  createModelCatalogProvider() {
+    return _MastraCodeGateway.createModelCatalogProvider(this);
+  }
+  #getCustomProviders() {
+    return this.#customProviders ?? loadSettings(this.#settingsPath).customProviders;
+  }
+  async fetchProviders() {
+    const providers = {};
+    for (const provider of this.#getCustomProviders()) {
+      const models = provider.models ?? [];
+      if (!models.length) continue;
+      providers[getCustomProviderId(provider.name)] = {
+        name: provider.name,
+        url: provider.url,
+        apiKeyEnvVar: "",
+        apiKeyHeader: "Authorization",
+        gateway: this.id,
+        models
+      };
+    }
+    try {
+      const copilotModels = await getCopilotModelCatalog({ authStorage });
+      providers["github-copilot"] = {
+        name: "GitHub Copilot",
+        apiKeyEnvVar: "",
+        apiKeyHeader: "Authorization",
+        gateway: this.id,
+        models: copilotModels.map((model) => model.id)
+      };
+    } catch (error) {
+      console.warn("Failed to load GitHub Copilot model catalog:", error);
+    }
+    return providers;
+  }
+  buildUrl(modelId) {
+    return this.#routeThroughMastraGateway ? this.#mastraGateway.buildUrl(modelId) : modelId;
+  }
+  async getApiKey(modelId) {
+    const providerId = stripMastraGatewayPrefix(modelId).split("/", 1)[0];
+    if (this.#routeThroughMastraGateway) return this.#mastraGatewayApiKey ?? "";
+    return providerId ? getProviderAuthKey(providerId) ?? "" : "";
+  }
+  resolveAuth(request) {
+    if (this.#routeThroughMastraGateway && this.#mastraGatewayApiKey) {
+      return { apiKey: this.#mastraGatewayApiKey, source: "gateway" };
+    }
+    const customProvider = this.#getCustomProviders().find(
+      (provider) => request.providerId === getCustomProviderId(provider.name)
+    );
+    if (customProvider?.apiKey) {
+      return { apiKey: customProvider.apiKey, source: "gateway" };
+    }
+    return _MastraCodeGateway.resolveProviderAuth(request);
+  }
+  resolveLanguageModel(args) {
+    const customProvider = this.#getCustomProviders().find(
+      (provider) => args.providerId === getCustomProviderId(provider.name)
+    );
+    if (customProvider) {
+      const provider = createOpenAICompatible({
+        name: args.providerId,
+        baseURL: customProvider.url,
+        apiKey: args.apiKey,
+        headers: args.headers
+      });
+      return provider.chatModel(args.modelId);
+    }
+    if (args.providerId === "github-copilot") {
+      return githubCopilotProvider(args.modelId, { headers: args.headers });
+    }
+    if (args.providerId === "moonshotai") {
+      if (!process.env.MOONSHOT_AI_API_KEY) {
+        throw new Error(`Need MOONSHOT_AI_API_KEY`);
+      }
+      return createAnthropic({
+        apiKey: process.env.MOONSHOT_AI_API_KEY,
+        baseURL: "https://api.moonshot.ai/anthropic/v1",
+        name: "moonshotai.anthropicv1",
+        headers: args.headers
+      })(args.modelId);
+    }
+    if (args.providerId === "anthropic") {
+      return this.#resolveAnthropicModel(args);
+    }
+    if (args.providerId === "openai") {
+      const openaiModel = this.#resolveOpenAIModel(args);
+      if (openaiModel) return openaiModel;
+    }
+    if (this.#routeThroughMastraGateway) {
+      return this.#mastraGateway.resolveLanguageModel(args);
+    }
+    return new ModelRouterLanguageModel({
+      id: `${args.providerId}/${args.modelId}`,
+      headers: args.headers
+    });
+  }
+  #resolveAnthropicModel(args) {
+    const bareModelId = normalizeAnthropicModelId(args.modelId);
+    const storedCred = authStorage.get("anthropic");
+    if (this.#routeThroughMastraGateway) {
+      if (storedCred?.type === "oauth") {
+        const anthropic = createAnthropic({
+          apiKey: "oauth-gateway-placeholder",
+          baseURL: `${this.#mastraGatewayBaseUrl}/v1`,
+          headers: {
+            [GATEWAY_AUTH_HEADER]: `Bearer ${args.apiKey}`,
+            ...args.headers
+          },
+          fetch: buildAnthropicOAuthFetch({ authStorage })
+        });
+        return wrapLanguageModel({
+          model: anthropic(bareModelId),
+          middleware: [claudeCodeMiddleware, promptCacheMiddleware]
+        });
+      }
+      return this.#mastraGateway.resolveLanguageModel({ ...args, modelId: bareModelId });
+    }
+    if (storedCred?.type === "oauth") {
+      return opencodeClaudeMaxProvider(bareModelId, { headers: args.headers });
+    }
+    if (storedCred?.type === "api_key" && storedCred.key.trim().length > 0) {
+      return anthropicApiKeyProvider(
+        bareModelId,
+        storedCred.key.trim(),
+        args.headers
+      );
+    }
+    const apiKey = getAnthropicApiKey();
+    if (apiKey) {
+      return anthropicApiKeyProvider(bareModelId, apiKey, args.headers);
+    }
+    return opencodeClaudeMaxProvider(bareModelId, { headers: args.headers });
+  }
+  #resolveOpenAIModel(args) {
+    const storedCred = authStorage.get("openai-codex");
+    if (this.#routeThroughMastraGateway) {
+      if (storedCred?.type === "oauth") {
+        const resolvedModelId = remapOpenAIModelForCodexOAuth(`openai/${args.modelId}`);
+        const resolvedBareModelId = resolvedModelId.substring(OPENAI_PREFIX.length);
+        const requestedLevel = this.#thinkingLevel ?? "medium";
+        const effectiveLevel = getEffectiveThinkingLevel(resolvedBareModelId, requestedLevel);
+        const reasoningEffort = THINKING_LEVEL_TO_REASONING_EFFORT[effectiveLevel];
+        const middleware = createCodexMiddleware(reasoningEffort);
+        const openai = createOpenAI({
+          apiKey: "oauth-gateway-placeholder",
+          baseURL: `${this.#mastraGatewayBaseUrl}/v1`,
+          headers: {
+            [GATEWAY_AUTH_HEADER]: `Bearer ${args.apiKey}`,
+            ...args.headers
+          },
+          fetch: buildOpenAICodexOAuthFetch({ authStorage, rewriteUrl: false })
+        });
+        return wrapLanguageModel({
+          model: openai.responses(resolvedBareModelId),
+          middleware: [middleware]
+        });
+      }
+      return this.#mastraGateway.resolveLanguageModel(args);
+    }
+    if (storedCred?.type === "oauth") {
+      const resolvedModelId = remapOpenAIModelForCodexOAuth(`openai/${args.modelId}`);
+      return openaiCodexProvider(resolvedModelId.substring(OPENAI_PREFIX.length), {
+        thinkingLevel: this.#thinkingLevel,
+        headers: args.headers
+      });
+    }
+    const apiKey = getOpenAIApiKey();
+    if (apiKey) {
+      return openaiApiKeyProvider(args.modelId, apiKey, args.headers);
+    }
+    return void 0;
+  }
+};
+
+// src/agents/model.ts
+function getHarnessHeaders(requestContext) {
+  const harnessContext = requestContext?.get("harness");
+  const headers = {
+    ...harnessContext?.threadId ? { "x-thread-id": harnessContext.threadId } : {},
+    ...harnessContext?.resourceId ? { "x-resource-id": harnessContext.resourceId } : {}
+  };
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+function createMastraCodeGateway(options) {
+  return new MastraCodeGateway(options);
+}
+function createMastraCodeModelCatalogProvider(gateway) {
+  return gateway instanceof MastraCodeGateway ? gateway.createModelCatalogProvider() : MastraCodeGateway.createModelCatalogProvider(gateway);
+}
+function resolveModel(modelId, options) {
+  reloadAuthStorage();
+  const headers = getHarnessHeaders(options?.requestContext);
+  const settings = loadSettings();
+  const isMastraGatewayModel = modelId.startsWith(MASTRA_GATEWAY_PREFIX);
+  const normalizedModelId = stripMastraGatewayPrefix(modelId);
+  const [providerId, ...modelParts] = normalizedModelId.split("/");
+  const bareModelId = modelParts.join("/");
+  if (!providerId || !bareModelId) {
+    throw new Error(`Invalid model id: ${modelId}`);
+  }
+  const routerId = `${MASTRACODE_GATEWAY_ID}/${normalizedModelId}`;
+  const mgApiKey = MastraCodeGateway.getMemoryGatewayApiKey();
+  const rawGatewayBase = settings.memoryGateway?.baseUrl ?? process.env["MASTRA_GATEWAY_URL"] ?? "https://gateway-api.mastra.ai";
+  const gateway = createMastraCodeGateway({
+    mastraGatewayBaseUrl: rawGatewayBase.replace(/\/+$/, "").replace(/\/v1$/, ""),
+    mastraGatewayApiKey: mgApiKey,
+    routeThroughMastraGateway: Boolean(mgApiKey && isMastraGatewayModel),
+    thinkingLevel: options?.thinkingLevel,
+    customProviders: settings.customProviders
+  });
+  const auth = gateway.resolveAuth({
+    gatewayId: MASTRACODE_GATEWAY_ID,
+    providerId,
+    modelId: bareModelId,
+    routerId
+  });
+  return gateway.resolveLanguageModel({
+    providerId,
+    modelId: bareModelId,
+    apiKey: auth?.apiKey ?? mgApiKey ?? "",
+    headers
+  });
+}
+function getDynamicModel({ requestContext }) {
+  const harnessContext = requestContext.get("harness");
+  const modelId = harnessContext?.state?.currentModelId;
+  if (!modelId) {
+    throw new Error("No model selected. Use /models to select a model first.");
+  }
+  const thinkingLevel = harnessContext?.state?.thinkingLevel;
+  return resolveModel(modelId, { thinkingLevel, requestContext });
+}
+function getGoalJudgeModel({ requestContext }, settingsPath) {
+  const judgeModelId = loadSettings(settingsPath).models.goalJudgeModel;
+  if (!judgeModelId) return void 0;
+  return resolveModel(judgeModelId, { requestContext });
+}
+
+// src/agents/memory.ts
 var cachedMemory = null;
 var cachedMemoryKey = null;
 function getHarnessState(requestContext) {
@@ -1035,14 +2014,12 @@ function getHarnessState(requestContext) {
 function getObserverModel({ requestContext }) {
   const state = getHarnessState(requestContext);
   return resolveModel(state?.observerModelId ?? DEFAULT_OM_MODEL_ID, {
-    remapForCodexOAuth: true,
     requestContext
   });
 }
 function getReflectorModel({ requestContext }) {
   const state = getHarnessState(requestContext);
   return resolveModel(state?.reflectorModelId ?? DEFAULT_OM_MODEL_ID, {
-    remapForCodexOAuth: true,
     requestContext
   });
 }
@@ -1125,10 +2102,10 @@ ${CAVEMAN_OM_INSTRUCTION}` : DYNAMIC_AGENTS_MD_INSTRUCTION;
   };
 }
 
-// src/agents/subagents/execute.ts
-var executeSubagent = {
-  id: "execute",
-  name: "Execute",
+// src/agents/modes/build.ts
+var buildMode = {
+  id: "build",
+  name: "Build",
   description: "Task execution with write capabilities. Use for 'implement feature X', 'fix bug Y', 'refactor module Z'.",
   instructions: `You are a focused execution agent. Your job is to complete a specific, well-defined task by making the necessary changes to the codebase.
 
@@ -1161,14 +2138,19 @@ End with a structured summary:
 . **Completed**: What you implemented (1-2 sentences)
 . **Changes**: Files modified/created
 . **Verification**: How you verified it works
-. **Notes**: Follow-up needed (if any)`
+. **Notes**: Follow-up needed (if any)`,
+  defaultModelId: "openai/gpt-5.5",
+  metadata: {
+    default: true
+  }
 };
 
-// src/agents/subagents/explore.ts
-var exploreSubagent = {
-  id: "explore",
+// src/agents/modes/explore.ts
+var fastMode = {
+  id: "fast",
   name: "Explore",
   description: "Read-only codebase exploration. Use for questions like 'find all usages of X', 'how does module Y work'.",
+  defaultModelId: "openai/gpt-5.4-mini",
   instructions: `You are an expert code explorer. Your job is to investigate a codebase and answer a specific question or gather specific information.
 
 ## Rules
@@ -1194,14 +2176,15 @@ End with a structured summary:
 . **Key Files**: Most relevant files with line numbers
 . **Details**: Additional context if needed
 
-Keep your summary under 300 words.`,
-  allowedWorkspaceTools: [MC_TOOLS.VIEW, MC_TOOLS.SEARCH_CONTENT, MC_TOOLS.FIND_FILES]
+Keep your summary under 300 words.`
 };
 
-// src/agents/subagents/plan.ts
-var planSubagent = {
+// src/agents/modes/plan.ts
+var planMode = {
   id: "plan",
   name: "Plan",
+  transitionsTo: "build",
+  defaultModelId: "openai/gpt-5.5",
   description: "Read-only analysis and planning. Use for 'create an implementation plan for X', 'analyze the architecture of Y'.",
   instructions: `You are an expert software architect and planner. Your job is to analyze a codebase and produce a detailed implementation plan for a given task.
 
@@ -1231,7 +2214,9 @@ Structure your plan as:
 . **Risks**: Potential issues or edge cases (if any)
 
 Be specific about code locations (file paths, function names, line numbers). Keep the plan actionable and under 500 words.`,
-  allowedWorkspaceTools: [MC_TOOLS.VIEW, MC_TOOLS.SEARCH_CONTENT, MC_TOOLS.FIND_FILES]
+  metadata: {
+    default: false
+  }
 };
 
 // src/agents/thread-caveman-state.ts
@@ -1911,17 +2896,6 @@ function createEfficiencyScorer() {
     return parts.join("\n");
   });
 }
-function v1ModeToLegacy(mode, agent) {
-  const meta = mode.metadata ?? {};
-  return {
-    id: mode.id,
-    name: mode.description,
-    default: meta.default === true,
-    defaultModelId: mode.defaultModelId,
-    color: typeof meta.color === "string" ? meta.color : void 0,
-    agent
-  };
-}
 var VALID_EVENTS = [
   "PreToolUse",
   "PostToolUse",
@@ -2559,13 +3533,14 @@ function createMcpManager(projectDir, configDirName = DEFAULT_CONFIG_DIR, extraS
     });
     try {
       const { toolsets, errors } = await client.listToolsetsWithErrors();
-      for (const [serverName, serverTools] of Object.entries(toolsets)) {
+      const typedToolsets = toolsets;
+      for (const [serverName, serverTools] of Object.entries(typedToolsets)) {
         for (const [toolName, toolConfig] of Object.entries(serverTools)) {
           tools[`${serverName}_${toolName}`] = toolConfig;
         }
       }
       for (const name of serverNames) {
-        const serverTools = toolsets[name];
+        const serverTools = typedToolsets[name];
         if (serverTools && Object.keys(serverTools).length > 0) {
           const toolNames = Object.keys(serverTools).map((t) => `${name}_${t}`);
           serverStatuses.set(name, {
@@ -3042,31 +4017,8 @@ async function createVectorStore(config, effectiveBackend = config.backend) {
 }
 
 // src/index.ts
-var PROVIDER_TO_OAUTH_ID = {
-  anthropic: "anthropic",
-  openai: "openai-codex",
-  "github-copilot": "github-copilot"
-};
 var CODE_AGENT_ID = "code-agent";
-function hash(value) {
-  return createHash("sha256").update(value).digest("hex").slice(0, 32);
-}
-function legacyModeToV1(mode, fallbackAgent) {
-  const agent = typeof mode.agent === "function" ? mode.agent({}) : mode.agent;
-  return {
-    id: mode.id,
-    defaultModelId: mode.defaultModelId ?? "openai/gpt-5.5",
-    description: mode.name,
-    ...mode.id === "plan" ? { transitionsTo: "build" } : {},
-    metadata: {
-      agentId: (agent ?? fallbackAgent).id,
-      color: mode.color,
-      default: mode.default,
-      name: mode.name
-    }
-  };
-}
-function applyEffectiveDefaultsToV1Modes(modes, effectiveDefaults) {
+function applyEffectiveDefaultsToModes(modes, effectiveDefaults) {
   return modes.map((mode) => {
     const savedModel = effectiveDefaults[mode.id];
     if (!savedModel) {
@@ -3079,16 +4031,16 @@ function applyEffectiveDefaultsToV1Modes(modes, effectiveDefaults) {
   });
 }
 function createAuthStorage() {
-  const authStorage = new AuthStorage();
-  setAuthStorage(authStorage);
-  setAuthStorage3(authStorage);
-  setAuthStorage2(authStorage);
-  return authStorage;
+  const authStorage2 = new AuthStorage();
+  setAuthStorage(authStorage2);
+  setAuthStorage3(authStorage2);
+  setAuthStorage2(authStorage2);
+  return authStorage2;
 }
-function resolveCloudObservabilityConfig(settings, authStorage, resourceId) {
+function resolveCloudObservabilityConfig(settings, authStorage2, resourceId) {
   const resourceConfig = settings.observability.resources[resourceId];
   if (resourceConfig) {
-    const token = authStorage.getStoredApiKey(`${OBSERVABILITY_AUTH_PREFIX}${resourceId}`);
+    const token = authStorage2.getStoredApiKey(`${OBSERVABILITY_AUTH_PREFIX}${resourceId}`);
     if (token) {
       return { accessToken: token, projectId: resourceConfig.projectId };
     }
@@ -3108,10 +4060,9 @@ async function createMastraCode(config) {
     process.loadEnvFile(path__default.join(cwd, ".env"));
   } catch {
   }
-  const gatewayRegistry = GatewayRegistry.getInstance({ useDynamicLoading: true });
-  const authStorage = createAuthStorage();
+  const authStorage2 = createAuthStorage();
   const globalSettings = loadSettings(config?.settingsPath);
-  const storedGatewayKey = authStorage.getStoredApiKey(MEMORY_GATEWAY_PROVIDER);
+  const storedGatewayKey = authStorage2.getStoredApiKey(MEMORY_GATEWAY_PROVIDER);
   const storedGatewayUrl = globalSettings.memoryGateway?.baseUrl;
   if (storedGatewayKey) {
     process.env["MASTRA_GATEWAY_API_KEY"] ??= storedGatewayKey;
@@ -3127,9 +4078,9 @@ async function createMastraCode(config) {
       providerEnvVars[provider] = Array.isArray(envVars) ? envVars[0] : envVars;
     }
     providerEnvVars[MEMORY_GATEWAY_PROVIDER] ??= "MASTRA_GATEWAY_API_KEY";
-    authStorage.loadStoredApiKeysIntoEnv(providerEnvVars);
+    authStorage2.loadStoredApiKeysIntoEnv(providerEnvVars);
   } catch {
-    authStorage.loadStoredApiKeysIntoEnv({
+    authStorage2.loadStoredApiKeysIntoEnv({
       [MEMORY_GATEWAY_PROVIDER]: "MASTRA_GATEWAY_API_KEY",
       anthropic: "ANTHROPIC_API_KEY",
       openai: "OPENAI_API_KEY",
@@ -3138,9 +4089,14 @@ async function createMastraCode(config) {
       deepseek: "DEEPSEEK_API_KEY"
     });
   }
-  void Promise.resolve(gatewayRegistry.syncGateways(true)).catch(() => {
+  const mgApiKey = process.env["MASTRA_GATEWAY_API_KEY"] ?? storedGatewayKey;
+  const mastraGatewayBaseUrl = (process.env["MASTRA_GATEWAY_URL"] ?? storedGatewayUrl ?? "https://gateway-api.mastra.ai").replace(/\/+$/, "").replace(/\/v1$/, "");
+  const mastraCodeGateway = createMastraCodeGateway({
+    mastraGatewayBaseUrl,
+    mastraGatewayApiKey: mgApiKey,
+    routeThroughMastraGateway: false,
+    settingsPath: config?.settingsPath
   });
-  const mgApiKey = storedGatewayKey ?? process.env["MASTRA_GATEWAY_API_KEY"];
   const project = detectProject(cwd);
   const resourceIdOverride = getResourceIdOverride(project.rootPath, configDir);
   if (resourceIdOverride) {
@@ -3229,8 +4185,12 @@ async function createMastraCode(config) {
           "harness.state.reflectionThreshold"
         ],
         exporters: [
-          new MastraStorageExporter({ strategy: "event-sourced" }),
-          new MastraPlatformExporter(resolveCloudObservabilityConfig(globalSettings, authStorage, project.resourceId))
+          // Only persist traces locally when DuckDB observability is available
+          // (via `/observability local on`). Without this guard the storage
+          // exporter falls through to the default libsql backend and silently
+          // fills the main database with gigabytes of span data.
+          ...observabilityDomain ? [new MastraStorageExporter({ strategy: "event-sourced" })] : [],
+          new MastraPlatformExporter(resolveCloudObservabilityConfig(globalSettings, authStorage2, project.resourceId))
         ],
         spanOutputProcessors: [new SensitiveDataFilter()]
       }
@@ -3289,6 +4249,22 @@ async function createMastraCode(config) {
     // the tools into the toolset and registers the task state-signal processor,
     // so the task list persists across turns and survives OM truncation.
     signals: [new TaskSignalProvider(), ...githubSignals ? [githubSignals] : []],
+    // Native goal mechanism: the in-loop goal step judges the thread's active
+    // objective each qualifying iteration. The judge model is required for any
+    // gating to occur; when unset the goal step is a complete no-op. A6 auto-wires
+    // the GoalStateProcessor so the `<current-objective>` signal persists across
+    // turns. Per-thread overrides live in the ThreadState `goal` record and win
+    // over these defaults.
+    goal: {
+      // Resolve the judge model through mastracode's gateway (a model-resolver
+      // function) so provider credentials are injected; returns undefined when no
+      // judge model is configured, keeping the goal step a no-op. Bind the same
+      // `settingsPath` used above so the judge model and `maxRuns` come from one
+      // config (a custom settings file would otherwise diverge).
+      judge: (ctx) => getGoalJudgeModel(ctx, config?.settingsPath),
+      maxRuns: globalSettings.models.goalMaxTurns ?? 50,
+      prompt: DEFAULT_GOAL_JUDGE_PROMPT
+    },
     inputProcessors: [
       new AgentsMDInjector({
         getIgnoredInstructionPaths: ({ requestContext }) => {
@@ -3301,34 +4277,25 @@ async function createMastraCode(config) {
     ],
     errorProcessors: [new StreamErrorRetryProcessor(), new PrefillErrorHandler(), new ProviderHistoryCompat()]
   });
-  const defaultSubagents = [exploreSubagent, planSubagent, executeSubagent];
-  const defaultModesV1 = [
+  const defaultModes = [
     {
-      id: "build",
-      description: "Build",
-      defaultModelId: "anthropic/claude-opus-4-7",
+      ...buildMode,
       metadata: {
-        agentId: CODE_AGENT_ID,
-        color: mastra.green,
-        default: true
+        ...buildMode.metadata,
+        color: mastra.green
       }
     },
     {
-      id: "plan",
-      description: "Plan",
-      transitionsTo: "build",
-      defaultModelId: "openai/gpt-5.5",
+      ...planMode,
       metadata: {
-        agentId: CODE_AGENT_ID,
+        ...planMode.metadata,
         color: mastra.purple
       }
     },
     {
-      id: "fast",
-      description: "Fast",
-      defaultModelId: "cerebras/zai-glm-4.7",
+      ...fastMode,
       metadata: {
-        agentId: CODE_AGENT_ID,
+        ...fastMode.metadata,
         color: mastra.orange
       }
     }
@@ -3337,13 +4304,14 @@ async function createMastraCode(config) {
     {
       id: "gateway-sync",
       intervalMs: 5 * 60 * 1e3,
+      immediate: false,
       handler: () => syncGateways()
     }
   ];
   const heartbeatHandlers = config?.heartbeatHandlers ?? defaultHeartbeatHandlers;
-  const anthropicCred = authStorage.get("anthropic");
-  const openaiCred = authStorage.get("openai-codex");
-  const githubCopilotCred = authStorage.get("github-copilot");
+  const anthropicCred = authStorage2.get("anthropic");
+  const openaiCred = authStorage2.get("openai-codex");
+  const githubCopilotCred = authStorage2.get("github-copilot");
   const startupAccess = {
     anthropic: anthropicCred?.type === "oauth" ? "oauth" : anthropicCred?.type === "api_key" && anthropicCred.key.trim().length > 0 ? "apikey" : false,
     openai: openaiCred?.type === "oauth" ? "oauth" : openaiCred?.type === "api_key" && openaiCred.key.trim().length > 0 ? "apikey" : false,
@@ -3378,36 +4346,11 @@ async function createMastraCode(config) {
   const effectiveReflectionThreshold = globalSettings.models.omReflectionThreshold ?? void 0;
   const effectiveCavemanObservations = globalSettings.models.omCavemanObservations ?? void 0;
   const effectiveObserveAttachments = globalSettings.models.omObserveAttachments ?? "auto";
-  const modesV1 = applyEffectiveDefaultsToV1Modes(
-    config?.modes ? config.modes.map((mode) => legacyModeToV1(mode, codeAgent)) : defaultModesV1,
-    effectiveDefaults
-  );
-  const defaultModeId = modesV1.find((mode) => mode.metadata?.default === true)?.id ?? modesV1.find((mode) => mode.id === "plan")?.id ?? modesV1[0]?.id;
+  const modes = applyEffectiveDefaultsToModes(config?.modes ? config.modes : defaultModes, effectiveDefaults);
+  const defaultModeId = modes.find((mode) => mode.metadata?.default === true)?.id ?? modes.find((mode) => mode.id === "build")?.id ?? modes[0]?.id;
   if (!defaultModeId) {
     throw new Error("MastraCode requires at least one mode");
   }
-  const modes = modesV1.map((mode) => v1ModeToLegacy(mode, codeAgent));
-  const subagentModeMap = { explore: "fast", plan: "plan", execute: "build" };
-  const subagents = (config?.subagents ?? defaultSubagents).map((sa) => {
-    const modeId = subagentModeMap[sa.id];
-    const model = modeId ? effectiveDefaults[modeId] : void 0;
-    let filtered = sa;
-    if (config?.disabledTools?.length) {
-      if (sa.allowedWorkspaceTools) {
-        filtered = {
-          ...filtered,
-          allowedWorkspaceTools: sa.allowedWorkspaceTools.filter((t) => !config.disabledTools.includes(t))
-        };
-      }
-      if (sa.tools) {
-        filtered = {
-          ...filtered,
-          tools: Object.fromEntries(Object.entries(sa.tools).filter(([k]) => !config.disabledTools.includes(k)))
-        };
-      }
-    }
-    return model ? { ...filtered, defaultModelId: model } : filtered;
-  });
   const globalInitialState = {};
   if (effectiveObserverModel) {
     globalInitialState.observerModelId = effectiveObserverModel;
@@ -3441,33 +4384,6 @@ async function createMastraCode(config) {
       globalInitialState[`subagentModelId_${key}`] = modelId;
     }
   }
-  const { threads } = await (await storage.getStore("memory"))?.listThreads({
-    perPage: false,
-    filter: {
-      resourceId: project.resourceId
-    }
-  }) ?? { threads: [] };
-  const ownerId = `mastracode-${hash(`${hostname()}\0${project.rootPath}`)}`;
-  await Promise.all(
-    threads.map((thread) => {
-      const sessionHash = hash(`${thread.resourceId}\0${thread.id}`);
-      const meta = thread.metadata;
-      const modeId = typeof meta?.currentModeId === "string" ? meta.currentModeId : defaultModeId;
-      const mode = modesV1.find((mode2) => mode2.id === modeId) ?? modesV1.find((mode2) => mode2.id === defaultModeId);
-      const modelId = typeof meta?.currentModelId === "string" ? meta.currentModelId : mode.defaultModelId;
-      return harnessStorage.saveSession({
-        id: `sess-${sessionHash}`,
-        ownerId,
-        resourceId: thread.resourceId,
-        threadId: thread.id,
-        modeId: mode.id,
-        modelId,
-        origin: "top-level",
-        createdAt: thread.createdAt,
-        lastActivityAt: thread.updatedAt
-      });
-    })
-  );
   const typedStateSchema = stateSchema;
   const harness = new Harness({
     id: "mastra-code",
@@ -3477,8 +4393,9 @@ async function createMastraCode(config) {
     memory,
     pubsub: signalsPubSub,
     stateSchema: typedStateSchema,
-    subagents,
-    resolveModel: (modelId) => resolveModel(modelId),
+    agent: codeAgent,
+    subagents: config?.subagents ?? [],
+    gateways: [mastraCodeGateway],
     toolCategoryResolver: getToolCategory,
     initialState: {
       projectPath: project.rootPath,
@@ -3495,39 +4412,8 @@ async function createMastraCode(config) {
     browser: config?.browser,
     modes,
     heartbeatHandlers,
-    modelAuthChecker: (provider) => {
-      const gatewayKey = authStorage.getStoredApiKey(MEMORY_GATEWAY_PROVIDER) ?? process.env["MASTRA_GATEWAY_API_KEY"];
-      if (gatewayKey) {
-        const providerConfig = gatewayRegistry.getProviders()[provider];
-        if (providerConfig?.gateway === "mastra") return true;
-      }
-      const oauthId = PROVIDER_TO_OAUTH_ID[provider];
-      if (oauthId && authStorage.isLoggedIn(oauthId)) {
-        return true;
-      }
-      if (authStorage.hasStoredApiKey(provider)) {
-        return true;
-      }
-      if (provider === "anthropic") {
-        const cred = authStorage.get("anthropic");
-        if (cred?.type === "api_key" && cred.key.trim().length > 0) {
-          return true;
-        }
-      }
-      if (provider === "openai") {
-        const cred = authStorage.get("openai-codex");
-        if (cred?.type === "api_key" && cred.key.trim().length > 0) {
-          return true;
-        }
-      }
-      const customProvider = loadSettings().customProviders.find((entry) => {
-        return provider === getCustomProviderId(entry.name);
-      });
-      if (customProvider) {
-        return true;
-      }
-      return void 0;
-    },
+    resolveModel,
+    customModelCatalogProvider: createMastraCodeModelCatalogProvider(mastraCodeGateway),
     modelUseCountProvider: () => loadSettings().modelUseCounts,
     modelUseCountTracker: (modelId) => {
       try {
@@ -3538,37 +4424,6 @@ async function createMastraCode(config) {
         console.error("Failed to persist model usage count", error);
       }
     },
-    customModelCatalogProvider: async () => {
-      const settings = loadSettings();
-      const customModels = [];
-      for (const provider of settings.customProviders) {
-        const providerId = getCustomProviderId(provider.name);
-        for (const modelName of provider.models) {
-          customModels.push({
-            id: toCustomProviderModelId(provider.name, modelName),
-            provider: providerId,
-            modelName,
-            hasApiKey: true,
-            apiKeyEnvVar: void 0
-          });
-        }
-      }
-      try {
-        const copilotModels = await getCopilotModelCatalog({ authStorage });
-        for (const m of copilotModels) {
-          customModels.push({
-            id: `github-copilot/${m.id}`,
-            provider: "github-copilot",
-            modelName: m.id,
-            hasApiKey: true,
-            apiKeyEnvVar: void 0
-          });
-        }
-      } catch (error) {
-        console.warn("Failed to load GitHub Copilot model catalog:", error);
-      }
-      return customModels;
-    },
     threadLock: crossProcessPubSub ? void 0 : {
       acquire: acquireThreadLock,
       release: releaseThreadLock
@@ -3589,8 +4444,8 @@ async function createMastraCode(config) {
       if (!threadId) return;
       githubSignals.stopAllPolling();
       try {
-        const threads2 = await harness.listThreads({ allResources: true });
-        const thread = threads2.find((item) => item.id === threadId);
+        const threads = await harness.listThreads({ allResources: true });
+        const thread = threads.find((item) => item.id === threadId);
         await githubSignals.startPollingForThread(
           {
             threadId,
@@ -3617,7 +4472,7 @@ async function createMastraCode(config) {
     mcpManager,
     hookManager,
     signalsPubSub,
-    authStorage,
+    authStorage: authStorage2,
     resolveModel,
     storageWarning,
     observabilityWarning,
@@ -3629,5 +4484,5 @@ async function createMastraCode(config) {
 }
 
 export { createAuthStorage, createMastraCode };
-//# sourceMappingURL=chunk-FDDVVRPH.js.map
-//# sourceMappingURL=chunk-FDDVVRPH.js.map
+//# sourceMappingURL=chunk-RDIIIT54.js.map
+//# sourceMappingURL=chunk-RDIIIT54.js.map