@aws/agentcore 1.0.0-rc.1 → 1.0.0-rc.4

package/dist/assets/cdk/bin/cdk.ts

@@ -1,181 +1,30 @@
 #!/usr/bin/env node
-import { AgentCoreStack, type HarnessConfig } from '../lib/cdk-stack';
-import { ConfigIO, HarnessSpecSchema, type AwsDeploymentTarget } from '@aws/agentcore-cdk';
-import { App, type Environment } from 'aws-cdk-lib';
-import * as path from 'path';
-import * as fs from 'fs';
-
-function toEnvironment(target: AwsDeploymentTarget): Environment {
-  return {
-    account: target.account,
-    region: target.region,
-  };
-}
-
-function sanitize(name: string): string {
-  return name.replace(/_/g, '-');
-}
-
-function toStackName(projectName: string, targetName: string): string {
-  return `AgentCore-${sanitize(projectName)}-${sanitize(targetName)}`;
-}
-
-// The vended CDK project compiles against the published @aws/agentcore-cdk schema
-// type, which may lag the CLI's own AgentCoreProjectSpec (e.g. payments, harnesses,
-// gateway fields). This alias documents each read of those not-yet-published fields.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type SpecWithLatestFields = any;
-
-// Extract MCP configuration from the project spec. Gateway fields are stored in
-// agentcore.json but may not yet be on the published spec type, so they are read
-// off the loosened alias.
-function resolveMcpSpec(spec: SpecWithLatestFields) {
-  return spec.agentCoreGateways?.length
-    ? {
-        agentCoreGateways: spec.agentCoreGateways,
-        mcpRuntimeTools: spec.mcpRuntimeTools,
-        unassignedTargets: spec.unassignedTargets,
-      }
-    : undefined;
-}
-
-// Read non-S3 KB connector-config files and return their parsed contents keyed by
-// the data source's connectorConfigFile path. The L3 does not read files; it
-// expects these parsed connectorParameters verbatim.
-function resolveConnectorParametersByFile(
-  spec: SpecWithLatestFields,
-  projectRoot: string
-): Record<string, Record<string, unknown>> {
-  const connectorParametersByFile: Record<string, Record<string, unknown>> = {};
-  for (const kb of spec.knowledgeBases ?? []) {
-    for (const ds of kb.dataSources ?? []) {
-      if (ds.type !== 'S3' && ds.connectorConfigFile) {
-        const abs = path.resolve(projectRoot, ds.connectorConfigFile);
-        try {
-          connectorParametersByFile[ds.connectorConfigFile] = JSON.parse(fs.readFileSync(abs, 'utf-8'));
-        } catch (err) {
-          throw new Error(
-            `Could not read connector config '${ds.connectorConfigFile}' for knowledge base '${kb.name}' at ${abs}: ${err instanceof Error ? err.message : err}`
-          );
-        }
-      }
-    }
-  }
-  return connectorParametersByFile;
-}
-
-// Synthesize a HarnessConfig for each harness entry in the spec. The full validated
-// spec drives the AWS::BedrockAgentCore::Harness CFN resource; the role-scoped
-// fields drive the IAM role + container build.
-function resolveHarnessConfigs(spec: SpecWithLatestFields, projectRoot: string): HarnessConfig[] {
-  const harnessConfigs: HarnessConfig[] = [];
-  for (const entry of spec.harnesses ?? []) {
-    const harnessDir = path.resolve(projectRoot, entry.path);
-    const harnessPath = path.resolve(harnessDir, 'harness.json');
-    try {
-      const harnessSpec = HarnessSpecSchema.parse(JSON.parse(fs.readFileSync(harnessPath, 'utf-8')));
-      harnessConfigs.push({
-        name: entry.name,
-        executionRoleArn: harnessSpec.executionRoleArn,
-        // Only an `existing` memory ref carries a name to wire IAM against; managed memory is
-        // owned by the harness (no sibling) and disabled has none — both resolve to undefined.
-        memoryName: harnessSpec.memory?.mode === 'existing' ? harnessSpec.memory.name : undefined,
-        containerUri: harnessSpec.containerUri,
-        hasDockerfile: !!harnessSpec.dockerfile,
-        dockerfile: harnessSpec.dockerfile,
-        codeLocation: harnessSpec.dockerfile ? harnessDir : undefined,
-        tools: harnessSpec.tools,
-        skills: harnessSpec.skills,
-        apiKeyArn: harnessSpec.model?.apiKeyArn,
-        efsAccessPoints: harnessSpec.efsAccessPoints,
-        s3AccessPoints: harnessSpec.s3AccessPoints,
-        apiFormat: harnessSpec.model?.apiFormat,
-        // Full spec + dir drive the AWS::BedrockAgentCore::Harness CFN resource.
-        spec: harnessSpec,
-        harnessDir,
-      });
-    } catch (err) {
-      throw new Error(
-        `Could not read harness.json for "${entry.name}" at ${harnessPath}: ${err instanceof Error ? err.message : err}`
-      );
-    }
-  }
-  return harnessConfigs;
-}
-
-async function main() {
-  // Config root is parent of cdk/ directory. The CLI sets process.cwd() to agentcore/cdk/.
-  const configRoot = path.resolve(process.cwd(), '..');
-  const configIO = new ConfigIO({ baseDir: configRoot });
-
-  const spec = await configIO.readProjectSpec();
-  const targets = await configIO.readAWSDeploymentTargets();
-
-  // `project build` runs before a project has anywhere to deploy, so an empty target
-  // list is not an error: it synthesizes a single environment-agnostic stack, which is
-  // enough to typecheck the app and produce a template. Only a stack synthesized for a
-  // real target is a deploy candidate; the target tag below is what marks one.
-  const stackTargets: (AwsDeploymentTarget | undefined)[] = targets.length > 0 ? targets : [undefined];
-
-  const specAny: SpecWithLatestFields = spec;
-  const projectRoot = path.resolve(configRoot, '..');
-
-  const mcpSpec = resolveMcpSpec(specAny);
-  const connectorParametersByFile = resolveConnectorParametersByFile(specAny, projectRoot);
-  const harnessConfigs = resolveHarnessConfigs(specAny, projectRoot);
-
-  // Read deployed state for credential ARNs (populated by pre-deploy identity setup).
-  // Under agentcore/.cli/ to match the released CLI's location.
-  let deployedState: Record<string, unknown> | undefined;
-  try {
-    deployedState = JSON.parse(fs.readFileSync(path.join(configRoot, '.cli', 'deployed-state.json'), 'utf8'));
-  } catch (err) {
-    // A missing file is the normal first-deploy case. A malformed one is not:
-    // surface it rather than silently synthesizing without the credential ARNs
-    // it holds (which would drop them from the stack).
-    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;
-  }
+import { App } from 'aws-cdk-lib';
+import { readAgentCoreProject, resolveTargetStacks, transformAgentCoreJson } from '@aws/agentcore-cdk';
+import { AgentCoreStack } from '../lib/cdk-stack';
 
+try {
+  // The AgentCore CLI runs this app from agentcore/cdk/; readAgentCoreProject walks up to agentcore/.
+  const project = readAgentCoreProject();
   const app = new App();
-
-  for (const target of stackTargets) {
-    // An environment-agnostic stack resolves its account and region from CloudFormation
-    // pseudo-parameters at deploy time instead of pinning them at synth time.
-    const env = target ? toEnvironment(target) : undefined;
-    const stackName = target ? toStackName(spec.name, target.name) : `AgentCore-${sanitize(spec.name)}`;
-
-    // Extract credentials from deployed state for this target
-    const targetState = (deployedState as Record<string, unknown>)?.targets as
-      Record<string, Record<string, unknown>> | undefined;
-    const targetResources = target
-      ? (targetState?.[target.name]?.resources as Record<string, unknown> | undefined)
-      : undefined;
-    const credentials = targetResources?.credentials as
-      Record<string, { credentialProviderArn: string; clientSecretArn?: string }> | undefined;
-
-    new AgentCoreStack(app, stackName, {
-      spec,
-      mcpSpec,
-      credentials,
-      connectorParametersByFile,
-      harnesses: harnessConfigs.length > 0 ? harnessConfigs : undefined,
-      env,
-      description: target
-        ? `AgentCore stack for ${spec.name} deployed to ${target.name} (${target.region})`
-        : `AgentCore stack for ${spec.name} (no deployment target configured)`,
-      // Only a stack synthesized for a real target carries the target tag, which is
-      // how deploy selects the stack to ship.
-      tags: {
-        'agentcore:project-name': spec.name,
-        ...(target ? { 'agentcore:target-name': target.name } : {}),
-      },
+  for (const stack of resolveTargetStacks({
+    projectName: project.projectName,
+    targets: project.targets,
+    deployedState: project.deployedState,
+  })) {
+    new AgentCoreStack(app, stack.stackName, {
+      env: stack.env,
+      tags: stack.tags,
+      description: stack.description,
+      application: transformAgentCoreJson(project.agentCoreJson, {
+        projectRoot: project.projectRoot,
+        credentials: stack.credentials,
+        target: stack.target,
+      }),
     });
   }
-
   app.synth();
-}
-
-main().catch((error: unknown) => {
+} catch (error) {
   console.error('AgentCore CDK synthesis failed:', error instanceof Error ? error.message : error);
   process.exit(1);
-});
+}

package/dist/assets/cdk/lib/cdk-stack.ts

@@ -1,94 +1,32 @@
-import {
-  AgentCoreApplication,
-  AgentCoreMcp,
-  AgentCorePayments,
-  type AgentCoreProjectSpec,
-  type AgentCoreMcpSpec,
-  type HarnessDeploymentConfig,
-} from '@aws/agentcore-cdk';
-import { CfnOutput, Stack, type StackProps } from 'aws-cdk-lib';
+import { AgentCoreApplication, type AgentCoreApplicationProps } from '@aws/agentcore-cdk';
+import { Stack, type StackProps } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 
-/**
- * Harness deployment config: role-scoped fields (for IAM role + container build)
- * plus the full validated spec + its config directory so the L3 construct can
- * synthesize the AWS::BedrockAgentCore::Harness resource.
- */
-export type HarnessConfig = HarnessDeploymentConfig;
-
 export interface AgentCoreStackProps extends StackProps {
-  /**
-   * The AgentCore project specification containing agents, memories, and credentials.
-   */
-  spec: AgentCoreProjectSpec;
-  /**
-   * The MCP specification containing gateways and servers.
-   */
-  mcpSpec?: AgentCoreMcpSpec;
-  /**
-   * Credential provider ARNs from deployed state, keyed by credential name.
-   */
-  credentials?: Record<string, { credentialProviderArn: string; clientSecretArn?: string }>;
-  /**
-   * Harness role configurations.
-   */
-  harnesses?: HarnessConfig[];
-  /**
-   * Parsed connectorParameters for non-S3 KB data sources, keyed by
-   * connectorConfigFile path. Forwarded to AgentCoreApplication.
-   */
-  connectorParametersByFile?: Record<string, Record<string, unknown>>;
+  /** Props for the AgentCore application, produced by transformAgentCoreJson from agentcore/agentcore.json. */
+  application: AgentCoreApplicationProps;
 }
 
 /**
- * CDK Stack that deploys AgentCore infrastructure.
- *
- * This is a thin wrapper that instantiates L3 constructs.
- * All resource logic and outputs are contained within the L3 constructs.
+ * The stack the AgentCore CLI deploys. Everything declared in agentcore/agentcore.json is
+ * created by the AgentCoreApplication construct. Add your own resources below it and wire
+ * them to your runtimes and harnesses through the application's accessors.
  */
 export class AgentCoreStack extends Stack {
-  /** The AgentCore application containing all agent environments */
   public readonly application: AgentCoreApplication;
 
   constructor(scope: Construct, id: string, props: AgentCoreStackProps) {
     super(scope, id, props);
-
-    const { spec, mcpSpec, credentials, harnesses, connectorParametersByFile } = props;
-
-    // Create AgentCoreApplication with all agents and harness roles
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const appProps: Record<string, unknown> = { spec };
-    if (harnesses?.length) {
-      appProps.harnesses = harnesses;
-    }
-    if (connectorParametersByFile && Object.keys(connectorParametersByFile).length > 0) {
-      appProps.connectorParametersByFile = connectorParametersByFile;
-    }
-    if (credentials) {
-      appProps.credentials = credentials;
-    }
-    this.application = new AgentCoreApplication(this, 'Application', appProps as any);
-    new AgentCorePayments(this, 'Payments', {
-      spec,
-      credentials,
-      agentCoreApplication: this.application,
-    });
-
-    // Create AgentCoreMcp if there are gateways configured
-    if (mcpSpec?.agentCoreGateways && mcpSpec.agentCoreGateways.length > 0) {
-      new AgentCoreMcp(this, 'Mcp', {
-        projectName: spec.name,
-        mcpSpec,
-        agentCoreApplication: this.application,
-        credentials,
-        projectTags: spec.tags,
-      });
-    }
-
-    // Stack-level output
-    new CfnOutput(this, 'StackNameOutput', {
-      description: 'Name of the CloudFormation Stack',
-      value: this.stackName,
-    });
+    this.application = new AgentCoreApplication(this, 'Application', props.application);
+
+    // Example: give a runtime a DynamoDB table.
+    //
+    // import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
+    // const orders = new dynamodb.Table(this, 'Orders', {
+    //   partitionKey: { name: 'pk', type: dynamodb.AttributeType.STRING },
+    // });
+    // const checkout = this.application.runtime('checkout'); // or .harness('support')
+    // checkout.grantReadWrite(orders);
+    // checkout.addEnvironmentVariable('ORDERS_TABLE', orders.tableName);
   }
 }

package/dist/assets/cdk/package.json

@@ -7,24 +7,17 @@
   "scripts": {
     "build": "tsc",
     "watch": "tsc -w",
-    "test": "jest",
     "cdk": "npm run build && cdk",
-    "clean": "rm -rf dist",
-    "format": "prettier --write .",
-    "format:check": "prettier --check ."
+    "clean": "rm -rf dist"
   },
   "devDependencies": {
-    "@types/jest": "~29.5.14",
     "@types/node": "~24.13.3",
-    "jest": "~29.7.0",
-    "ts-jest": "~29.4.11",
     "aws-cdk": "~2.1126.0",
-    "prettier": "~3.9.5",
     "typescript": "~5.9.3"
   },
   "dependencies": {
-    "@aws/agentcore-cdk": "0.1.0-alpha.52",
-    "aws-cdk-lib": "~2.266.0",
+    "@aws/agentcore-cdk": "1.0.0-rc.2",
+    "aws-cdk-lib": "~2.269.0",
     "constructs": "~10.7.0"
   }
 }

package/dist/assets/cdk/tsconfig.json

@@ -23,6 +23,6 @@
     "rootDir": ".",
     "outDir": "dist"
   },
-  "include": ["bin/**/*", "lib/**/*", "test/**/*"],
+  "include": ["bin/**/*", "lib/**/*"],
   "exclude": ["node_modules", "cdk.out", "dist"]
 }

