@mastra/core 1.24.0 → 1.24.1-alpha.1

package/dist/docs/references/docs-editor-overview.md

@@ -72,6 +72,72 @@ Go to the **Agents** tab in Studio and select an agent to edit. Select the **Edi
 
 Modify the system prompt and save a new draft version. Afterwards, publish the draft to make it the active version.
 
+## Programmatic control
+
+Everything you can do in Studio is also available programmatically through [`mastra.getEditor()`](https://mastra.ai/reference/core/getEditor). This is useful for scripting bulk updates, seeding stored configurations from code, or building automation that tunes agents based on evaluation results.
+
+Call `mastra.getEditor()` from anywhere you have access to the `Mastra` instance. It returns the `MastraEditor` instance you registered, with namespaces for each resource type:
+
+```typescript
+import { mastra } from '../mastra'
+
+const editor = mastra.getEditor()
+if (!editor) throw new Error('Editor is not registered on Mastra')
+
+// Create a stored agent override for an existing code-defined agent
+await editor.agent.create({
+  id: 'support-agent',
+  instructions: 'You are a friendly support agent for Acme Inc.',
+  tools: {
+    search_kb: { description: 'Search the Acme knowledge base' },
+  },
+})
+```
+
+Use `editor.agent.update()` to change an existing stored configuration. Every update creates a new draft version automatically:
+
+```typescript
+import { mastra } from '../mastra'
+
+const editor = mastra.getEditor()!
+
+await editor.agent.update({
+  id: 'support-agent',
+  instructions:
+    "You are a friendly support agent for Acme Inc. Always respond in the user's language.",
+})
+```
+
+The `editor.agent` namespace also exposes `getById`, `list`, `listResolved`, and `delete`. The `editor.prompt` namespace exposes the same CRUD methods for prompt blocks. See [Prompts](https://mastra.ai/docs/editor/prompts) for examples.
+
+### Server endpoints
+
+The same operations are available over HTTP through the Mastra server. Use these when you want to manage stored agents from a separate service or from a non-TypeScript client:
+
+| Method   | Path                            | Description               |
+| -------- | ------------------------------- | ------------------------- |
+| `GET`    | `/stored/agents`                | List all stored agents.   |
+| `POST`   | `/stored/agents`                | Create a stored agent.    |
+| `GET`    | `/stored/agents/:storedAgentId` | Get a stored agent by ID. |
+| `PATCH`  | `/stored/agents/:storedAgentId` | Update a stored agent.    |
+| `DELETE` | `/stored/agents/:storedAgentId` | Delete a stored agent.    |
+
+The Client SDK wraps these endpoints with `client.listStoredAgents()`, `client.createStoredAgent()`, and `client.getStoredAgent()`. Version management endpoints live under `/stored/agents/:storedAgentId/versions`, see [version management](https://mastra.ai/reference/client-js/agents) for the full list.
+
+### Automated experimentation
+
+Because stored agents are just data, you can build automation loops that tune agents without human involvement. A common pattern is to pair the editor API with [datasets](https://mastra.ai/docs/evals/datasets/overview) and [experiments](https://mastra.ai/docs/evals/datasets/running-experiments):
+
+- Run a dataset through the current version of an agent and score the results.
+- Have another agent read the failing cases and propose changes to the instructions or tools.
+- Apply those changes with `editor.agent.update()` to create a new draft.
+- Re-run the experiment against the draft and compare scores to the baseline.
+- Promote the draft to the published version when the scores improve.
+
+This turns agent tuning into a closed feedback loop. One agent owns the production configuration, another agent iterates on it, and every change is versioned so you can roll back if a round of automated edits makes things worse. Combine this with [version targeting](#version-targeting-and-experimentation) to keep production traffic on the published version while the draft is being tested.
+
+> **Note:** See the [MastraEditor reference](https://mastra.ai/reference/editor/mastra-editor) for the full namespace API.
+
 ## What can be overridden
 
 When you edit a code-defined agent through the editor, only specific fields can be changed:

package/dist/docs/references/docs-editor-prompts.md

@@ -59,6 +59,69 @@ Rule groups can be nested, so you can combine AND and OR conditions for complex
 
 In the Studio, open a block's **Display conditions** panel to set up rules visually. You can also configure conditions programmatically through the API. Blocks without conditions are always included.
 
+## Programmatic control
+
+Prompt blocks can be managed from code through [`mastra.getEditor().prompt`](https://mastra.ai/reference/editor/mastra-editor). This is useful for seeding a set of starter prompts, syncing blocks between environments, or generating prompt variants from a script.
+
+Create a new prompt block with `editor.prompt.create()`:
+
+```typescript
+import { mastra } from '../mastra'
+
+const editor = mastra.getEditor()!
+
+await editor.prompt.create({
+  id: 'brand-voice',
+  name: 'Brand voice',
+  description: 'Acme Inc. tone and style guidelines',
+  content:
+    'You write in a friendly, concise tone. Always address the user as {{userName || "there"}}.',
+})
+```
+
+Update an existing block with `editor.prompt.update()`. Each update creates a new draft version:
+
+```typescript
+import { mastra } from '../mastra'
+
+const editor = mastra.getEditor()!
+
+await editor.prompt.update({
+  id: 'brand-voice',
+  content: 'You write in a friendly, concise tone. Always greet the user by name when available.',
+})
+```
+
+Use `editor.prompt.list()` to paginate through stored blocks or `editor.prompt.getById()` to fetch a specific block. To preview an agent's full instructions with a set of prompt blocks applied, call `editor.prompt.preview()` with the draft content.
+
+The same operations are available over HTTP through the Mastra server:
+
+| Method   | Path                                         | Description                      |
+| -------- | -------------------------------------------- | -------------------------------- |
+| `GET`    | `/stored/prompt-blocks`                      | List all stored prompt blocks.   |
+| `POST`   | `/stored/prompt-blocks`                      | Create a stored prompt block.    |
+| `GET`    | `/stored/prompt-blocks/:storedPromptBlockId` | Get a stored prompt block by ID. |
+| `PATCH`  | `/stored/prompt-blocks/:storedPromptBlockId` | Update a stored prompt block.    |
+| `DELETE` | `/stored/prompt-blocks/:storedPromptBlockId` | Delete a stored prompt block.    |
+
+Once a prompt block is created, reference it from an agent's `instructions` field as a `prompt_block_ref`:
+
+```typescript
+import { mastra } from '../mastra'
+
+const editor = mastra.getEditor()!
+
+await editor.agent.update({
+  id: 'support-agent',
+  instructions: [
+    { type: 'prompt_block_ref', id: 'brand-voice' },
+    { type: 'text', content: 'Answer only questions about Acme products.' },
+  ],
+})
+```
+
+> **Note:** See the [MastraEditor reference](https://mastra.ai/reference/editor/mastra-editor) for the full `editor.prompt` API.
+
 ## Versioning
 
 Prompt blocks follow the same [versioning lifecycle](https://mastra.ai/docs/editor/overview) as agents. Each prompt block has a draft that you can edit and publish as a versioned snapshot. This means prompt content can be versioned and rolled back independently from the agent that uses it.

package/dist/docs/references/docs-editor-tools.md

@@ -57,7 +57,7 @@ Integration providers connect external tool platforms to the editor. Once regist
    ```typescript
    import { Mastra } from '@mastra/core'
    import { MastraEditor } from '@mastra/editor'
-   import { ComposioToolProvider } from '@mastra/editor/providers/composio'
+   import { ComposioToolProvider } from '@mastra/editor/composio'
 
    export const mastra = new Mastra({
      agents: {
@@ -86,7 +86,7 @@ Integration providers connect external tool platforms to the editor. Once regist
    ```typescript
    import { Mastra } from '@mastra/core'
    import { MastraEditor } from '@mastra/editor'
-   import { ArcadeToolProvider } from '@mastra/editor/providers/arcade'
+   import { ArcadeToolProvider } from '@mastra/editor/arcade'
 
    export const mastra = new Mastra({
      agents: {

package/dist/docs/references/reference-core-getEditor.md

@@ -0,0 +1,35 @@
+# Mastra.getEditor()
+
+The `.getEditor()` method is used to retrieve the editor instance that has been configured on the Mastra instance. The editor exposes CRUD namespaces for managing stored agents, prompt blocks, MCP clients, scorers, skills, and workspaces programmatically.
+
+## Usage example
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { MastraEditor } from '@mastra/editor'
+
+const mastra = new Mastra({
+  editor: new MastraEditor(),
+})
+
+const editor = mastra.getEditor()
+
+const agent = await editor?.agent.create({
+  id: 'support-agent',
+  name: 'Support Agent',
+  instructions: 'Help customers with their questions.',
+})
+```
+
+## Parameters
+
+This method doesn't accept any parameters.
+
+## Returns
+
+**editor** (`MastraEditor | undefined`): The configured editor instance, or undefined if no editor has been configured.
+
+## Related
+
+- [Editor overview](https://mastra.ai/docs/editor/overview)
+- [MastraEditor reference](https://mastra.ai/reference/editor/mastra-editor)

package/dist/docs/references/reference-editor-mastra-editor.md

@@ -41,18 +41,96 @@ export const mastra = new Mastra({
 
 ## Namespaces
 
-The editor exposes namespaces for managing different entity types. These are used by the Mastra server and Studio — you don't call them directly in application code.
+The editor exposes namespaces for managing different entity types. Access them from any Mastra instance with `mastra.getEditor()` and call the CRUD methods directly in application code, or rely on the Mastra server routes that use them under the hood.
+
+All namespaces extend a shared CRUD base class, so they expose the same `create`, `getById`, `update`, `delete`, `list`, `listResolved`, and `clearCache` methods. The namespace-specific property tables below also document any additional methods.
 
 **agent** (`EditorAgentNamespace`): CRUD operations and version management for stored agents. Handles applying stored overrides to code-defined agents.
 
+**agent.create** (`(input: StorageCreateAgentInput) => Promise<Agent>`): Create a new stored agent and return a hydrated Agent instance. Accepts an id, authorId, metadata, and the initial snapshot (name, description, instructions, model, tools, memory, and so on).
+
+**agent.getById** (`(id: string, options?: GetByIdOptions) => Promise<Agent | null>`): Return a hydrated Agent instance for a stored agent. Pass options with versionId, versionNumber, or status ("draft" | "published" | "archived") to target a specific version. Default version requests are cached.
+
+**agent.update** (`(input: StorageUpdateAgentInput) => Promise<Agent>`): Partially update a stored agent. Creates a new draft version with the provided snapshot fields (instructions, tools, memory, and so on) and invalidates the cache. Set memory to null to disable memory.
+
+**agent.delete** (`(id: string) => Promise<void>`): Delete a stored agent and remove it from the Mastra runtime registry.
+
+**agent.list** (`(args?: StorageListAgentsInput) => Promise<StorageListAgentsOutput>`): List stored agents with optional pagination, orderBy, authorId, and metadata filters. Returns raw stored snapshots.
+
+**agent.listResolved** (`(args?: StorageListAgentsInput) => Promise<StorageListAgentsResolvedOutput>`): Same as list, but returns fully resolved configurations with references dereferenced.
+
+**agent.applyStoredOverrides** (`(agent: Agent, options?: { versionId?: string; status?: "draft" | "published" }) => Promise<Agent>`): Mutate a code-defined agent in place to apply any stored overrides (instructions, tools, variables). Called internally by mastra.getAgent() — you rarely call it directly.
+
+**agent.clone** (`(agent: Agent, options: { newId: string; newName?: string; metadata?: Record<string, unknown>; authorId?: string; requestContext?: RequestContext; }) => Promise<Agent>`): Create a new stored agent by cloning an existing agent.
+
+**agent.clearCache** (`(agentId?: string) => void`): Clear the in-memory cache for one agent or all agents. Called automatically after mutations.
+
 **prompt** (`EditorPromptNamespace`): CRUD operations for prompt blocks. Includes a preview method for resolving instruction blocks with draft content.
 
+**prompt.create** (`(input: StorageCreatePromptBlockInput) => Promise<StorageResolvedPromptBlockType>`): Create a new stored prompt block. Accepts an id, authorId, metadata, and the initial snapshot (name, description, content, rules, requestContextSchema).
+
+**prompt.getById** (`(id: string, options?: GetByIdOptions) => Promise<StorageResolvedPromptBlockType | null>`): Return a resolved prompt block. Pass options to target a specific version or status.
+
+**prompt.update** (`(input: StorageUpdatePromptBlockInput) => Promise<StorageResolvedPromptBlockType>`): Partially update a stored prompt block. Creates a new draft version with the provided snapshot fields.
+
+**prompt.delete** (`(id: string) => Promise<void>`): Delete a stored prompt block and remove it from the Mastra runtime registry.
+
+**prompt.list** (`(args?: StorageListPromptBlocksInput) => Promise<StorageListPromptBlocksOutput>`): List stored prompt blocks with optional pagination, orderBy, authorId, metadata, and status filters.
+
+**prompt.listResolved** (`(args?: StorageListPromptBlocksInput) => Promise<StorageListPromptBlocksResolvedOutput>`): Same as list, but returns fully resolved prompt block content.
+
+**prompt.preview** (`(blocks: AgentInstructionBlock[], context: Record<string, unknown>) => Promise<string>`): Resolve an array of instruction blocks against a context, rendering template variables and evaluating display conditions. Includes draft content for referenced prompt blocks.
+
+**prompt.clearCache** (`(id?: string) => void`): Clear the in-memory cache for one prompt block or all prompt blocks.
+
 **mcp** (`EditorMCPNamespace`): CRUD operations for stored MCP client configurations.
 
+**mcp.create** (`(input: StorageCreateMCPClientInput) => Promise<MCPClient>`): Create a new stored MCP client. Accepts an id, authorId, metadata, and the initial snapshot (servers, tool filtering).
+
+**mcp.getById** (`(id: string, options?: GetByIdOptions) => Promise<MCPClient | null>`): Return a hydrated MCPClient instance for a stored MCP client.
+
+**mcp.update** (`(input: StorageUpdateMCPClientInput) => Promise<MCPClient>`): Partially update a stored MCP client and invalidate the cache.
+
+**mcp.delete** (`(id: string) => Promise<void>`): Delete a stored MCP client and remove it from the Mastra runtime registry.
+
+**mcp.list** (`(args?: StorageListMCPClientsInput) => Promise<StorageListMCPClientsOutput>`): List stored MCP clients with optional pagination and filters.
+
+**mcp.listResolved** (`(args?: StorageListMCPClientsInput) => Promise<StorageListMCPClientsResolvedOutput>`): Same as list, but returns fully resolved MCP client configurations.
+
+**mcp.clearCache** (`(id?: string) => void`): Clear the in-memory cache for one MCP client or all MCP clients.
+
 **mcpServer** (`EditorMCPServerNamespace`): CRUD operations for MCP server configurations.
 
+**mcpServer.create** (`(input: StorageCreateMCPServerInput) => Promise<MCPServerBase>`): Create a new stored MCP server configuration and return a hydrated server instance.
+
+**mcpServer.getById** (`(id: string, options?: GetByIdOptions) => Promise<MCPServerBase | null>`): Return a hydrated MCP server for a given id.
+
+**mcpServer.update** (`(input: StorageUpdateMCPServerInput) => Promise<MCPServerBase>`): Partially update a stored MCP server configuration.
+
+**mcpServer.delete** (`(id: string) => Promise<void>`): Delete a stored MCP server configuration.
+
+**mcpServer.list** (`(args?: StorageListMCPServersInput) => Promise<StorageListMCPServersOutput>`): List stored MCP server configurations.
+
+**mcpServer.listResolved** (`(args?: StorageListMCPServersInput) => Promise<StorageListMCPServersResolvedOutput>`): Same as list, but returns fully resolved server configurations.
+
+**mcpServer.clearCache** (`(id?: string) => void`): Clear the in-memory cache for one MCP server or all MCP servers.
+
 **scorer** (`EditorScorerNamespace`): CRUD operations for scorer configurations.
 
+**scorer.create** (`(input: StorageCreateScorerInput) => Promise<MastraScorer>`): Create a new stored scorer and return a hydrated MastraScorer instance.
+
+**scorer.getById** (`(id: string, options?: GetByIdOptions) => Promise<MastraScorer | null>`): Return a hydrated scorer for a given id.
+
+**scorer.update** (`(input: StorageUpdateScorerInput) => Promise<MastraScorer>`): Partially update a stored scorer.
+
+**scorer.delete** (`(id: string) => Promise<void>`): Delete a stored scorer and remove it from the Mastra runtime registry.
+
+**scorer.list** (`(args?: StorageListScorersInput) => Promise<StorageListScorersOutput>`): List stored scorers with optional pagination and filters.
+
+**scorer.listResolved** (`(args?: StorageListScorersInput) => Promise<StorageListScorersResolvedOutput>`): Same as list, but returns fully resolved scorer configurations.
+
+**scorer.clearCache** (`(id?: string) => void`): Clear the in-memory cache for one scorer or all scorers.
+
 ## Methods
 
 ### Provider access

package/dist/docs/references/reference.md

@@ -63,6 +63,7 @@ The Reference section provides documentation of Mastra's API, including paramete
 - [.getAgent()](https://mastra.ai/reference/core/getAgent)
 - [.getAgentById()](https://mastra.ai/reference/core/getAgentById)
 - [.getDeployer()](https://mastra.ai/reference/core/getDeployer)
+- [.getEditor()](https://mastra.ai/reference/core/getEditor)
 - [.getGateway()](https://mastra.ai/reference/core/getGateway)
 - [.getGatewayById()](https://mastra.ai/reference/core/getGatewayById)
 - [.getLogger()](https://mastra.ai/reference/core/getLogger)

package/dist/evals/index.cjs

@@ -1,22 +1,22 @@
 'use strict';
 
-var chunkKDLCZTD3_cjs = require('../chunk-KDLCZTD3.cjs');
-var chunkV7H57YBW_cjs = require('../chunk-V7H57YBW.cjs');
+var chunkUHYAP2CY_cjs = require('../chunk-UHYAP2CY.cjs');
+var chunkNPYKTS7A_cjs = require('../chunk-NPYKTS7A.cjs');
 var chunkP5C4HEAB_cjs = require('../chunk-P5C4HEAB.cjs');
 
 
 
 Object.defineProperty(exports, "runEvals", {
   enumerable: true,
-  get: function () { return chunkKDLCZTD3_cjs.runEvals; }
+  get: function () { return chunkUHYAP2CY_cjs.runEvals; }
 });
 Object.defineProperty(exports, "MastraScorer", {
   enumerable: true,
-  get: function () { return chunkV7H57YBW_cjs.MastraScorer; }
+  get: function () { return chunkNPYKTS7A_cjs.MastraScorer; }
 });
 Object.defineProperty(exports, "createScorer", {
   enumerable: true,
-  get: function () { return chunkV7H57YBW_cjs.createScorer; }
+  get: function () { return chunkNPYKTS7A_cjs.createScorer; }
 });
 Object.defineProperty(exports, "extractTrajectory", {
   enumerable: true,

package/dist/evals/index.js

@@ -1,5 +1,5 @@
-export { runEvals } from '../chunk-3P6XSZUF.js';
-export { MastraScorer, createScorer } from '../chunk-SE7ST47S.js';
+export { runEvals } from '../chunk-ABEBCXBS.js';
+export { MastraScorer, createScorer } from '../chunk-5SVDDL2G.js';
 export { extractTrajectory, extractTrajectoryFromTrace, extractWorkflowTrajectory, listScoresResponseSchema, saveScorePayloadSchema, scoreResultSchema, scoreRowDataSchema, scoringEntityTypeSchema, scoringExtractStepResultSchema, scoringHookInputSchema, scoringInputSchema, scoringInputWithExtractStepResultAndAnalyzeStepResultSchema, scoringInputWithExtractStepResultAndScoreAndReasonSchema, scoringInputWithExtractStepResultSchema, scoringPromptsSchema, scoringSourceSchema, scoringValueSchema } from '../chunk-Y4SL4WJQ.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/evals/scoreTraces/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkIZQ4UPH5_cjs = require('../../chunk-IZQ4UPH5.cjs');
+var chunkM4SXMLXQ_cjs = require('../../chunk-M4SXMLXQ.cjs');
 var chunkP5C4HEAB_cjs = require('../../chunk-P5C4HEAB.cjs');
 var chunkQFGYBEP3_cjs = require('../../chunk-QFGYBEP3.cjs');
 var chunk4U7ZLI36_cjs = require('../../chunk-4U7ZLI36.cjs');
@@ -234,7 +234,7 @@ function transformTraceToScorerInputAndOutput(trace) {
 }
 
 // src/evals/scoreTraces/scoreTracesWorkflow.ts
-var getTraceStep = chunkIZQ4UPH5_cjs.createStep({
+var getTraceStep = chunkM4SXMLXQ_cjs.createStep({
   id: "__process-trace-scoring",
   inputSchema: v4.z.object({
     targets: v4.z.array(
@@ -429,7 +429,7 @@ async function attachScoreToSpan({
   } catch {
   }
 }
-var scoreTracesWorkflow = chunkIZQ4UPH5_cjs.createWorkflow({
+var scoreTracesWorkflow = chunkM4SXMLXQ_cjs.createWorkflow({
   id: "__batch-scoring-traces",
   inputSchema: v4.z.object({
     targets: v4.z.array(

package/dist/evals/scoreTraces/index.js

@@ -1,4 +1,4 @@
-import { createStep, createWorkflow } from '../../chunk-B5643WMN.js';
+import { createStep, createWorkflow } from '../../chunk-OFDFDY4Z.js';
 import { saveScorePayloadSchema } from '../../chunk-Y4SL4WJQ.js';
 import { getEntityTypeForSpan } from '../../chunk-E7PBOS66.js';
 import { MastraError } from '../../chunk-FJEVLHJT.js';

package/dist/harness/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunkN7S3MTPO_cjs = require('../chunk-N7S3MTPO.cjs');
-var chunkV7H57YBW_cjs = require('../chunk-V7H57YBW.cjs');
+var chunkCWGTLGSP_cjs = require('../chunk-CWGTLGSP.cjs');
+var chunkNPYKTS7A_cjs = require('../chunk-NPYKTS7A.cjs');
 var chunkRNJ2FXGD_cjs = require('../chunk-RNJ2FXGD.cjs');
 var chunkXS3FHQ34_cjs = require('../chunk-XS3FHQ34.cjs');
 var chunkLDLHW3QN_cjs = require('../chunk-LDLHW3QN.cjs');
@@ -313,7 +313,7 @@ Use this tool when:
         };
       }
       const workspace = context?.workspace;
-      const subagent = new chunkV7H57YBW_cjs.Agent({
+      const subagent = new chunkNPYKTS7A_cjs.Agent({
         id: `subagent-${definition.id}`,
         name: `${definition.name} Subagent`,
         instructions: definition.instructions,
@@ -340,15 +340,20 @@ Use this tool when:
       });
       let partialText = "";
       const toolCallLog = [];
+      let subagentRequestContext;
+      if (context?.requestContext) {
+        subagentRequestContext = new chunk5WBEMKE2_cjs.RequestContext(context.requestContext.entries());
+        if (harnessCtx) {
+          subagentRequestContext.set("harness", { ...harnessCtx, threadId: null, resourceId: "" });
+        }
+      }
       try {
         const response = await subagent.stream(task, {
           maxSteps: definition.maxSteps ?? (definition.stopWhen ? void 0 : 50),
           stopWhen: definition.stopWhen,
           abortSignal,
           requireToolApproval: false,
-          // Forward the parent's request context so the subagent inherits
-          // sandbox allowed paths and other harness state.
-          requestContext: context?.requestContext,
+          requestContext: subagentRequestContext,
           // When allowedWorkspaceTools is set, hide workspace tools not in
           // the list. Non-workspace tools always pass through.
           prepareStep: allowedWs && allWorkspaceToolNames ? ({ tools }) => ({
@@ -576,7 +581,7 @@ var Harness = class {
    */
   async init() {
     if (this.config.storage) {
-      this.#internalMastra = new chunkN7S3MTPO_cjs.Mastra({ logger: false, storage: this.config.storage });
+      this.#internalMastra = new chunkCWGTLGSP_cjs.Mastra({ logger: false, storage: this.config.storage });
       await this.#internalMastra.getStorage().init();
     }
     if (this.config.workspace && !this.workspaceInitialized && !this.workspaceFn) {
@@ -832,7 +837,7 @@ var Harness = class {
       }
     }
     try {
-      const { PROVIDER_REGISTRY } = await import('../provider-registry-2RFGIGU5.cjs');
+      const { PROVIDER_REGISTRY } = await import('../provider-registry-W3UHSSXG.cjs');
       const registry = PROVIDER_REGISTRY;
       const providerConfig = registry[provider];
       const envVars = providerConfig?.apiKeyEnvVar;
@@ -852,7 +857,7 @@ var Harness = class {
    */
   async listAvailableModels() {
     try {
-      const { PROVIDER_REGISTRY } = await import('../provider-registry-2RFGIGU5.cjs');
+      const { PROVIDER_REGISTRY } = await import('../provider-registry-W3UHSSXG.cjs');
       if (!PROVIDER_REGISTRY) return [];
       const registry = PROVIDER_REGISTRY;
       const providers = Object.keys(registry);
@@ -911,7 +916,7 @@ var Harness = class {
   }
   async getProviderApiKeyEnvVar(provider) {
     try {
-      const { PROVIDER_REGISTRY } = await import('../provider-registry-2RFGIGU5.cjs');
+      const { PROVIDER_REGISTRY } = await import('../provider-registry-W3UHSSXG.cjs');
       const registry = PROVIDER_REGISTRY;
       const envVars = registry[provider]?.apiKeyEnvVar;
       return Array.isArray(envVars) ? envVars[0] : envVars;