feat: runtime endpoint support in AgentCore CLI

.gitignore

@@ -67,6 +67,7 @@ ProtocolTesting/
 
 # Auto-cloned CDK constructs (from scripts/bundle.mjs)
 .cdk-constructs-clone/
+.omc/
 
 # Browser tests
 browser-tests/.browser-test-env

src/cli/cloudformation/outputs.ts

@@ -6,6 +6,7 @@ import type {
   OnlineEvalDeployedState,
   PolicyDeployedState,
   PolicyEngineDeployedState,
+  RuntimeEndpointDeployedState,
   TargetDeployedState,
 } from '../../schema';
 import { getCredentialProvider } from '../aws';
@@ -338,6 +339,40 @@ export function parsePolicyOutputs(
   return policies;
 }
 
+/**
+ * Parse stack outputs into deployed state for runtime endpoints.
+ *
+ * Output key pattern: ApplicationAgent{AgentPascal}Endpoint{AgentPascal}{EndpointPascal}(Id|Arn)Output{Hash}
+ * The Agent{PascalName} prefix comes from the AgentEnvironment construct in the CDK tree.
+ */
+export function parseRuntimeEndpointOutputs(
+  outputs: StackOutputs,
+  endpointSpecs: { agentName: string; endpointName: string }[]
+): Record<string, RuntimeEndpointDeployedState> {
+  const endpoints: Record<string, RuntimeEndpointDeployedState> = {};
+  const outputKeys = Object.keys(outputs);
+
+  for (const { agentName, endpointName } of endpointSpecs) {
+    const agentPascal = toPascalId(agentName);
+    const endpointPascal = toPascalId('Endpoint', agentName, endpointName);
+    const idPrefix = `ApplicationAgent${agentPascal}${endpointPascal}IdOutput`;
+    const arnPrefix = `ApplicationAgent${agentPascal}${endpointPascal}ArnOutput`;
+
+    const idKey = outputKeys.find(k => k.startsWith(idPrefix));
+    const arnKey = outputKeys.find(k => k.startsWith(arnPrefix));
+
+    if (idKey && arnKey) {
+      const key = `${agentName}/${endpointName}`;
+      endpoints[key] = {
+        endpointId: outputs[idKey]!,
+        endpointArn: outputs[arnKey]!,
+      };
+    }
+  }
+
+  return endpoints;
+}
+
 export interface BuildDeployedStateOptions {
   targetName: string;
   stackName: string;
@@ -351,6 +386,7 @@ export interface BuildDeployedStateOptions {
   onlineEvalConfigs?: Record<string, OnlineEvalDeployedState>;
   policyEngines?: Record<string, PolicyEngineDeployedState>;
   policies?: Record<string, PolicyDeployedState>;
+  runtimeEndpoints?: Record<string, RuntimeEndpointDeployedState>;
 }
 
 /**
@@ -370,6 +406,7 @@ export function buildDeployedState(opts: BuildDeployedStateOptions): DeployedSta
     onlineEvalConfigs,
     policyEngines,
     policies,
+    runtimeEndpoints,
   } = opts;
   const targetState: TargetDeployedState = {
     resources: {
@@ -404,6 +441,11 @@ export function buildDeployedState(opts: BuildDeployedStateOptions): DeployedSta
     targetState.resources!.onlineEvalConfigs = onlineEvalConfigs;
   }
 
+  // Add runtime endpoint state if endpoints exist
+  if (runtimeEndpoints && Object.keys(runtimeEndpoints).length > 0) {
+    targetState.resources!.runtimeEndpoints = runtimeEndpoints;
+  }
+
   return {
     targets: {
       ...existingState?.targets,

src/cli/commands/deploy/actions.ts

@@ -13,6 +13,7 @@ import {
   parseOnlineEvalOutputs,
   parsePolicyEngineOutputs,
   parsePolicyOutputs,
+  parseRuntimeEndpointOutputs,
 } from '../../cloudformation';
 import { getErrorMessage } from '../../errors';
 import { ExecLogger } from '../../logging';
@@ -403,6 +404,17 @@ export async function handleDeploy(options: ValidatedDeployOptions): Promise<Dep
     );
     const policies = parsePolicyOutputs(outputs, policySpecs);
 
+    // Parse runtime endpoint outputs
+    const endpointSpecs: { agentName: string; endpointName: string }[] = [];
+    for (const runtime of context.projectSpec.runtimes) {
+      if (runtime.endpoints) {
+        for (const endpointName of Object.keys(runtime.endpoints)) {
+          endpointSpecs.push({ agentName: runtime.name, endpointName });
+        }
+      }
+    }
+    const runtimeEndpoints = parseRuntimeEndpointOutputs(outputs, endpointSpecs);
+
     // Parse gateway outputs
     const gatewaySpecs =
       mcpSpec?.agentCoreGateways?.reduce(
@@ -428,6 +440,7 @@ export async function handleDeploy(options: ValidatedDeployOptions): Promise<Dep
       onlineEvalConfigs,
       policyEngines,
       policies,
+      runtimeEndpoints,
     });
     await configIO.writeDeployedState(deployedState);
 

src/cli/commands/remove/types.ts

@@ -2,6 +2,7 @@ export type ResourceType =
   | 'agent'
   | 'gateway'
   | 'gateway-target'
+  | 'runtime-endpoint'
   | 'memory'
   | 'credential'
   | 'evaluator'

src/cli/commands/status/action.ts

@@ -18,11 +18,13 @@ export interface ResourceStatusEntry {
     | 'evaluator'
     | 'online-eval'
     | 'policy-engine'
-    | 'policy';
+    | 'policy'
+    | 'runtime-endpoint';
   name: string;
   deploymentState: ResourceDeploymentState;
   identifier?: string;
   detail?: string;
+  parentName?: string;
   error?: string;
   invocationUrl?: string;
 }
@@ -79,13 +81,15 @@ function diffResourceSet<TLocal extends { name: string }, TDeployed>({
   getIdentifier,
   getLocalDetail,
   getDeployedKey,
+  getParentName,
 }: {
   resourceType: ResourceStatusEntry['resourceType'];
   localItems: TLocal[];
   deployedRecord: Record<string, TDeployed>;
   getIdentifier: (deployed: TDeployed) => string | undefined;
   getLocalDetail?: (item: TLocal) => string | undefined;
   getDeployedKey?: (item: TLocal) => string;
+  getParentName?: (item: TLocal) => string | undefined;
 }): ResourceStatusEntry[] {
   const entries: ResourceStatusEntry[] = [];
   const localKeys = new Set(localItems.map(item => (getDeployedKey ? getDeployedKey(item) : item.name)));
@@ -99,16 +103,20 @@ function diffResourceSet<TLocal extends { name: string }, TDeployed>({
       deploymentState: deployed ? 'deployed' : 'local-only',
       identifier: deployed ? getIdentifier(deployed) : undefined,
       detail: getLocalDetail?.(item),
+      parentName: getParentName?.(item),
     });
   }
 
   for (const [name, deployed] of Object.entries(deployedRecord)) {
     if (!localKeys.has(name)) {
+      // For pending-removal entries, try to extract parentName from composite key
+      const slashIdx = name.indexOf('/');
       entries.push({
         resourceType,
         name,
         deploymentState: 'pending-removal',
         identifier: getIdentifier(deployed),
+        parentName: getParentName && slashIdx > 0 ? name.substring(0, slashIdx) : undefined,
       });
     }
   }
@@ -202,8 +210,34 @@ export function computeResourceStatuses(
     getDeployedKey: item => `${item.engineName}/${item.name}`,
   });
 
+  // Flatten runtime endpoints for diffing against deployed state
+  const localEndpoints: { name: string; agentName: string; version: number; description?: string }[] = [];
+  for (const runtime of project.runtimes) {
+    if (runtime.endpoints) {
+      for (const [epName, ep] of Object.entries(runtime.endpoints)) {
+        localEndpoints.push({
+          name: epName,
+          agentName: runtime.name,
+          version: ep.version,
+          description: ep.description,
+        });
+      }
+    }
+  }
+
+  const runtimeEndpoints = diffResourceSet({
+    resourceType: 'runtime-endpoint',
+    localItems: localEndpoints,
+    deployedRecord: resources?.runtimeEndpoints ?? {},
+    getIdentifier: deployed => deployed.endpointArn,
+    getLocalDetail: item => `v${item.version}${item.description ? ` — ${item.description}` : ''}`,
+    getDeployedKey: item => `${item.agentName}/${item.name}`,
+    getParentName: item => item.agentName,
+  });
+
   return [
     ...agents,
+    ...runtimeEndpoints,
     ...credentials,
     ...memories,
     ...gateways,

src/cli/commands/status/command.tsx

@@ -9,6 +9,7 @@
 
 const VALID_RESOURCE_TYPES = [
   'agent',
+  'runtime-endpoint',
   'memory',
   'credential',
   'gateway',
@@ -58,7 +59,7 @@
     .option('--target <name>', 'Select deployment target')
     .option(
       '--type <type>',
-      'Filter by resource type (agent, memory, credential, gateway, evaluator, online-eval, policy-engine, policy)'
+      'Filter by resource type (agent, runtime-endpoint, memory, credential, gateway, evaluator, online-eval, policy-engine, policy)'
     )
     .option('--state <state>', 'Filter by deployment state (deployed, local-only, pending-removal)')
     .option('--runtime <name>', 'Filter to a specific runtime')
@@ -135,6 +136,7 @@
 
         const filtered = filterResources(result.resources, cliOptions);
         const agents = filtered.filter(r => r.resourceType === 'agent');
+        const runtimeEndpoints = filtered.filter(r => r.resourceType === 'runtime-endpoint');
         const credentials = filtered.filter(r => r.resourceType === 'credential');
         const memories = filtered.filter(r => r.resourceType === 'memory');
         const gateways = filtered.filter(r => r.resourceType === 'gateway');
@@ -153,15 +155,41 @@
             {agents.length > 0 && (
               <Box flexDirection="column" marginTop={1}>
                 <Text bold>Agents</Text>
-                {agents.map(entry => (
-                  <Box key={`${entry.resourceType}-${entry.name}`} flexDirection="column">
-                    <ResourceEntry entry={entry} showRuntime />
-                    {entry.invocationUrl && (
-                      <Text dimColor>
-                        {'  '}URL: {entry.invocationUrl}
-                      </Text>
-                    )}
-                  </Box>
+                {agents.map(entry => {
+                  // Find endpoints belonging to this agent
+                  const agentEndpoints = runtimeEndpoints.filter(ep => ep.parentName === entry.name);
+                  return (
+                    <Box key={`${entry.resourceType}-${entry.name}`} flexDirection="column">
+                      <ResourceEntry entry={entry} showRuntime />
+                      {entry.invocationUrl && (
+                        <Text dimColor>
+                          {'  '}URL: {entry.invocationUrl}
+                        </Text>
+                      )}
+                      {agentEndpoints.map(ep => (
+                        <Text key={`${ep.parentName}/${ep.name}`}>
+                          {'    '}◉ {ep.name} <Text dimColor>{ep.detail}</Text>{' '}
+                          <Text color={DEPLOYMENT_STATE_COLORS[ep.deploymentState] ?? 'gray'}>
+                            [{DEPLOYMENT_STATE_LABELS[ep.deploymentState] ?? ep.deploymentState}]
+                          </Text>
+                        </Text>
+                      ))}
+                    </Box>
+                  );
+                })}
+              </Box>
+            )}
+
+            {agents.length === 0 && runtimeEndpoints.length > 0 && (
+              <Box flexDirection="column" marginTop={1}>
+                <Text bold>Runtime Endpoints</Text>
+                {runtimeEndpoints.map(ep => (
+                  <Text key={`${ep.parentName}/${ep.name}`}>
+                    {'  '}◉ {ep.parentName}/{ep.name} <Text dimColor>{ep.detail}</Text>{' '}
+                    <Text color={DEPLOYMENT_STATE_COLORS[ep.deploymentState] ?? 'gray'}>
+                      [{DEPLOYMENT_STATE_LABELS[ep.deploymentState] ?? ep.deploymentState}]
+                    </Text>
+                  </Text>
                 ))}
               </Box>
             )}
@@ -239,7 +267,7 @@
     });
 };
 
 function ResourceEntry({ entry, showRuntime }: { entry: ResourceStatusEntry; showRuntime?: boolean }) {
   return (
     <Text>
       {'  '}

src/cli/logging/remove-logger.ts

@@ -13,6 +13,7 @@ export interface RemoveLoggerOptions {
     | 'credential'
     | 'gateway'
     | 'gateway-target'
+    | 'runtime-endpoint'
     | 'evaluator'
     | 'online-eval'
     | 'policy-engine'