package/dist/assets/evaluators/python-lambda/README.md

@@ -13,7 +13,11 @@ with your own logic.
 - `pyproject.toml` — Python dependencies, managed with
   [uv](https://docs.astral.sh/uv/).
 - `execution-role-policy.json` — extra IAM the evaluator Lambda gets at runtime.
-  Add statements here for anything your logic calls (DynamoDB, S3, …).
+  Add statements here for anything your logic calls (Bedrock, DynamoDB, S3, …).
+
+Third-party evaluation libraries are ordinary application dependencies. Add
+them to `pyproject.toml`, configure them in `lambda_function.py`, and grant any
+required permissions in `execution-role-policy.json`.
 
 ## Write your evaluator
 

package/dist/assets/templates/a2a-python-strands/pyproject.toml

@@ -10,7 +10,7 @@ readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
     "a2a-sdk[all] ~= 0.3.0",
-    "aws-opentelemetry-distro ~= 0.17.0",
+    "aws-opentelemetry-distro ~= 0.18.0",
     "bedrock-agentcore[a2a] ~= 1.9.1",
     "botocore[crt] ~= 1.43.0",
     "strands-agents ~= 1.15.0",

package/dist/assets/templates/agent-python-langchain/README.md

@@ -7,9 +7,10 @@ session, and streams its response.
 ## What's here
 
 - `main.py`: the agent. A `BedrockAgentCoreApp` wraps an async entrypoint
-  that reads `prompt` from the payload, runs the agent, and streams each model
-  chunk back as a JSON event of content blocks. An `InMemorySaver` checkpointer
-  keyed on the Runtime session id carries history between turns.
+  that reads `prompt` from the payload, runs the agent, and streams each
+  completed model message back as a JSON event of content blocks. An
+  `InMemorySaver` checkpointer keyed on the Runtime session id carries history
+  between turns.
 - `model/load.py`: creates the Bedrock chat model with `init_chat_model`.
 - `pyproject.toml`: Python dependencies, managed with
   [uv](https://docs.astral.sh/uv/). `agentcore project create` has already run
@@ -21,7 +22,7 @@ Run the agent locally from the project root:
 
 ```bash
 agentcore project dev
-agentcore project invoke runtime --local --payload '{"prompt":"What is 2 plus 3?"}'
+agentcore project invoke runtime --local --name {{name}} --payload '{"prompt":"What is 2 plus 3?"}'
 ```
 
 Environment variables for local development go in `agentcore/.env.local`

package/dist/assets/templates/agent-python-langchain/main.py

@@ -1,6 +1,5 @@
 from langchain.agents import create_agent
 from langchain.tools import tool
-from langchain_core.messages import AIMessageChunk
 from langgraph.checkpoint.memory import InMemorySaver
 from bedrock_agentcore.runtime import BedrockAgentCoreApp
 from model.load import load_model
@@ -36,18 +35,15 @@ async def invoke(payload, context):
     session_id = context.session_id or "default-session"
     config = {"configurable": {"thread_id": session_id}}
 
-    async for event in agent.astream(
+    async with await agent.astream_events(
         {"messages": [{"role": "user", "content": prompt}]},
         config,
-        stream_mode="messages",
-        version="v2",
-    ):
-        message, metadata = event["data"]
-        if not isinstance(message, AIMessageChunk):
-            continue
-        blocks = message.content_blocks
-        if blocks:
-            yield {"node": metadata["langgraph_node"], "content": blocks}
+        version="v3",
+    ) as stream:
+        async for message in stream.messages:
+            blocks = (await message.output).content_blocks
+            if blocks:
+                yield {"node": message.node, "content": blocks}
 
 
 if __name__ == "__main__":

package/dist/assets/templates/agent-python-strands/README.md

@@ -16,8 +16,22 @@ file defines a Starlette ASGI app with the Strands Agent SDK running within.
 ## Input Validation
 
 Validate invocation input before forwarding it to Strands. Keep plain prompts typed as strings. If the app accepts a
-caller-supplied message history, retain `strip_trailing_tool_use()`, which normalizes the history tail before
-invoking the agent.
+caller-supplied message history, retain `_strip_trailing_tool_use()` in `parse.py`, which normalizes the history tail
+before invoking the agent.
+
+## Payload
+
+The Runtime accepts a JSON object. `parse_payload()` reads:
+
+- `prompt` (string) — a single user message. Used when `messages` is absent; defaults to `""`.
+- `messages` (array) — a full conversation history (`[{"role": ..., "content": [...]}]`). Takes precedence over `prompt`; trailing `toolUse` blocks are stripped before the agent runs.
+- `actorId` (string, optional) — identifies the end user for Memory scoping (e.g. `/users/{actorId}/facts`). Defaults to `"default"`.
+
+Provide either `prompt` or `messages`. The `session_id` is not in the body — it comes from the `X-Amzn-Bedrock-AgentCore-Runtime-Session-Id` header (`context.session_id`); reuse it to continue a conversation.
+
+```json
+{ "prompt": "What's the weather?", "actorId": "user-123" }
+```
 
 ## Environment Variables
 

package/dist/assets/templates/agent-python-strands/main.py

@@ -1,106 +1,65 @@
-from typing import Any
+from functools import lru_cache
 
 from strands import Agent, tool
 from strands.agent.conversation_manager.null_conversation_manager import NullConversationManager
 from bedrock_agentcore.runtime import BedrockAgentCoreApp
 from model.load import load_model
+from parse import parse_payload
 from memory.session import get_memory_session_manager
 
-app = BedrockAgentCoreApp()
-log = app.logger
-
 DEFAULT_SYSTEM_PROMPT = "You are a helpful assistant. Use tools when appropriate."
 
 # Define a collection of tools used by the model
 tools = []
 
-
 # Define a simple function tool
 @tool
 def add_numbers(a: int, b: int) -> int:
     """Return the sum of two numbers"""
     return a + b
 
-
 tools.append(add_numbers)
 
-
 def _make_conversation_manager():
     return NullConversationManager()
 
-
-def agent_factory():
-    cache = {}
-    def get_or_create_agent(session_id, user_id):
-        key = f"{session_id}/{user_id}"
-        if key not in cache:
-            cache[key] = Agent(
-                model=load_model(),
-                session_manager=get_memory_session_manager(session_id, user_id),
-                conversation_manager=_make_conversation_manager(),
-                system_prompt=DEFAULT_SYSTEM_PROMPT,
-                tools=tools,
-            )
-        return cache[key]
-    return get_or_create_agent
-get_or_create_agent = agent_factory()
-
-
-def strip_trailing_tool_use(messages: Any) -> list[dict]:
-    """Strip toolUse blocks from the tail until the last message has none."""
-    if not isinstance(messages, list):
-        raise ValueError("messages must be a list")
-
-    messages = list(messages)
-    while messages:
-        last = messages[-1]
-        if not isinstance(last, dict):
-            raise ValueError("each message must be an object")
-        original_content = last.get("content", [])
-        if not isinstance(original_content, list) or not all(isinstance(block, dict) for block in original_content):
-            raise ValueError("each message content value must be a list of content blocks")
-
-        content = [block for block in original_content if "toolUse" not in block]
-        if len(content) == len(original_content):
-            break
-        if content:
-            messages[-1] = {**last, "content": content}
-            break
-        messages.pop()
-
-    return messages
-
-
-def _extract_prompt(payload: dict):
-    """Accept a caller-supplied message history or a plain prompt string."""
-    if not isinstance(payload, dict):
-        raise ValueError("payload must be a JSON object")
-    if "messages" in payload:
-        return strip_trailing_tool_use(payload["messages"])
-    prompt = payload.get("prompt", "")
-    if not isinstance(prompt, str):
-        raise ValueError("prompt must be a string")
-    return prompt
-
-
-@app.entrypoint
-async def invoke(payload, context):
-    log.info("Invoking Agent.....")
-
-    session_id = getattr(context, "session_id", "default-session")
-    user_id = getattr(context, "user_id", "default-user")
-    agent = get_or_create_agent(session_id, user_id)
-
-    prompt = _extract_prompt(payload)
-
-    async for event in agent.stream_async(prompt):
-        if not isinstance(event, dict) or "event" not in event:
-            continue
-        cbs = event["event"].get("contentBlockStart")
-        if cbs is not None and not cbs.get("start"):
-            continue
-        yield event
-
-
+@lru_cache(maxsize=128)
+def _get_agent(session_id: str, actor_id: str) -> Agent:
+    """Given a session_id and actor_id, return or construct the corresponding Strands agent.
+    Note: caching helps avoid repeated identity fetches on non-bedrock model loads
+    and supports in-memory session management for local dev."""
+    return Agent(
+        model=load_model(),
+        session_manager=get_memory_session_manager(session_id, actor_id),
+        conversation_manager=_make_conversation_manager(),
+        system_prompt=DEFAULT_SYSTEM_PROMPT,
+        tools=tools,
+    )
+
+def create_app():
+    app = BedrockAgentCoreApp()
+    log = app.logger
+
+    @app.entrypoint
+    async def invoke(payload, context):
+        log.info("Invoking Agent.....")
+
+        session_id = getattr(context, "session_id", None) or "default-session"
+        prompt, actor_id = parse_payload(payload)
+
+        log.info(f"Invoking with session_id={session_id} and actor_id={actor_id}")
+        agent = _get_agent(session_id, actor_id)
+
+        async for event in agent.stream_async(prompt):
+            if not isinstance(event, dict) or "event" not in event:
+                continue
+            cbs = event["event"].get("contentBlockStart")
+            if cbs is not None and not cbs.get("start"):
+                continue
+            yield event
+
+    return app
+
+app = create_app()
 if __name__ == "__main__":
     app.run()

package/dist/assets/templates/agent-python-strands/memory/session.py

@@ -1,5 +1,4 @@
 import os
-import uuid
 from typing import Optional
 
 from bedrock_agentcore.memory.integrations.strands.config import AgentCoreMemoryConfig, RetrievalConfig
@@ -8,15 +7,12 @@ from bedrock_agentcore.memory.integrations.strands.session_manager import AgentC
 MEMORY_ID = os.getenv("{{memoryEnvVarName}}")
 REGION = os.getenv("AWS_REGION")
 
-
 def get_memory_session_manager(
-    session_id: Optional[str], actor_id: str
+        session_id: str, actor_id: str,
 ) -> Optional[AgentCoreMemorySessionManager]:
     if not MEMORY_ID:
         return None
 
-    session_id = session_id or uuid.uuid4().hex
-
     retrieval_config = {
         f"/users/{actor_id}/facts": RetrievalConfig(top_k=3, relevance_score=0.5),
         f"/users/{actor_id}/preferences": RetrievalConfig(top_k=3, relevance_score=0.5),