feat(project): add project add memory

[notgitika]

This PR adds agentcore project add memory, which validates and appends a memory resource to spec.memories in agentcore.json. Memory resources do not scaffold any application files and are deployed through the generated CDK application.

Example:

 agentcore project add memory \
--name UserFacts \
--strategies SEMANTIC,EPISODIC

To maintain parity with the xisting CLI functionality, while also adding more configurability and customization, --strategies supports 2 input types:

• Comma-separated managed strategy types using default namespaces
• The memory's strategies array as JSON, exactly as it is stored in agentcore.json, for explicit names, descriptions, and namespaces (there is a parameter help in --help for ease of understanding for the user). It is parsed with the project schema's own MemoryStrategySchema, so the flag cannot drift from the schema.

The command also supports expiry duration, indexed keys, stream delivery, encryption and execution roles, descriptions, and tags (description is a new optional field. Here is the CDK PR for it https://github.com/aws/agentcore-l3-cdk-constructs/pull/325 )

Callouts:

• CUSTOM strategies are not supported because their extraction configuration cannot yet be represented by the project schema.

Validation

I tested it myself e2e with different combinations, flags, strategy conversions and validation failures. It all works well. I also tested it with agetncore project build

TODO: check compatibility with harness resource

[codecov-commenter]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 97.27%. Comparing base (b75e1c6) to head (da37fed).

Additional details and impacted files

@@ Coverage Diff @@## refactor #2025 +/- ##
============================================
+ Coverage 97.25% 97.27% +0.01% 
============================================
Files 397 398 +1 Lines 24127 24284 +157 ============================================
+ Hits 23465 23622 +157 
Misses 662 662 

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[notgitika]

My agent ran focused testing for project add memory after the latest validation changes:

• 122 focused project tests pass, plus build/typecheck/lint/format
• Rebuilt CLI verified valid JSON persistence and atomic rejection for the new edge cases
• Covered strategy unions, unsupported fields, indexed keys, stream delivery, tags, malformed JSON, and boundary inputs
• Live AWS lifecycles passed for minimal memory, all four managed strategies, and Kinesis stream delivery (CREATE_COMPLETE followed by cleanup)
• Confirmed no test stacks, memories, or streams remain

The testing surfaced and we fixed empty shorthand entries, recursive unsupported-field stripping (including __proto__), missing JSON strategy names, and the JSON-object diagnostic. The remaining long default strategy-name boundary is in the existing project schema/CDK naming layer rather than this handler.

[nborges-aws]

LGTM thanks for updates!

[jariy17]

Why didn't we use zod.strictObject

[notgitika]

good suggestion!

[jariy17]

I feel like there is a lot going on here just for parse and converting strategy inputs. Maybe we should create an adapter like this

xport interface MemoryStrategyAdapter<TInput = unknown> {
readonly type: MemoryStrategyType;
readonly memberKey: string;
readonly inputSchema: z.ZodType<TInput>;
fromInput(input: TInput): MemoryStrategy;
toInput(strategy: MemoryStrategy): TInput;
fromShorthand?(): MemoryStrategy;
canUseShorthand(strategy: MemoryStrategy): boolean;
}
The codec indexes registered adapters:
export class MemoryStrategyFlagCodec {
private readonly byType: Map<string, MemoryStrategyAdapter>;
private readonly byMember: Map<string, MemoryStrategyAdapter>;
constructor(adapters: readonly MemoryStrategyAdapter[]) {
this.byType = new Map(
adapters.map((adapter) => [adapter.type, adapter]),
);
this.byMember = new Map(
adapters.map((adapter) => [adapter.memberKey, adapter]),
);
}
parse(raw: string): MemoryStrategy[] {
return raw.trimStart().startsWith("[")
? this.parseJson(raw)
: this.parseShorthand(raw);
}
toFlag(strategies: readonly MemoryStrategy[]): string {
const adapters = strategies.map((strategy) => {
const adapter = this.byType.get(strategy.type);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy '${strategy.type}'`,
);
}
return adapter;
});
if (
strategies.every((strategy, index) =>
adapters[index].canUseShorthand(strategy),
)
) {
return strategies.map((strategy) => strategy.type).join(",");
}
return JSON.stringify(
strategies.map((strategy, index) => {
const adapter = adapters[index];
return {
[adapter.memberKey]: adapter.toInput(strategy),
};
}),
);
}
private parseShorthand(raw: string): MemoryStrategy[] {
return raw.split(",").map((value) => {
const type = value.trim();
const adapter = this.byType.get(type);
if (!adapter?.fromShorthand) {
throw new InputValidationError(
`Unsupported shorthand strategy '${type}'`,
);
}
return adapter.fromShorthand();
});
}
private parseJson(raw: string): MemoryStrategy[] {
const inputs = JSON.parse(raw) as unknown[];
return inputs.map((input) => this.parseJsonMember(input));
}
private parseJsonMember(input: unknown): MemoryStrategy {
// Validate that input is an object containing exactly one member.
const [memberKey] = Object.keys(input as object);
const adapter = this.byMember.get(memberKey);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy member '${memberKey}'`,
);
}
const value = adapter.inputSchema.parse(
(input as Record<string, unknown>)[memberKey],
);
return adapter.fromInput(value);
}
}
Registration is centralized:
const strategyCodec = new MemoryStrategyFlagCodec([
new StandardStrategyAdapter("SEMANTIC", "semanticMemoryStrategy"),
new StandardStrategyAdapter(
"SUMMARIZATION",
"summaryMemoryStrategy",
),
new StandardStrategyAdapter(
"USER_PREFERENCE",
"userPreferenceMemoryStrategy",
),
new EpisodicStrategyAdapter(),
]);

[notgitika]

Per @jariy17's ask for a 1-by-1 comparison — every flag is one agentcore.json memory field, and MemorySchema has exactly these 9 fields, so there is no flag without a field and no field without a flag.

flag	memories[] field
--name	name
--description	description
--event-expiry-duration	eventExpiryDuration
--strategies	strategies[]
--indexed-keys	indexedKeys[]
--stream-delivery-resources	streamDeliveryResources
--encryption-key-arn	encryptionKeyArn
--execution-role-arn	executionRoleArn
--tags	tags

One command using all 9 flags:

agentcore project add memory \ --name UserFacts \ --description "Durable facts and preferences for each end user." \ --event-expiry-duration 45 \ --strategies '[{"type":"SEMANTIC","name":"facts","description":"Durable user facts","namespaceTemplates":["/users/{actorId}/facts"]},{"type":"EPISODIC","name":"episodes","namespaceTemplates":["/episodes/{actorId}/{sessionId}"],"reflectionNamespaceTemplates":["/episodes/{actorId}"]}]' \ --indexed-keys '[{"key":"tenant","type":"STRING"}]' \ --stream-delivery-resources '{"resources":[{"kinesis":{"dataStreamArn":"arn:aws:kinesis:us-east-1:123456789012:stream/memory","contentConfigurations":[{"type":"MEMORY_RECORDS","level":"FULL_CONTENT"}]}}]}' \ --encryption-key-arn arn:aws:kms:us-east-1:123456789012:key/abc \ --execution-role-arn arn:aws:iam::123456789012:role/MyMemoryRole \ --tags '{"team":"ml"}'

The resulting memories[0], verbatim from the written agentcore.json:

{
"name": "UserFacts",
"description": "Durable facts and preferences for each end user.",
"eventExpiryDuration": 45,
"strategies": [
{
"type": "SEMANTIC",
"name": "facts",
"description": "Durable user facts",
"namespaceTemplates": ["/users/{actorId}/facts"]
},
{
"type": "EPISODIC",
"name": "episodes",
"namespaceTemplates": ["/episodes/{actorId}/{sessionId}"],
"reflectionNamespaceTemplates": ["/episodes/{actorId}"]
}
],
"indexedKeys": [{ "key": "tenant", "type": "STRING" }],
"tags": { "team": "ml" },
"encryptionKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abc",
"executionRoleArn": "arn:aws:iam::123456789012:role/MyMemoryRole",
"streamDeliveryResources": {
"resources": [
{
"kinesis": {
"dataStreamArn": "arn:aws:kinesis:us-east-1:123456789012:stream/memory",
"contentConfigurations": [{ "type": "MEMORY_RECORDS", "level": "FULL_CONTENT" }]
}
}
]
}
}

The --strategies JSON above is the strategies array as stored, character for character — da37fedf drops the flag's own copy of that schema and parses with the project schema's MemoryStrategySchema itself (wrapped only to report unsupported fields), so type/name/description/namespaceTemplates/reflectionNamespaceTemplates and all of the schema's cross-field rules come from one place and can't drift. --strategies SEMANTIC,EPISODIC remains as the shorthand that fills in the default namespaces.

[jariy17]

This should use SourceResolver.

[jariy17]

shift maps into handler. could be a follow up.

[nborges-aws]

LGTM. Agree with TJs latest comments for a follow up

[jariy17]

Follow Up PR

[jariy17]

Please use SourceResolver in follow up PR

[jariy17]

Shift templates to here because its not part of the schema type.

[notgitika]

This PR adds agentcore project add memory, which validates and appends a memory resource to spec.memories in agentcore.json. Memory resources do not scaffold any application files and are deployed through the generated CDK application.

Example:

 agentcore project add memory \
--name UserFacts \
--strategies SEMANTIC,EPISODIC

To maintain parity with the xisting CLI functionality, while also adding more configurability and customization, --strategies supports 2 input types:

• Comma-separated managed strategy types using default namespaces
• The memory's strategies array as JSON, exactly as it is stored in agentcore.json, for explicit names, descriptions, and namespaces (there is a parameter help in --help for ease of understanding for the user). It is parsed with the project schema's own MemoryStrategySchema, so the flag cannot drift from the schema.

The command also supports expiry duration, indexed keys, stream delivery, encryption and execution roles, descriptions, and tags (description is a new optional field. Here is the CDK PR for it https://github.com/aws/agentcore-l3-cdk-constructs/pull/325 )

Callouts:

• CUSTOM strategies are not supported because their extraction configuration cannot yet be represented by the project schema.

Validation

I tested it myself e2e with different combinations, flags, strategy conversions and validation failures. It all works well. I also tested it with agetncore project build

TODO: check compatibility with harness resource

[codecov-commenter]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 97.27%. Comparing base (b75e1c6) to head (da37fed).

Additional details and impacted files

@@ Coverage Diff @@## refactor #2025 +/- ##
============================================
+ Coverage 97.25% 97.27% +0.01% 
============================================
Files 397 398 +1 Lines 24127 24284 +157 ============================================
+ Hits 23465 23622 +157 
Misses 662 662 

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[notgitika]

My agent ran focused testing for project add memory after the latest validation changes:

• 122 focused project tests pass, plus build/typecheck/lint/format
• Rebuilt CLI verified valid JSON persistence and atomic rejection for the new edge cases
• Covered strategy unions, unsupported fields, indexed keys, stream delivery, tags, malformed JSON, and boundary inputs
• Live AWS lifecycles passed for minimal memory, all four managed strategies, and Kinesis stream delivery (CREATE_COMPLETE followed by cleanup)
• Confirmed no test stacks, memories, or streams remain

The testing surfaced and we fixed empty shorthand entries, recursive unsupported-field stripping (including __proto__), missing JSON strategy names, and the JSON-object diagnostic. The remaining long default strategy-name boundary is in the existing project schema/CDK naming layer rather than this handler.

[nborges-aws]

LGTM thanks for updates!

[jariy17]

Why didn't we use zod.strictObject

[notgitika]

good suggestion!

[jariy17]

I feel like there is a lot going on here just for parse and converting strategy inputs. Maybe we should create an adapter like this

xport interface MemoryStrategyAdapter<TInput = unknown> {
readonly type: MemoryStrategyType;
readonly memberKey: string;
readonly inputSchema: z.ZodType<TInput>;
fromInput(input: TInput): MemoryStrategy;
toInput(strategy: MemoryStrategy): TInput;
fromShorthand?(): MemoryStrategy;
canUseShorthand(strategy: MemoryStrategy): boolean;
}
The codec indexes registered adapters:
export class MemoryStrategyFlagCodec {
private readonly byType: Map<string, MemoryStrategyAdapter>;
private readonly byMember: Map<string, MemoryStrategyAdapter>;
constructor(adapters: readonly MemoryStrategyAdapter[]) {
this.byType = new Map(
adapters.map((adapter) => [adapter.type, adapter]),
);
this.byMember = new Map(
adapters.map((adapter) => [adapter.memberKey, adapter]),
);
}
parse(raw: string): MemoryStrategy[] {
return raw.trimStart().startsWith("[")
? this.parseJson(raw)
: this.parseShorthand(raw);
}
toFlag(strategies: readonly MemoryStrategy[]): string {
const adapters = strategies.map((strategy) => {
const adapter = this.byType.get(strategy.type);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy '${strategy.type}'`,
);
}
return adapter;
});
if (
strategies.every((strategy, index) =>
adapters[index].canUseShorthand(strategy),
)
) {
return strategies.map((strategy) => strategy.type).join(",");
}
return JSON.stringify(
strategies.map((strategy, index) => {
const adapter = adapters[index];
return {
[adapter.memberKey]: adapter.toInput(strategy),
};
}),
);
}
private parseShorthand(raw: string): MemoryStrategy[] {
return raw.split(",").map((value) => {
const type = value.trim();
const adapter = this.byType.get(type);
if (!adapter?.fromShorthand) {
throw new InputValidationError(
`Unsupported shorthand strategy '${type}'`,
);
}
return adapter.fromShorthand();
});
}
private parseJson(raw: string): MemoryStrategy[] {
const inputs = JSON.parse(raw) as unknown[];
return inputs.map((input) => this.parseJsonMember(input));
}
private parseJsonMember(input: unknown): MemoryStrategy {
// Validate that input is an object containing exactly one member.
const [memberKey] = Object.keys(input as object);
const adapter = this.byMember.get(memberKey);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy member '${memberKey}'`,
);
}
const value = adapter.inputSchema.parse(
(input as Record<string, unknown>)[memberKey],
);
return adapter.fromInput(value);
}
}
Registration is centralized:
const strategyCodec = new MemoryStrategyFlagCodec([
new StandardStrategyAdapter("SEMANTIC", "semanticMemoryStrategy"),
new StandardStrategyAdapter(
"SUMMARIZATION",
"summaryMemoryStrategy",
),
new StandardStrategyAdapter(
"USER_PREFERENCE",
"userPreferenceMemoryStrategy",
),
new EpisodicStrategyAdapter(),
]);

[notgitika]

Per @jariy17's ask for a 1-by-1 comparison — every flag is one agentcore.json memory field, and MemorySchema has exactly these 9 fields, so there is no flag without a field and no field without a flag.

flag	memories[] field
--name	name
--description	description
--event-expiry-duration	eventExpiryDuration
--strategies	strategies[]
--indexed-keys	indexedKeys[]
--stream-delivery-resources	streamDeliveryResources
--encryption-key-arn	encryptionKeyArn
--execution-role-arn	executionRoleArn
--tags	tags

One command using all 9 flags:

agentcore project add memory \ --name UserFacts \ --description "Durable facts and preferences for each end user." \ --event-expiry-duration 45 \ --strategies '[{"type":"SEMANTIC","name":"facts","description":"Durable user facts","namespaceTemplates":["/users/{actorId}/facts"]},{"type":"EPISODIC","name":"episodes","namespaceTemplates":["/episodes/{actorId}/{sessionId}"],"reflectionNamespaceTemplates":["/episodes/{actorId}"]}]' \ --indexed-keys '[{"key":"tenant","type":"STRING"}]' \ --stream-delivery-resources '{"resources":[{"kinesis":{"dataStreamArn":"arn:aws:kinesis:us-east-1:123456789012:stream/memory","contentConfigurations":[{"type":"MEMORY_RECORDS","level":"FULL_CONTENT"}]}}]}' \ --encryption-key-arn arn:aws:kms:us-east-1:123456789012:key/abc \ --execution-role-arn arn:aws:iam::123456789012:role/MyMemoryRole \ --tags '{"team":"ml"}'

The resulting memories[0], verbatim from the written agentcore.json:

{
"name": "UserFacts",
"description": "Durable facts and preferences for each end user.",
"eventExpiryDuration": 45,
"strategies": [
{
"type": "SEMANTIC",
"name": "facts",
"description": "Durable user facts",
"namespaceTemplates": ["/users/{actorId}/facts"]
},
{
"type": "EPISODIC",
"name": "episodes",
"namespaceTemplates": ["/episodes/{actorId}/{sessionId}"],
"reflectionNamespaceTemplates": ["/episodes/{actorId}"]
}
],
"indexedKeys": [{ "key": "tenant", "type": "STRING" }],
"tags": { "team": "ml" },
"encryptionKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abc",
"executionRoleArn": "arn:aws:iam::123456789012:role/MyMemoryRole",
"streamDeliveryResources": {
"resources": [
{
"kinesis": {
"dataStreamArn": "arn:aws:kinesis:us-east-1:123456789012:stream/memory",
"contentConfigurations": [{ "type": "MEMORY_RECORDS", "level": "FULL_CONTENT" }]
}
}
]
}
}

The --strategies JSON above is the strategies array as stored, character for character — da37fedf drops the flag's own copy of that schema and parses with the project schema's MemoryStrategySchema itself (wrapped only to report unsupported fields), so type/name/description/namespaceTemplates/reflectionNamespaceTemplates and all of the schema's cross-field rules come from one place and can't drift. --strategies SEMANTIC,EPISODIC remains as the shorthand that fills in the default namespaces.

[jariy17]

This should use SourceResolver.

[jariy17]

shift maps into handler. could be a follow up.

[nborges-aws]

LGTM. Agree with TJs latest comments for a follow up

[jariy17]

Follow Up PR

[jariy17]

Please use SourceResolver in follow up PR

[jariy17]

Shift templates to here because its not part of the schema type.

[notgitika]

This PR adds agentcore project add memory, which validates and appends a memory resource to spec.memories in agentcore.json. Memory resources do not scaffold any application files and are deployed through the generated CDK application.

Example:

 agentcore project add memory \
--name UserFacts \
--strategies SEMANTIC,EPISODIC

To maintain parity with the xisting CLI functionality, while also adding more configurability and customization, --strategies supports 2 input types:

• Comma-separated managed strategy types using default namespaces
• The memory's strategies array as JSON, exactly as it is stored in agentcore.json, for explicit names, descriptions, and namespaces (there is a parameter help in --help for ease of understanding for the user). It is parsed with the project schema's own MemoryStrategySchema, so the flag cannot drift from the schema.

The command also supports expiry duration, indexed keys, stream delivery, encryption and execution roles, descriptions, and tags (description is a new optional field. Here is the CDK PR for it https://github.com/aws/agentcore-l3-cdk-constructs/pull/325 )

Callouts:

• CUSTOM strategies are not supported because their extraction configuration cannot yet be represented by the project schema.

Validation

I tested it myself e2e with different combinations, flags, strategy conversions and validation failures. It all works well. I also tested it with agetncore project build

TODO: check compatibility with harness resource

[codecov-commenter]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 97.27%. Comparing base (b75e1c6) to head (da37fed).

Additional details and impacted files

@@ Coverage Diff @@## refactor #2025 +/- ##
============================================
+ Coverage 97.25% 97.27% +0.01% 
============================================
Files 397 398 +1 Lines 24127 24284 +157 ============================================
+ Hits 23465 23622 +157 
Misses 662 662 

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[notgitika]

My agent ran focused testing for project add memory after the latest validation changes:

• 122 focused project tests pass, plus build/typecheck/lint/format
• Rebuilt CLI verified valid JSON persistence and atomic rejection for the new edge cases
• Covered strategy unions, unsupported fields, indexed keys, stream delivery, tags, malformed JSON, and boundary inputs
• Live AWS lifecycles passed for minimal memory, all four managed strategies, and Kinesis stream delivery (CREATE_COMPLETE followed by cleanup)
• Confirmed no test stacks, memories, or streams remain

The testing surfaced and we fixed empty shorthand entries, recursive unsupported-field stripping (including __proto__), missing JSON strategy names, and the JSON-object diagnostic. The remaining long default strategy-name boundary is in the existing project schema/CDK naming layer rather than this handler.

[nborges-aws]

LGTM thanks for updates!

[jariy17]

Why didn't we use zod.strictObject

[notgitika]

good suggestion!

[jariy17]

I feel like there is a lot going on here just for parse and converting strategy inputs. Maybe we should create an adapter like this

xport interface MemoryStrategyAdapter<TInput = unknown> {
readonly type: MemoryStrategyType;
readonly memberKey: string;
readonly inputSchema: z.ZodType<TInput>;
fromInput(input: TInput): MemoryStrategy;
toInput(strategy: MemoryStrategy): TInput;
fromShorthand?(): MemoryStrategy;
canUseShorthand(strategy: MemoryStrategy): boolean;
}
The codec indexes registered adapters:
export class MemoryStrategyFlagCodec {
private readonly byType: Map<string, MemoryStrategyAdapter>;
private readonly byMember: Map<string, MemoryStrategyAdapter>;
constructor(adapters: readonly MemoryStrategyAdapter[]) {
this.byType = new Map(
adapters.map((adapter) => [adapter.type, adapter]),
);
this.byMember = new Map(
adapters.map((adapter) => [adapter.memberKey, adapter]),
);
}
parse(raw: string): MemoryStrategy[] {
return raw.trimStart().startsWith("[")
? this.parseJson(raw)
: this.parseShorthand(raw);
}
toFlag(strategies: readonly MemoryStrategy[]): string {
const adapters = strategies.map((strategy) => {
const adapter = this.byType.get(strategy.type);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy '${strategy.type}'`,
);
}
return adapter;
});
if (
strategies.every((strategy, index) =>
adapters[index].canUseShorthand(strategy),
)
) {
return strategies.map((strategy) => strategy.type).join(",");
}
return JSON.stringify(
strategies.map((strategy, index) => {
const adapter = adapters[index];
return {
[adapter.memberKey]: adapter.toInput(strategy),
};
}),
);
}
private parseShorthand(raw: string): MemoryStrategy[] {
return raw.split(",").map((value) => {
const type = value.trim();
const adapter = this.byType.get(type);
if (!adapter?.fromShorthand) {
throw new InputValidationError(
`Unsupported shorthand strategy '${type}'`,
);
}
return adapter.fromShorthand();
});
}
private parseJson(raw: string): MemoryStrategy[] {
const inputs = JSON.parse(raw) as unknown[];
return inputs.map((input) => this.parseJsonMember(input));
}
private parseJsonMember(input: unknown): MemoryStrategy {
// Validate that input is an object containing exactly one member.
const [memberKey] = Object.keys(input as object);
const adapter = this.byMember.get(memberKey);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy member '${memberKey}'`,
);
}
const value = adapter.inputSchema.parse(
(input as Record<string, unknown>)[memberKey],
);
return adapter.fromInput(value);
}
}
Registration is centralized:
const strategyCodec = new MemoryStrategyFlagCodec([
new StandardStrategyAdapter("SEMANTIC", "semanticMemoryStrategy"),
new StandardStrategyAdapter(
"SUMMARIZATION",
"summaryMemoryStrategy",
),
new StandardStrategyAdapter(
"USER_PREFERENCE",
"userPreferenceMemoryStrategy",
),
new EpisodicStrategyAdapter(),
]);

[notgitika]

Per @jariy17's ask for a 1-by-1 comparison — every flag is one agentcore.json memory field, and MemorySchema has exactly these 9 fields, so there is no flag without a field and no field without a flag.

flag	memories[] field
--name	name
--description	description
--event-expiry-duration	eventExpiryDuration
--strategies	strategies[]
--indexed-keys	indexedKeys[]
--stream-delivery-resources	streamDeliveryResources
--encryption-key-arn	encryptionKeyArn
--execution-role-arn	executionRoleArn
--tags	tags

One command using all 9 flags:

agentcore project add memory \ --name UserFacts \ --description "Durable facts and preferences for each end user." \ --event-expiry-duration 45 \ --strategies '[{"type":"SEMANTIC","name":"facts","description":"Durable user facts","namespaceTemplates":["/users/{actorId}/facts"]},{"type":"EPISODIC","name":"episodes","namespaceTemplates":["/episodes/{actorId}/{sessionId}"],"reflectionNamespaceTemplates":["/episodes/{actorId}"]}]' \ --indexed-keys '[{"key":"tenant","type":"STRING"}]' \ --stream-delivery-resources '{"resources":[{"kinesis":{"dataStreamArn":"arn:aws:kinesis:us-east-1:123456789012:stream/memory","contentConfigurations":[{"type":"MEMORY_RECORDS","level":"FULL_CONTENT"}]}}]}' \ --encryption-key-arn arn:aws:kms:us-east-1:123456789012:key/abc \ --execution-role-arn arn:aws:iam::123456789012:role/MyMemoryRole \ --tags '{"team":"ml"}'

The resulting memories[0], verbatim from the written agentcore.json:

{
"name": "UserFacts",
"description": "Durable facts and preferences for each end user.",
"eventExpiryDuration": 45,
"strategies": [
{
"type": "SEMANTIC",
"name": "facts",
"description": "Durable user facts",
"namespaceTemplates": ["/users/{actorId}/facts"]
},
{
"type": "EPISODIC",
"name": "episodes",
"namespaceTemplates": ["/episodes/{actorId}/{sessionId}"],
"reflectionNamespaceTemplates": ["/episodes/{actorId}"]
}
],
"indexedKeys": [{ "key": "tenant", "type": "STRING" }],
"tags": { "team": "ml" },
"encryptionKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abc",
"executionRoleArn": "arn:aws:iam::123456789012:role/MyMemoryRole",
"streamDeliveryResources": {
"resources": [
{
"kinesis": {
"dataStreamArn": "arn:aws:kinesis:us-east-1:123456789012:stream/memory",
"contentConfigurations": [{ "type": "MEMORY_RECORDS", "level": "FULL_CONTENT" }]
}
}
]
}
}

The --strategies JSON above is the strategies array as stored, character for character — da37fedf drops the flag's own copy of that schema and parses with the project schema's MemoryStrategySchema itself (wrapped only to report unsupported fields), so type/name/description/namespaceTemplates/reflectionNamespaceTemplates and all of the schema's cross-field rules come from one place and can't drift. --strategies SEMANTIC,EPISODIC remains as the shorthand that fills in the default namespaces.

[jariy17]

This should use SourceResolver.

[jariy17]

shift maps into handler. could be a follow up.

[nborges-aws]

LGTM. Agree with TJs latest comments for a follow up

[jariy17]

Follow Up PR

[jariy17]

Please use SourceResolver in follow up PR

[jariy17]

Shift templates to here because its not part of the schema type.

[notgitika]

This PR adds agentcore project add memory, which validates and appends a memory resource to spec.memories in agentcore.json. Memory resources do not scaffold any application files and are deployed through the generated CDK application.

Example:

 agentcore project add memory \
--name UserFacts \
--strategies SEMANTIC,EPISODIC

To maintain parity with the xisting CLI functionality, while also adding more configurability and customization, --strategies supports 2 input types:

• Comma-separated managed strategy types using default namespaces
• The memory's strategies array as JSON, exactly as it is stored in agentcore.json, for explicit names, descriptions, and namespaces (there is a parameter help in --help for ease of understanding for the user). It is parsed with the project schema's own MemoryStrategySchema, so the flag cannot drift from the schema.

The command also supports expiry duration, indexed keys, stream delivery, encryption and execution roles, descriptions, and tags (description is a new optional field. Here is the CDK PR for it https://github.com/aws/agentcore-l3-cdk-constructs/pull/325 )

Callouts:

• CUSTOM strategies are not supported because their extraction configuration cannot yet be represented by the project schema.

Validation

I tested it myself e2e with different combinations, flags, strategy conversions and validation failures. It all works well. I also tested it with agetncore project build

TODO: check compatibility with harness resource

[codecov-commenter]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 97.27%. Comparing base (b75e1c6) to head (da37fed).

Additional details and impacted files

@@ Coverage Diff @@## refactor #2025 +/- ##
============================================
+ Coverage 97.25% 97.27% +0.01% 
============================================
Files 397 398 +1 Lines 24127 24284 +157 ============================================
+ Hits 23465 23622 +157 
Misses 662 662 

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[notgitika]

My agent ran focused testing for project add memory after the latest validation changes:

• 122 focused project tests pass, plus build/typecheck/lint/format
• Rebuilt CLI verified valid JSON persistence and atomic rejection for the new edge cases
• Covered strategy unions, unsupported fields, indexed keys, stream delivery, tags, malformed JSON, and boundary inputs
• Live AWS lifecycles passed for minimal memory, all four managed strategies, and Kinesis stream delivery (CREATE_COMPLETE followed by cleanup)
• Confirmed no test stacks, memories, or streams remain

The testing surfaced and we fixed empty shorthand entries, recursive unsupported-field stripping (including __proto__), missing JSON strategy names, and the JSON-object diagnostic. The remaining long default strategy-name boundary is in the existing project schema/CDK naming layer rather than this handler.

[nborges-aws]

LGTM thanks for updates!

[jariy17]

Why didn't we use zod.strictObject

[notgitika]

good suggestion!

[jariy17]

I feel like there is a lot going on here just for parse and converting strategy inputs. Maybe we should create an adapter like this

xport interface MemoryStrategyAdapter<TInput = unknown> {
readonly type: MemoryStrategyType;
readonly memberKey: string;
readonly inputSchema: z.ZodType<TInput>;
fromInput(input: TInput): MemoryStrategy;
toInput(strategy: MemoryStrategy): TInput;
fromShorthand?(): MemoryStrategy;
canUseShorthand(strategy: MemoryStrategy): boolean;
}
The codec indexes registered adapters:
export class MemoryStrategyFlagCodec {
private readonly byType: Map<string, MemoryStrategyAdapter>;
private readonly byMember: Map<string, MemoryStrategyAdapter>;
constructor(adapters: readonly MemoryStrategyAdapter[]) {
this.byType = new Map(
adapters.map((adapter) => [adapter.type, adapter]),
);
this.byMember = new Map(
adapters.map((adapter) => [adapter.memberKey, adapter]),
);
}
parse(raw: string): MemoryStrategy[] {
return raw.trimStart().startsWith("[")
? this.parseJson(raw)
: this.parseShorthand(raw);
}
toFlag(strategies: readonly MemoryStrategy[]): string {
const adapters = strategies.map((strategy) => {
const adapter = this.byType.get(strategy.type);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy '${strategy.type}'`,
);
}
return adapter;
});
if (
strategies.every((strategy, index) =>
adapters[index].canUseShorthand(strategy),
)
) {
return strategies.map((strategy) => strategy.type).join(",");
}
return JSON.stringify(
strategies.map((strategy, index) => {
const adapter = adapters[index];
return {
[adapter.memberKey]: adapter.toInput(strategy),
};
}),
);
}
private parseShorthand(raw: string): MemoryStrategy[] {
return raw.split(",").map((value) => {
const type = value.trim();
const adapter = this.byType.get(type);
if (!adapter?.fromShorthand) {
throw new InputValidationError(
`Unsupported shorthand strategy '${type}'`,
);
}
return adapter.fromShorthand();
});
}
private parseJson(raw: string): MemoryStrategy[] {
const inputs = JSON.parse(raw) as unknown[];
return inputs.map((input) => this.parseJsonMember(input));
}
private parseJsonMember(input: unknown): MemoryStrategy {
// Validate that input is an object containing exactly one member.
const [memberKey] = Object.keys(input as object);
const adapter = this.byMember.get(memberKey);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy member '${memberKey}'`,
);
}
const value = adapter.inputSchema.parse(
(input as Record<string, unknown>)[memberKey],
);
return adapter.fromInput(value);
}
}
Registration is centralized:
const strategyCodec = new MemoryStrategyFlagCodec([
new StandardStrategyAdapter("SEMANTIC", "semanticMemoryStrategy"),
new StandardStrategyAdapter(
"SUMMARIZATION",
"summaryMemoryStrategy",
),
new StandardStrategyAdapter(
"USER_PREFERENCE",
"userPreferenceMemoryStrategy",
),
new EpisodicStrategyAdapter(),
]);

[notgitika]

Per @jariy17's ask for a 1-by-1 comparison — every flag is one agentcore.json memory field, and MemorySchema has exactly these 9 fields, so there is no flag without a field and no field without a flag.

flag	memories[] field
--name	name
--description	description
--event-expiry-duration	eventExpiryDuration
--strategies	strategies[]
--indexed-keys	indexedKeys[]
--stream-delivery-resources	streamDeliveryResources
--encryption-key-arn	encryptionKeyArn
--execution-role-arn	executionRoleArn
--tags	tags

One command using all 9 flags:

agentcore project add memory \ --name UserFacts \ --description "Durable facts and preferences for each end user." \ --event-expiry-duration 45 \ --strategies '[{"type":"SEMANTIC","name":"facts","description":"Durable user facts","namespaceTemplates":["/users/{actorId}/facts"]},{"type":"EPISODIC","name":"episodes","namespaceTemplates":["/episodes/{actorId}/{sessionId}"],"reflectionNamespaceTemplates":["/episodes/{actorId}"]}]' \ --indexed-keys '[{"key":"tenant","type":"STRING"}]' \ --stream-delivery-resources '{"resources":[{"kinesis":{"dataStreamArn":"arn:aws:kinesis:us-east-1:123456789012:stream/memory","contentConfigurations":[{"type":"MEMORY_RECORDS","level":"FULL_CONTENT"}]}}]}' \ --encryption-key-arn arn:aws:kms:us-east-1:123456789012:key/abc \ --execution-role-arn arn:aws:iam::123456789012:role/MyMemoryRole \ --tags '{"team":"ml"}'

The resulting memories[0], verbatim from the written agentcore.json:

{
"name": "UserFacts",
"description": "Durable facts and preferences for each end user.",
"eventExpiryDuration": 45,
"strategies": [
{
"type": "SEMANTIC",
"name": "facts",
"description": "Durable user facts",
"namespaceTemplates": ["/users/{actorId}/facts"]
},
{
"type": "EPISODIC",
"name": "episodes",
"namespaceTemplates": ["/episodes/{actorId}/{sessionId}"],
"reflectionNamespaceTemplates": ["/episodes/{actorId}"]
}
],
"indexedKeys": [{ "key": "tenant", "type": "STRING" }],
"tags": { "team": "ml" },
"encryptionKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abc",
"executionRoleArn": "arn:aws:iam::123456789012:role/MyMemoryRole",
"streamDeliveryResources": {
"resources": [
{
"kinesis": {
"dataStreamArn": "arn:aws:kinesis:us-east-1:123456789012:stream/memory",
"contentConfigurations": [{ "type": "MEMORY_RECORDS", "level": "FULL_CONTENT" }]
}
}
]
}
}

The --strategies JSON above is the strategies array as stored, character for character — da37fedf drops the flag's own copy of that schema and parses with the project schema's MemoryStrategySchema itself (wrapped only to report unsupported fields), so type/name/description/namespaceTemplates/reflectionNamespaceTemplates and all of the schema's cross-field rules come from one place and can't drift. --strategies SEMANTIC,EPISODIC remains as the shorthand that fills in the default namespaces.

[jariy17]

This should use SourceResolver.

[jariy17]

shift maps into handler. could be a follow up.

[nborges-aws]

LGTM. Agree with TJs latest comments for a follow up

[jariy17]

Follow Up PR

[jariy17]

Please use SourceResolver in follow up PR

[jariy17]

Shift templates to here because its not part of the schema type.

[notgitika]

This PR adds agentcore project add memory, which validates and appends a memory resource to spec.memories in agentcore.json. Memory resources do not scaffold any application files and are deployed through the generated CDK application.

Example:

 agentcore project add memory \
--name UserFacts \
--strategies SEMANTIC,EPISODIC

To maintain parity with the xisting CLI functionality, while also adding more configurability and customization, --strategies supports 2 input types:

• Comma-separated managed strategy types using default namespaces
• The memory's strategies array as JSON, exactly as it is stored in agentcore.json, for explicit names, descriptions, and namespaces (there is a parameter help in --help for ease of understanding for the user). It is parsed with the project schema's own MemoryStrategySchema, so the flag cannot drift from the schema.

The command also supports expiry duration, indexed keys, stream delivery, encryption and execution roles, descriptions, and tags (description is a new optional field. Here is the CDK PR for it https://github.com/aws/agentcore-l3-cdk-constructs/pull/325 )

Callouts:

• CUSTOM strategies are not supported because their extraction configuration cannot yet be represented by the project schema.

Validation

I tested it myself e2e with different combinations, flags, strategy conversions and validation failures. It all works well. I also tested it with agetncore project build

TODO: check compatibility with harness resource

[codecov-commenter]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 97.27%. Comparing base (b75e1c6) to head (da37fed).

Additional details and impacted files

@@ Coverage Diff @@## refactor #2025 +/- ##
============================================
+ Coverage 97.25% 97.27% +0.01% 
============================================
Files 397 398 +1 Lines 24127 24284 +157 ============================================
+ Hits 23465 23622 +157 
Misses 662 662 

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[notgitika]

My agent ran focused testing for project add memory after the latest validation changes:

• 122 focused project tests pass, plus build/typecheck/lint/format
• Rebuilt CLI verified valid JSON persistence and atomic rejection for the new edge cases
• Covered strategy unions, unsupported fields, indexed keys, stream delivery, tags, malformed JSON, and boundary inputs
• Live AWS lifecycles passed for minimal memory, all four managed strategies, and Kinesis stream delivery (CREATE_COMPLETE followed by cleanup)
• Confirmed no test stacks, memories, or streams remain

The testing surfaced and we fixed empty shorthand entries, recursive unsupported-field stripping (including __proto__), missing JSON strategy names, and the JSON-object diagnostic. The remaining long default strategy-name boundary is in the existing project schema/CDK naming layer rather than this handler.

[nborges-aws]

LGTM thanks for updates!

[jariy17]

Why didn't we use zod.strictObject

[notgitika]

good suggestion!

[jariy17]

I feel like there is a lot going on here just for parse and converting strategy inputs. Maybe we should create an adapter like this

xport interface MemoryStrategyAdapter<TInput = unknown> {
readonly type: MemoryStrategyType;
readonly memberKey: string;
readonly inputSchema: z.ZodType<TInput>;
fromInput(input: TInput): MemoryStrategy;
toInput(strategy: MemoryStrategy): TInput;
fromShorthand?(): MemoryStrategy;
canUseShorthand(strategy: MemoryStrategy): boolean;
}
The codec indexes registered adapters:
export class MemoryStrategyFlagCodec {
private readonly byType: Map<string, MemoryStrategyAdapter>;
private readonly byMember: Map<string, MemoryStrategyAdapter>;
constructor(adapters: readonly MemoryStrategyAdapter[]) {
this.byType = new Map(
adapters.map((adapter) => [adapter.type, adapter]),
);
this.byMember = new Map(
adapters.map((adapter) => [adapter.memberKey, adapter]),
);
}
parse(raw: string): MemoryStrategy[] {
return raw.trimStart().startsWith("[")
? this.parseJson(raw)
: this.parseShorthand(raw);
}
toFlag(strategies: readonly MemoryStrategy[]): string {
const adapters = strategies.map((strategy) => {
const adapter = this.byType.get(strategy.type);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy '${strategy.type}'`,
);
}
return adapter;
});
if (
strategies.every((strategy, index) =>
adapters[index].canUseShorthand(strategy),
)
) {
return strategies.map((strategy) => strategy.type).join(",");
}
return JSON.stringify(
strategies.map((strategy, index) => {
const adapter = adapters[index];
return {
[adapter.memberKey]: adapter.toInput(strategy),
};
}),
);
}
private parseShorthand(raw: string): MemoryStrategy[] {
return raw.split(",").map((value) => {
const type = value.trim();
const adapter = this.byType.get(type);
if (!adapter?.fromShorthand) {
throw new InputValidationError(
`Unsupported shorthand strategy '${type}'`,
);
}
return adapter.fromShorthand();
});
}
private parseJson(raw: string): MemoryStrategy[] {
const inputs = JSON.parse(raw) as unknown[];
return inputs.map((input) => this.parseJsonMember(input));
}
private parseJsonMember(input: unknown): MemoryStrategy {
// Validate that input is an object containing exactly one member.
const [memberKey] = Object.keys(input as object);
const adapter = this.byMember.get(memberKey);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy member '${memberKey}'`,
);
}
const value = adapter.inputSchema.parse(
(input as Record<string, unknown>)[memberKey],
);
return adapter.fromInput(value);
}
}
Registration is centralized:
const strategyCodec = new MemoryStrategyFlagCodec([
new StandardStrategyAdapter("SEMANTIC", "semanticMemoryStrategy"),
new StandardStrategyAdapter(
"SUMMARIZATION",
"summaryMemoryStrategy",
),
new StandardStrategyAdapter(
"USER_PREFERENCE",
"userPreferenceMemoryStrategy",
),
new EpisodicStrategyAdapter(),
]);

[notgitika]

Per @jariy17's ask for a 1-by-1 comparison — every flag is one agentcore.json memory field, and MemorySchema has exactly these 9 fields, so there is no flag without a field and no field without a flag.

flag	memories[] field
--name	name
--description	description
--event-expiry-duration	eventExpiryDuration
--strategies	strategies[]
--indexed-keys	indexedKeys[]
--stream-delivery-resources	streamDeliveryResources
--encryption-key-arn	encryptionKeyArn
--execution-role-arn	executionRoleArn
--tags	tags

One command using all 9 flags:

agentcore project add memory \ --name UserFacts \ --description "Durable facts and preferences for each end user." \ --event-expiry-duration 45 \ --strategies '[{"type":"SEMANTIC","name":"facts","description":"Durable user facts","namespaceTemplates":["/users/{actorId}/facts"]},{"type":"EPISODIC","name":"episodes","namespaceTemplates":["/episodes/{actorId}/{sessionId}"],"reflectionNamespaceTemplates":["/episodes/{actorId}"]}]' \ --indexed-keys '[{"key":"tenant","type":"STRING"}]' \ --stream-delivery-resources '{"resources":[{"kinesis":{"dataStreamArn":"arn:aws:kinesis:us-east-1:123456789012:stream/memory","contentConfigurations":[{"type":"MEMORY_RECORDS","level":"FULL_CONTENT"}]}}]}' \ --encryption-key-arn arn:aws:kms:us-east-1:123456789012:key/abc \ --execution-role-arn arn:aws:iam::123456789012:role/MyMemoryRole \ --tags '{"team":"ml"}'

The resulting memories[0], verbatim from the written agentcore.json:

{
"name": "UserFacts",
"description": "Durable facts and preferences for each end user.",
"eventExpiryDuration": 45,
"strategies": [
{
"type": "SEMANTIC",
"name": "facts",
"description": "Durable user facts",
"namespaceTemplates": ["/users/{actorId}/facts"]
},
{
"type": "EPISODIC",
"name": "episodes",
"namespaceTemplates": ["/episodes/{actorId}/{sessionId}"],
"reflectionNamespaceTemplates": ["/episodes/{actorId}"]
}
],
"indexedKeys": [{ "key": "tenant", "type": "STRING" }],
"tags": { "team": "ml" },
"encryptionKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abc",
"executionRoleArn": "arn:aws:iam::123456789012:role/MyMemoryRole",
"streamDeliveryResources": {
"resources": [
{
"kinesis": {
"dataStreamArn": "arn:aws:kinesis:us-east-1:123456789012:stream/memory",
"contentConfigurations": [{ "type": "MEMORY_RECORDS", "level": "FULL_CONTENT" }]
}
}
]
}
}

The --strategies JSON above is the strategies array as stored, character for character — da37fedf drops the flag's own copy of that schema and parses with the project schema's MemoryStrategySchema itself (wrapped only to report unsupported fields), so type/name/description/namespaceTemplates/reflectionNamespaceTemplates and all of the schema's cross-field rules come from one place and can't drift. --strategies SEMANTIC,EPISODIC remains as the shorthand that fills in the default namespaces.

[jariy17]

This should use SourceResolver.

[jariy17]

shift maps into handler. could be a follow up.

[nborges-aws]

LGTM. Agree with TJs latest comments for a follow up

[jariy17]

Follow Up PR

[jariy17]

Please use SourceResolver in follow up PR

[jariy17]

Shift templates to here because its not part of the schema type.

[notgitika]

This PR adds agentcore project add memory, which validates and appends a memory resource to spec.memories in agentcore.json. Memory resources do not scaffold any application files and are deployed through the generated CDK application.

Example:

 agentcore project add memory \
--name UserFacts \
--strategies SEMANTIC,EPISODIC

To maintain parity with the xisting CLI functionality, while also adding more configurability and customization, --strategies supports 2 input types:

• Comma-separated managed strategy types using default namespaces
• The memory's strategies array as JSON, exactly as it is stored in agentcore.json, for explicit names, descriptions, and namespaces (there is a parameter help in --help for ease of understanding for the user). It is parsed with the project schema's own MemoryStrategySchema, so the flag cannot drift from the schema.

The command also supports expiry duration, indexed keys, stream delivery, encryption and execution roles, descriptions, and tags (description is a new optional field. Here is the CDK PR for it https://github.com/aws/agentcore-l3-cdk-constructs/pull/325 )

Callouts:

• CUSTOM strategies are not supported because their extraction configuration cannot yet be represented by the project schema.

Validation

I tested it myself e2e with different combinations, flags, strategy conversions and validation failures. It all works well. I also tested it with agetncore project build

TODO: check compatibility with harness resource

[codecov-commenter]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 97.27%. Comparing base (b75e1c6) to head (da37fed).

Additional details and impacted files

@@ Coverage Diff @@## refactor #2025 +/- ##
============================================
+ Coverage 97.25% 97.27% +0.01% 
============================================
Files 397 398 +1 Lines 24127 24284 +157 ============================================
+ Hits 23465 23622 +157 
Misses 662 662 

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[notgitika]

My agent ran focused testing for project add memory after the latest validation changes:

• 122 focused project tests pass, plus build/typecheck/lint/format
• Rebuilt CLI verified valid JSON persistence and atomic rejection for the new edge cases
• Covered strategy unions, unsupported fields, indexed keys, stream delivery, tags, malformed JSON, and boundary inputs
• Live AWS lifecycles passed for minimal memory, all four managed strategies, and Kinesis stream delivery (CREATE_COMPLETE followed by cleanup)
• Confirmed no test stacks, memories, or streams remain

The testing surfaced and we fixed empty shorthand entries, recursive unsupported-field stripping (including __proto__), missing JSON strategy names, and the JSON-object diagnostic. The remaining long default strategy-name boundary is in the existing project schema/CDK naming layer rather than this handler.

[nborges-aws]

LGTM thanks for updates!

[jariy17]

Why didn't we use zod.strictObject

[notgitika]

good suggestion!

[jariy17]

I feel like there is a lot going on here just for parse and converting strategy inputs. Maybe we should create an adapter like this

xport interface MemoryStrategyAdapter<TInput = unknown> {
readonly type: MemoryStrategyType;
readonly memberKey: string;
readonly inputSchema: z.ZodType<TInput>;
fromInput(input: TInput): MemoryStrategy;
toInput(strategy: MemoryStrategy): TInput;
fromShorthand?(): MemoryStrategy;
canUseShorthand(strategy: MemoryStrategy): boolean;
}
The codec indexes registered adapters:
export class MemoryStrategyFlagCodec {
private readonly byType: Map<string, MemoryStrategyAdapter>;
private readonly byMember: Map<string, MemoryStrategyAdapter>;
constructor(adapters: readonly MemoryStrategyAdapter[]) {
this.byType = new Map(
adapters.map((adapter) => [adapter.type, adapter]),
);
this.byMember = new Map(
adapters.map((adapter) => [adapter.memberKey, adapter]),
);
}
parse(raw: string): MemoryStrategy[] {
return raw.trimStart().startsWith("[")
? this.parseJson(raw)
: this.parseShorthand(raw);
}
toFlag(strategies: readonly MemoryStrategy[]): string {
const adapters = strategies.map((strategy) => {
const adapter = this.byType.get(strategy.type);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy '${strategy.type}'`,
);
}
return adapter;
});
if (
strategies.every((strategy, index) =>
adapters[index].canUseShorthand(strategy),
)
) {
return strategies.map((strategy) => strategy.type).join(",");
}
return JSON.stringify(
strategies.map((strategy, index) => {
const adapter = adapters[index];
return {
[adapter.memberKey]: adapter.toInput(strategy),
};
}),
);
}
private parseShorthand(raw: string): MemoryStrategy[] {
return raw.split(",").map((value) => {
const type = value.trim();
const adapter = this.byType.get(type);
if (!adapter?.fromShorthand) {
throw new InputValidationError(
`Unsupported shorthand strategy '${type}'`,
);
}
return adapter.fromShorthand();
});
}
private parseJson(raw: string): MemoryStrategy[] {
const inputs = JSON.parse(raw) as unknown[];
return inputs.map((input) => this.parseJsonMember(input));
}
private parseJsonMember(input: unknown): MemoryStrategy {
// Validate that input is an object containing exactly one member.
const [memberKey] = Object.keys(input as object);
const adapter = this.byMember.get(memberKey);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy member '${memberKey}'`,
);
}
const value = adapter.inputSchema.parse(
(input as Record<string, unknown>)[memberKey],
);
return adapter.fromInput(value);
}
}
Registration is centralized:
const strategyCodec = new MemoryStrategyFlagCodec([
new StandardStrategyAdapter("SEMANTIC", "semanticMemoryStrategy"),
new StandardStrategyAdapter(
"SUMMARIZATION",
"summaryMemoryStrategy",
),
new StandardStrategyAdapter(
"USER_PREFERENCE",
"userPreferenceMemoryStrategy",
),
new EpisodicStrategyAdapter(),
]);

[notgitika]

Per @jariy17's ask for a 1-by-1 comparison — every flag is one agentcore.json memory field, and MemorySchema has exactly these 9 fields, so there is no flag without a field and no field without a flag.

flag	memories[] field
--name	name
--description	description
--event-expiry-duration	eventExpiryDuration
--strategies	strategies[]
--indexed-keys	indexedKeys[]
--stream-delivery-resources	streamDeliveryResources
--encryption-key-arn	encryptionKeyArn
--execution-role-arn	executionRoleArn
--tags	tags

One command using all 9 flags:

agentcore project add memory \ --name UserFacts \ --description "Durable facts and preferences for each end user." \ --event-expiry-duration 45 \ --strategies '[{"type":"SEMANTIC","name":"facts","description":"Durable user facts","namespaceTemplates":["/users/{actorId}/facts"]},{"type":"EPISODIC","name":"episodes","namespaceTemplates":["/episodes/{actorId}/{sessionId}"],"reflectionNamespaceTemplates":["/episodes/{actorId}"]}]' \ --indexed-keys '[{"key":"tenant","type":"STRING"}]' \ --stream-delivery-resources '{"resources":[{"kinesis":{"dataStreamArn":"arn:aws:kinesis:us-east-1:123456789012:stream/memory","contentConfigurations":[{"type":"MEMORY_RECORDS","level":"FULL_CONTENT"}]}}]}' \ --encryption-key-arn arn:aws:kms:us-east-1:123456789012:key/abc \ --execution-role-arn arn:aws:iam::123456789012:role/MyMemoryRole \ --tags '{"team":"ml"}'

The resulting memories[0], verbatim from the written agentcore.json:

{
"name": "UserFacts",
"description": "Durable facts and preferences for each end user.",
"eventExpiryDuration": 45,
"strategies": [
{
"type": "SEMANTIC",
"name": "facts",
"description": "Durable user facts",
"namespaceTemplates": ["/users/{actorId}/facts"]
},
{
"type": "EPISODIC",
"name": "episodes",
"namespaceTemplates": ["/episodes/{actorId}/{sessionId}"],
"reflectionNamespaceTemplates": ["/episodes/{actorId}"]
}
],
"indexedKeys": [{ "key": "tenant", "type": "STRING" }],
"tags": { "team": "ml" },
"encryptionKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abc",
"executionRoleArn": "arn:aws:iam::123456789012:role/MyMemoryRole",
"streamDeliveryResources": {
"resources": [
{
"kinesis": {
"dataStreamArn": "arn:aws:kinesis:us-east-1:123456789012:stream/memory",
"contentConfigurations": [{ "type": "MEMORY_RECORDS", "level": "FULL_CONTENT" }]
}
}
]
}
}

The --strategies JSON above is the strategies array as stored, character for character — da37fedf drops the flag's own copy of that schema and parses with the project schema's MemoryStrategySchema itself (wrapped only to report unsupported fields), so type/name/description/namespaceTemplates/reflectionNamespaceTemplates and all of the schema's cross-field rules come from one place and can't drift. --strategies SEMANTIC,EPISODIC remains as the shorthand that fills in the default namespaces.

[jariy17]

This should use SourceResolver.

[jariy17]

shift maps into handler. could be a follow up.

[nborges-aws]

LGTM. Agree with TJs latest comments for a follow up

[jariy17]

Follow Up PR

[jariy17]

Please use SourceResolver in follow up PR

[jariy17]

Shift templates to here because its not part of the schema type.

[notgitika]

This PR adds agentcore project add memory, which validates and appends a memory resource to spec.memories in agentcore.json. Memory resources do not scaffold any application files and are deployed through the generated CDK application.

Example:

 agentcore project add memory \
--name UserFacts \
--strategies SEMANTIC,EPISODIC

To maintain parity with the xisting CLI functionality, while also adding more configurability and customization, --strategies supports 2 input types:

• Comma-separated managed strategy types using default namespaces
• The memory's strategies array as JSON, exactly as it is stored in agentcore.json, for explicit names, descriptions, and namespaces (there is a parameter help in --help for ease of understanding for the user). It is parsed with the project schema's own MemoryStrategySchema, so the flag cannot drift from the schema.

The command also supports expiry duration, indexed keys, stream delivery, encryption and execution roles, descriptions, and tags (description is a new optional field. Here is the CDK PR for it https://github.com/aws/agentcore-l3-cdk-constructs/pull/325 )

Callouts:

• CUSTOM strategies are not supported because their extraction configuration cannot yet be represented by the project schema.

Validation

I tested it myself e2e with different combinations, flags, strategy conversions and validation failures. It all works well. I also tested it with agetncore project build

TODO: check compatibility with harness resource

[codecov-commenter]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 97.27%. Comparing base (b75e1c6) to head (da37fed).

Additional details and impacted files

@@ Coverage Diff @@## refactor #2025 +/- ##
============================================
+ Coverage 97.25% 97.27% +0.01% 
============================================
Files 397 398 +1 Lines 24127 24284 +157 ============================================
+ Hits 23465 23622 +157 
Misses 662 662 

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[notgitika]

My agent ran focused testing for project add memory after the latest validation changes:

• 122 focused project tests pass, plus build/typecheck/lint/format
• Rebuilt CLI verified valid JSON persistence and atomic rejection for the new edge cases
• Covered strategy unions, unsupported fields, indexed keys, stream delivery, tags, malformed JSON, and boundary inputs
• Live AWS lifecycles passed for minimal memory, all four managed strategies, and Kinesis stream delivery (CREATE_COMPLETE followed by cleanup)
• Confirmed no test stacks, memories, or streams remain

The testing surfaced and we fixed empty shorthand entries, recursive unsupported-field stripping (including __proto__), missing JSON strategy names, and the JSON-object diagnostic. The remaining long default strategy-name boundary is in the existing project schema/CDK naming layer rather than this handler.

[nborges-aws]

LGTM thanks for updates!

[jariy17]

Why didn't we use zod.strictObject

[notgitika]

good suggestion!

[jariy17]

I feel like there is a lot going on here just for parse and converting strategy inputs. Maybe we should create an adapter like this

xport interface MemoryStrategyAdapter<TInput = unknown> {
readonly type: MemoryStrategyType;
readonly memberKey: string;
readonly inputSchema: z.ZodType<TInput>;
fromInput(input: TInput): MemoryStrategy;
toInput(strategy: MemoryStrategy): TInput;
fromShorthand?(): MemoryStrategy;
canUseShorthand(strategy: MemoryStrategy): boolean;
}
The codec indexes registered adapters:
export class MemoryStrategyFlagCodec {
private readonly byType: Map<string, MemoryStrategyAdapter>;
private readonly byMember: Map<string, MemoryStrategyAdapter>;
constructor(adapters: readonly MemoryStrategyAdapter[]) {
this.byType = new Map(
adapters.map((adapter) => [adapter.type, adapter]),
);
this.byMember = new Map(
adapters.map((adapter) => [adapter.memberKey, adapter]),
);
}
parse(raw: string): MemoryStrategy[] {
return raw.trimStart().startsWith("[")
? this.parseJson(raw)
: this.parseShorthand(raw);
}
toFlag(strategies: readonly MemoryStrategy[]): string {
const adapters = strategies.map((strategy) => {
const adapter = this.byType.get(strategy.type);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy '${strategy.type}'`,
);
}
return adapter;
});
if (
strategies.every((strategy, index) =>
adapters[index].canUseShorthand(strategy),
)
) {
return strategies.map((strategy) => strategy.type).join(",");
}
return JSON.stringify(
strategies.map((strategy, index) => {
const adapter = adapters[index];
return {
[adapter.memberKey]: adapter.toInput(strategy),
};
}),
);
}
private parseShorthand(raw: string): MemoryStrategy[] {
return raw.split(",").map((value) => {
const type = value.trim();
const adapter = this.byType.get(type);
if (!adapter?.fromShorthand) {
throw new InputValidationError(
`Unsupported shorthand strategy '${type}'`,
);
}
return adapter.fromShorthand();
});
}
private parseJson(raw: string): MemoryStrategy[] {
const inputs = JSON.parse(raw) as unknown[];
return inputs.map((input) => this.parseJsonMember(input));
}
private parseJsonMember(input: unknown): MemoryStrategy {
// Validate that input is an object containing exactly one member.
const [memberKey] = Object.keys(input as object);
const adapter = this.byMember.get(memberKey);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy member '${memberKey}'`,
);
}
const value = adapter.inputSchema.parse(
(input as Record<string, unknown>)[memberKey],
);
return adapter.fromInput(value);
}
}
Registration is centralized:
const strategyCodec = new MemoryStrategyFlagCodec([
new StandardStrategyAdapter("SEMANTIC", "semanticMemoryStrategy"),
new StandardStrategyAdapter(
"SUMMARIZATION",
"summaryMemoryStrategy",
),
new StandardStrategyAdapter(
"USER_PREFERENCE",
"userPreferenceMemoryStrategy",
),
new EpisodicStrategyAdapter(),
]);

[notgitika]

Per @jariy17's ask for a 1-by-1 comparison — every flag is one agentcore.json memory field, and MemorySchema has exactly these 9 fields, so there is no flag without a field and no field without a flag.

flag	memories[] field
--name	name
--description	description
--event-expiry-duration	eventExpiryDuration
--strategies	strategies[]
--indexed-keys	indexedKeys[]
--stream-delivery-resources	streamDeliveryResources
--encryption-key-arn	encryptionKeyArn
--execution-role-arn	executionRoleArn
--tags	tags

One command using all 9 flags:

agentcore project add memory \ --name UserFacts \ --description "Durable facts and preferences for each end user." \ --event-expiry-duration 45 \ --strategies '[{"type":"SEMANTIC","name":"facts","description":"Durable user facts","namespaceTemplates":["/users/{actorId}/facts"]},{"type":"EPISODIC","name":"episodes","namespaceTemplates":["/episodes/{actorId}/{sessionId}"],"reflectionNamespaceTemplates":["/episodes/{actorId}"]}]' \ --indexed-keys '[{"key":"tenant","type":"STRING"}]' \ --stream-delivery-resources '{"resources":[{"kinesis":{"dataStreamArn":"arn:aws:kinesis:us-east-1:123456789012:stream/memory","contentConfigurations":[{"type":"MEMORY_RECORDS","level":"FULL_CONTENT"}]}}]}' \ --encryption-key-arn arn:aws:kms:us-east-1:123456789012:key/abc \ --execution-role-arn arn:aws:iam::123456789012:role/MyMemoryRole \ --tags '{"team":"ml"}'

The resulting memories[0], verbatim from the written agentcore.json:

{
"name": "UserFacts",
"description": "Durable facts and preferences for each end user.",
"eventExpiryDuration": 45,
"strategies": [
{
"type": "SEMANTIC",
"name": "facts",
"description": "Durable user facts",
"namespaceTemplates": ["/users/{actorId}/facts"]
},
{
"type": "EPISODIC",
"name": "episodes",
"namespaceTemplates": ["/episodes/{actorId}/{sessionId}"],
"reflectionNamespaceTemplates": ["/episodes/{actorId}"]
}
],
"indexedKeys": [{ "key": "tenant", "type": "STRING" }],
"tags": { "team": "ml" },
"encryptionKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abc",
"executionRoleArn": "arn:aws:iam::123456789012:role/MyMemoryRole",
"streamDeliveryResources": {
"resources": [
{
"kinesis": {
"dataStreamArn": "arn:aws:kinesis:us-east-1:123456789012:stream/memory",
"contentConfigurations": [{ "type": "MEMORY_RECORDS", "level": "FULL_CONTENT" }]
}
}
]
}
}

The --strategies JSON above is the strategies array as stored, character for character — da37fedf drops the flag's own copy of that schema and parses with the project schema's MemoryStrategySchema itself (wrapped only to report unsupported fields), so type/name/description/namespaceTemplates/reflectionNamespaceTemplates and all of the schema's cross-field rules come from one place and can't drift. --strategies SEMANTIC,EPISODIC remains as the shorthand that fills in the default namespaces.

[jariy17]

This should use SourceResolver.

[jariy17]

shift maps into handler. could be a follow up.

[nborges-aws]

LGTM. Agree with TJs latest comments for a follow up

[jariy17]

Follow Up PR

[jariy17]

Please use SourceResolver in follow up PR

[jariy17]

Shift templates to here because its not part of the schema type.

[notgitika]

This PR adds agentcore project add memory, which validates and appends a memory resource to spec.memories in agentcore.json. Memory resources do not scaffold any application files and are deployed through the generated CDK application.

Example:

 agentcore project add memory \
--name UserFacts \
--strategies SEMANTIC,EPISODIC

To maintain parity with the xisting CLI functionality, while also adding more configurability and customization, --strategies supports 2 input types:

• Comma-separated managed strategy types using default namespaces
• The memory's strategies array as JSON, exactly as it is stored in agentcore.json, for explicit names, descriptions, and namespaces (there is a parameter help in --help for ease of understanding for the user). It is parsed with the project schema's own MemoryStrategySchema, so the flag cannot drift from the schema.

The command also supports expiry duration, indexed keys, stream delivery, encryption and execution roles, descriptions, and tags (description is a new optional field. Here is the CDK PR for it https://github.com/aws/agentcore-l3-cdk-constructs/pull/325 )

Callouts:

• CUSTOM strategies are not supported because their extraction configuration cannot yet be represented by the project schema.

Validation

I tested it myself e2e with different combinations, flags, strategy conversions and validation failures. It all works well. I also tested it with agetncore project build

TODO: check compatibility with harness resource

[codecov-commenter]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 97.27%. Comparing base (b75e1c6) to head (da37fed).

Additional details and impacted files

@@ Coverage Diff @@## refactor #2025 +/- ##
============================================
+ Coverage 97.25% 97.27% +0.01% 
============================================
Files 397 398 +1 Lines 24127 24284 +157 ============================================
+ Hits 23465 23622 +157 
Misses 662 662 

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[notgitika]

My agent ran focused testing for project add memory after the latest validation changes:

• 122 focused project tests pass, plus build/typecheck/lint/format
• Rebuilt CLI verified valid JSON persistence and atomic rejection for the new edge cases
• Covered strategy unions, unsupported fields, indexed keys, stream delivery, tags, malformed JSON, and boundary inputs
• Live AWS lifecycles passed for minimal memory, all four managed strategies, and Kinesis stream delivery (CREATE_COMPLETE followed by cleanup)
• Confirmed no test stacks, memories, or streams remain

The testing surfaced and we fixed empty shorthand entries, recursive unsupported-field stripping (including __proto__), missing JSON strategy names, and the JSON-object diagnostic. The remaining long default strategy-name boundary is in the existing project schema/CDK naming layer rather than this handler.

[nborges-aws]

LGTM thanks for updates!

[jariy17]

Why didn't we use zod.strictObject

[notgitika]

good suggestion!

[jariy17]

I feel like there is a lot going on here just for parse and converting strategy inputs. Maybe we should create an adapter like this

xport interface MemoryStrategyAdapter<TInput = unknown> {
readonly type: MemoryStrategyType;
readonly memberKey: string;
readonly inputSchema: z.ZodType<TInput>;
fromInput(input: TInput): MemoryStrategy;
toInput(strategy: MemoryStrategy): TInput;
fromShorthand?(): MemoryStrategy;
canUseShorthand(strategy: MemoryStrategy): boolean;
}
The codec indexes registered adapters:
export class MemoryStrategyFlagCodec {
private readonly byType: Map<string, MemoryStrategyAdapter>;
private readonly byMember: Map<string, MemoryStrategyAdapter>;
constructor(adapters: readonly MemoryStrategyAdapter[]) {
this.byType = new Map(
adapters.map((adapter) => [adapter.type, adapter]),
);
this.byMember = new Map(
adapters.map((adapter) => [adapter.memberKey, adapter]),
);
}
parse(raw: string): MemoryStrategy[] {
return raw.trimStart().startsWith("[")
? this.parseJson(raw)
: this.parseShorthand(raw);
}
toFlag(strategies: readonly MemoryStrategy[]): string {
const adapters = strategies.map((strategy) => {
const adapter = this.byType.get(strategy.type);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy '${strategy.type}'`,
);
}
return adapter;
});
if (
strategies.every((strategy, index) =>
adapters[index].canUseShorthand(strategy),
)
) {
return strategies.map((strategy) => strategy.type).join(",");
}
return JSON.stringify(
strategies.map((strategy, index) => {
const adapter = adapters[index];
return {
[adapter.memberKey]: adapter.toInput(strategy),
};
}),
);
}
private parseShorthand(raw: string): MemoryStrategy[] {
return raw.split(",").map((value) => {
const type = value.trim();
const adapter = this.byType.get(type);
if (!adapter?.fromShorthand) {
throw new InputValidationError(
`Unsupported shorthand strategy '${type}'`,
);
}
return adapter.fromShorthand();
});
}
private parseJson(raw: string): MemoryStrategy[] {
const inputs = JSON.parse(raw) as unknown[];
return inputs.map((input) => this.parseJsonMember(input));
}
private parseJsonMember(input: unknown): MemoryStrategy {
// Validate that input is an object containing exactly one member.
const [memberKey] = Object.keys(input as object);
const adapter = this.byMember.get(memberKey);
if (!adapter) {
throw new InputValidationError(
`Unsupported memory strategy member '${memberKey}'`,
);
}
const value = adapter.inputSchema.parse(
(input as Record<string, unknown>)[memberKey],
);
return adapter.fromInput(value);
}
}
Registration is centralized:
const strategyCodec = new MemoryStrategyFlagCodec([
new StandardStrategyAdapter("SEMANTIC", "semanticMemoryStrategy"),
new StandardStrategyAdapter(
"SUMMARIZATION",
"summaryMemoryStrategy",
),
new StandardStrategyAdapter(
"USER_PREFERENCE",
"userPreferenceMemoryStrategy",
),
new EpisodicStrategyAdapter(),
]);

[notgitika]

Per @jariy17's ask for a 1-by-1 comparison — every flag is one agentcore.json memory field, and MemorySchema has exactly these 9 fields, so there is no flag without a field and no field without a flag.

flag	memories[] field
--name	name
--description	description
--event-expiry-duration	eventExpiryDuration
--strategies	strategies[]
--indexed-keys	indexedKeys[]
--stream-delivery-resources	streamDeliveryResources
--encryption-key-arn	encryptionKeyArn
--execution-role-arn	executionRoleArn
--tags	tags

One command using all 9 flags:

agentcore project add memory \ --name UserFacts \ --description "Durable facts and preferences for each end user." \ --event-expiry-duration 45 \ --strategies '[{"type":"SEMANTIC","name":"facts","description":"Durable user facts","namespaceTemplates":["/users/{actorId}/facts"]},{"type":"EPISODIC","name":"episodes","namespaceTemplates":["/episodes/{actorId}/{sessionId}"],"reflectionNamespaceTemplates":["/episodes/{actorId}"]}]' \ --indexed-keys '[{"key":"tenant","type":"STRING"}]' \ --stream-delivery-resources '{"resources":[{"kinesis":{"dataStreamArn":"arn:aws:kinesis:us-east-1:123456789012:stream/memory","contentConfigurations":[{"type":"MEMORY_RECORDS","level":"FULL_CONTENT"}]}}]}' \ --encryption-key-arn arn:aws:kms:us-east-1:123456789012:key/abc \ --execution-role-arn arn:aws:iam::123456789012:role/MyMemoryRole \ --tags '{"team":"ml"}'

The resulting memories[0], verbatim from the written agentcore.json:

{
"name": "UserFacts",
"description": "Durable facts and preferences for each end user.",
"eventExpiryDuration": 45,
"strategies": [
{
"type": "SEMANTIC",
"name": "facts",
"description": "Durable user facts",
"namespaceTemplates": ["/users/{actorId}/facts"]
},
{
"type": "EPISODIC",
"name": "episodes",
"namespaceTemplates": ["/episodes/{actorId}/{sessionId}"],
"reflectionNamespaceTemplates": ["/episodes/{actorId}"]
}
],
"indexedKeys": [{ "key": "tenant", "type": "STRING" }],
"tags": { "team": "ml" },
"encryptionKeyArn": "arn:aws:kms:us-east-1:123456789012:key/abc",
"executionRoleArn": "arn:aws:iam::123456789012:role/MyMemoryRole",
"streamDeliveryResources": {
"resources": [
{
"kinesis": {
"dataStreamArn": "arn:aws:kinesis:us-east-1:123456789012:stream/memory",
"contentConfigurations": [{ "type": "MEMORY_RECORDS", "level": "FULL_CONTENT" }]
}
}
]
}
}

The --strategies JSON above is the strategies array as stored, character for character — da37fedf drops the flag's own copy of that schema and parses with the project schema's MemoryStrategySchema itself (wrapped only to report unsupported fields), so type/name/description/namespaceTemplates/reflectionNamespaceTemplates and all of the schema's cross-field rules come from one place and can't drift. --strategies SEMANTIC,EPISODIC remains as the shorthand that fills in the default namespaces.

[jariy17]

This should use SourceResolver.

[jariy17]

shift maps into handler. could be a follow up.

[nborges-aws]

LGTM. Agree with TJs latest comments for a follow up

[jariy17]

Follow Up PR

[jariy17]

Please use SourceResolver in follow up PR

[jariy17]

Shift templates to here because its not part of the schema type.