Schema change refactor big bang (#108)

* feat: remove attach command, add create/bind dialog to add wizards

* feat: schema refactor with breaking changes

Schema: Agent->AgentEnvSpec; version int; artifact->build; RuntimeVersion supports Python+Node; entrypoint supports .py/.ts/.js; remove EPISODIC memory strategy; remove mcp from project spec (separate mcp.json)

Packaging: add Node/TypeScript packager; auto-select packager by runtime

TUI: simplify memory/identity wizards (flat resource model, no owner/user bindings)

CDK: update templates for mcpSpec as separate prop

* feat: add InstrumentationSchema with enableOtel support

Add InstrumentationSchema with enableOtel field (default true);
Update llm-compacted schemas with Node runtimes and instrumentation

* fix: fix build

---------

Co-authored-by: Tejas Kashinath <42380254+tejaskash@users.noreply.github.com>

Author: notgitika

src/assets/cdk/bin/cdk.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { AgentCoreStack } from '../lib/cdk-stack';
-import { ConfigIO, type AwsDeploymentTarget } from '@aws/agentcore-l3-cdk-constructs';
+import { ConfigIO, type AgentCoreMcpSpec, type AwsDeploymentTarget } from '@aws/agentcore-l3-cdk-constructs';
 import { App, type Environment } from 'aws-cdk-lib';
 import * as path from 'path';
 
@@ -23,6 +23,12 @@ async function main() {
   const spec = await configIO.readProjectSpec();
   const targets = await configIO.readAWSDeploymentTargets();
 
+  // Read MCP spec if it exists (stored separately in mcp.json)
+  let mcpSpec: AgentCoreMcpSpec | undefined;
+  if (configIO.configExists('mcp')) {
+    mcpSpec = await configIO.readMcpSpec();
+  }
+
   if (targets.length === 0) {
     throw new Error('No deployment targets configured. Please define targets in agentcore/aws-targets.json');
   }
@@ -35,6 +41,7 @@ async function main() {
 
     new AgentCoreStack(app, stackName, {
       spec,
+      mcpSpec,
       env,
       description: `AgentCore stack for ${spec.name} deployed to ${target.name} (${target.region})`,
       tags: {

src/assets/cdk/lib/cdk-stack.ts

@@ -1,12 +1,23 @@
-import { AgentCoreApplication, AgentCoreMcp, type AgentCoreProjectSpec } from '@aws/agentcore-l3-cdk-constructs';
+import {
+  AgentCoreApplication,
+  AgentCoreMcp,
+  type AgentCoreProjectSpec,
+  type AgentCoreMcpSpec,
+} from '@aws/agentcore-l3-cdk-constructs';
 import { CfnOutput, Stack, type StackProps } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 
 export interface AgentCoreStackProps extends StackProps {
   /**
-   * The complete AgentCore workspace specification containing all agents and MCP config.
+   * The AgentCore project specification containing agents, memories, and credentials.
    */
   spec: AgentCoreProjectSpec;
+
+  /**
+   * Optional MCP specification for gateways and runtime tools.
+   * MCP is stored separately in mcp.json.
+   */
+  mcpSpec?: AgentCoreMcpSpec;
 }
 
 /**
@@ -25,17 +36,18 @@ export class AgentCoreStack extends Stack {
   constructor(scope: Construct, id: string, props: AgentCoreStackProps) {
     super(scope, id, props);
 
-    const { spec } = props;
+    const { spec, mcpSpec } = props;
 
     // Create AgentCoreApplication with all agents
     this.application = new AgentCoreApplication(this, 'Application', {
       spec,
     });
 
-    // Instantiate AgentCoreMcp if MCP is defined
-    if (spec.mcp) {
+    // Instantiate AgentCoreMcp if MCP spec is provided
+    if (mcpSpec) {
       this.mcp = new AgentCoreMcp(this, 'Mcp', {
-        spec,
+        projectName: spec.name,
+        mcpSpec,
         agentCoreApplication: this.application,
       });
     }

src/cli/commands/add/actions.ts

@@ -4,7 +4,6 @@ import type {
   DirectoryPath,
   FilePath,
   GatewayAuthorizerType,
-  IdentityCredentialVariant,
   MemoryStrategyType,
   ModelProvider,
   SDKFramework,
@@ -13,37 +12,25 @@ import type {
 import { getErrorMessage } from '../../errors';
 import { setupPythonProject } from '../../operations';
 import {
-  mapGenerateConfigToAgentEnvSpec,
-  mapModelProviderToIdentityProviders,
+  mapGenerateConfigToRenderConfig,
+  mapModelProviderToCredentials,
   writeAgentToProject,
 } from '../../operations/agent/generate';
-import {
-  attachAgentToAgent,
-  attachGatewayToAgent,
-  attachIdentityToAgent,
-  attachMemoryToAgent,
-  bindMcpRuntimeToAgent,
-} from '../../operations/attach';
-import { computeDefaultIdentityEnvVarName, createIdentityFromWizard } from '../../operations/identity/create-identity';
+import { bindMcpRuntimeToAgent } from '../../operations/attach';
+import { computeDefaultCredentialEnvVarName, createCredential } from '../../operations/identity/create-identity';
 import { createGatewayFromWizard, createToolFromWizard } from '../../operations/mcp/create-mcp';
-import { createMemoryFromWizard } from '../../operations/memory/create-memory';
+import { createMemory } from '../../operations/memory/create-memory';
 import { createRenderer } from '../../templates';
 import type { MemoryOption } from '../../tui/screens/generate/types';
-import type { AddIdentityConfig } from '../../tui/screens/identity/types';
 import type { AddGatewayConfig, AddMcpToolConfig } from '../../tui/screens/mcp/types';
-import type { AddMemoryConfig, AddMemoryStrategyConfig } from '../../tui/screens/memory/types';
 import { DEFAULT_EVENT_EXPIRY } from '../../tui/screens/memory/types';
 import type {
   AddAgentResult,
   AddGatewayResult,
   AddIdentityResult,
   AddMcpToolResult,
   AddMemoryResult,
-  BindAgentResult,
-  BindGatewayResult,
-  BindIdentityResult,
   BindMcpRuntimeResult,
-  BindMemoryResult,
 } from './types';
 import { dirname, join } from 'path';
 
@@ -82,19 +69,13 @@ export interface ValidatedAddMcpToolOptions {
 
 export interface ValidatedAddMemoryOptions {
   name: string;
-  description?: string;
   strategies: string;
   expiry?: number;
-  owner: string;
-  users?: string;
 }
 
 export interface ValidatedAddIdentityOptions {
   name: string;
-  type: string;
   apiKey: string;
-  owner: string;
-  users?: string;
 }
 
 // Agent handlers
@@ -140,8 +121,8 @@ async function handleCreatePath(options: ValidatedAddAgentOptions, configBaseDir
 
   const agentPath = join(projectRoot, APP_DIR, options.name);
 
-  const agentSpec = mapGenerateConfigToAgentEnvSpec(generateConfig);
-  const renderer = createRenderer(agentSpec);
+  const renderConfig = mapGenerateConfigToRenderConfig(generateConfig);
+  const renderer = createRenderer(renderConfig);
   await renderer.render({ outputDir: projectRoot });
 
   await writeAgentToProject(generateConfig, { configBaseDir });
@@ -151,7 +132,7 @@ async function handleCreatePath(options: ValidatedAddAgentOptions, configBaseDir
   }
 
   if (options.apiKey && options.modelProvider !== 'Bedrock') {
-    const envVarName = computeDefaultIdentityEnvVarName(options.modelProvider);
+    const envVarName = computeDefaultCredentialEnvVarName(options.modelProvider);
     await setEnvVar(envVarName, options.apiKey, configBaseDir);
   }
 
@@ -165,34 +146,28 @@ async function handleByoPath(
 ): Promise<AddAgentResult> {
   const codeLocation = options.codeLocation!.endsWith('/') ? options.codeLocation! : `${options.codeLocation!}/`;
 
-  // Read project first to get project name for qualified identity provider names
   const project = await configIO.readProjectSpec();
 
-  const agentEnvSpec: AgentEnvSpec = {
+  const agent: AgentEnvSpec = {
+    type: 'AgentCoreRuntime',
     name: options.name,
-    id: `${options.name}Agent`,
-    sdkFramework: options.framework,
-    targetLanguage: options.language,
-    modelProvider: options.modelProvider,
-    runtime: {
-      artifact: 'CodeZip',
-      name: options.name,
-      entrypoint: (options.entrypoint ?? 'main.py') as FilePath,
-      codeLocation: codeLocation as DirectoryPath,
-      pythonVersion: 'PYTHON_3_12',
-      networkMode: 'PUBLIC',
-    },
-    mcpProviders: [],
-    memoryProviders: [],
-    identityProviders: mapModelProviderToIdentityProviders(options.modelProvider, project.name),
-    remoteTools: [],
+    build: 'CodeZip',
+    entrypoint: (options.entrypoint ?? 'main.py') as FilePath,
+    codeLocation: codeLocation as DirectoryPath,
+    runtimeVersion: 'PYTHON_3_12',
+    networkMode: 'PUBLIC',
   };
 
-  project.agents.push(agentEnvSpec);
+  project.agents.push(agent);
+
+  // Add credential for non-Bedrock providers
+  const credentials = mapModelProviderToCredentials(options.modelProvider, project.name);
+  project.credentials.push(...credentials);
+
   await configIO.writeProjectSpec(project);
 
   if (options.apiKey && options.modelProvider !== 'Bedrock') {
-    const envVarName = computeDefaultIdentityEnvVarName(options.modelProvider);
+    const envVarName = computeDefaultCredentialEnvVarName(options.modelProvider);
     await setEnvVar(envVarName, options.apiKey, configBaseDir);
   }
 
@@ -283,74 +258,58 @@ export async function handleAddMcpTool(options: ValidatedAddMcpToolOptions): Pro
   }
 }
 
-// Memory handler
-function buildMemoryConfig(options: ValidatedAddMemoryOptions): AddMemoryConfig {
-  const userAgents = options.users
-    ? options.users
-        .split(',')
-        .map(s => s.trim())
-        .filter(Boolean)
-    : [];
+// Memory handler (v2: top-level resource, no owner/user)
+export async function handleAddMemory(options: ValidatedAddMemoryOptions): Promise<AddMemoryResult> {
+  try {
+    const strategies = options.strategies
+      .split(',')
+      .map(s => s.trim())
+      .filter(Boolean)
+      .map(type => ({ type: type as MemoryStrategyType }));
 
-  const strategies: AddMemoryStrategyConfig[] = options.strategies
-    .split(',')
-    .map(s => s.trim())
-    .filter(Boolean)
-    .map(type => ({ type: type as MemoryStrategyType }));
+    const result = await createMemory({
+      name: options.name,
+      eventExpiryDuration: options.expiry ?? DEFAULT_EVENT_EXPIRY,
+      strategies,
+    });
 
-  return {
-    name: options.name,
-    description: options.description ?? `Memory for ${options.name}`,
-    eventExpiryDuration: options.expiry ?? DEFAULT_EVENT_EXPIRY,
-    strategies,
-    ownerAgent: options.owner,
-    userAgents,
-  };
+    return { success: true, memoryName: result.name };
+  } catch (err) {
+    return { success: false, error: getErrorMessage(err) };
+  }
 }
 
-export async function handleAddMemory(options: ValidatedAddMemoryOptions): Promise<AddMemoryResult> {
+// Identity handler (v2: top-level credential resource, no owner/user)
+export async function handleAddIdentity(options: ValidatedAddIdentityOptions): Promise<AddIdentityResult> {
   try {
-    const config = buildMemoryConfig(options);
-    const result = await createMemoryFromWizard(config);
-    return {
-      success: true,
-      memoryName: result.name,
-      ownerAgent: result.ownerAgent,
-      userAgents: result.userAgents,
-    };
+    const result = await createCredential({
+      name: options.name,
+      apiKey: options.apiKey,
+    });
+
+    return { success: true, credentialName: result.name };
   } catch (err) {
     return { success: false, error: getErrorMessage(err) };
   }
 }
 
-// Identity handler
-function buildIdentityConfig(options: ValidatedAddIdentityOptions): AddIdentityConfig {
-  const userAgents = options.users
-    ? options.users
-        .split(',')
-        .map(s => s.trim())
-        .filter(Boolean)
-    : [];
+// ─────────────────────────────────────────────────────────────────────────────
+// MCP Runtime Bind handler (still relevant in v2)
+// ─────────────────────────────────────────────────────────────────────────────
 
-  return {
-    identityType: options.type as IdentityCredentialVariant,
-    name: options.name,
-    apiKey: options.apiKey,
-    ownerAgent: options.owner,
-    userAgents,
-  };
+export interface ValidatedBindMcpRuntimeOptions {
+  agent: string;
+  runtime: string;
+  envVar: string;
 }
 
-export async function handleAddIdentity(options: ValidatedAddIdentityOptions): Promise<AddIdentityResult> {
+export async function handleBindMcpRuntime(options: ValidatedBindMcpRuntimeOptions): Promise<BindMcpRuntimeResult> {
   try {
-    const config = buildIdentityConfig(options);
-    const result = await createIdentityFromWizard(config);
-    return {
-      success: true,
-      identityName: result.name,
-      ownerAgent: result.ownerAgent,
-      userAgents: result.userAgents,
-    };
+    await bindMcpRuntimeToAgent(options.runtime, {
+      agentName: options.agent,
+      envVarName: options.envVar,
+    });
+    return { success: true, runtimeName: options.runtime, targetAgent: options.agent };
   } catch (err) {
     return { success: false, error: getErrorMessage(err) };
   }
@@ -420,24 +379,6 @@ export async function handleBindGateway(options: ValidatedBindGatewayOptions): P
   }
 }
 
-export interface ValidatedBindMcpRuntimeOptions {
-  agent: string;
-  runtime: string;
-  envVar: string;
-}
-
-export async function handleBindMcpRuntime(options: ValidatedBindMcpRuntimeOptions): Promise<BindMcpRuntimeResult> {
-  try {
-    await bindMcpRuntimeToAgent(options.runtime, {
-      agentName: options.agent,
-      envVarName: options.envVar,
-    });
-    return { success: true, runtimeName: options.runtime, targetAgent: options.agent };
-  } catch (err) {
-    return { success: false, error: getErrorMessage(err) };
-  }
-}
-
 export interface ValidatedBindAgentOptions {
   source: string;
   target: string;