@aws/nx-plugin 1.0.0-rc.70 → 1.0.0-rc.72

package/src/py/agent/a2a-connection/__snapshots__/generator.spec.ts.snap

@@ -42,21 +42,64 @@ class AgentCoreA2aClientConfig:
 `;
 
 exports[`py#agent#a2a-connection generator > should match snapshot for agent-connection core files > agentcore_a2a_client_strands.py 1`] = `
-"from collections.abc import Callable
+"import asyncio
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
 
+import httpx
+from a2a.client import ClientConfig
 from strands.agent.a2a_agent import A2AAgent
+from strands.agent.agent_result import AgentResult
 
 from .agentcore_a2a_client_config import AgentCoreA2aClientConfig
 
 
-def _build(config: tuple, *, name: str | None, description: str | None) -> A2AAgent:
+def _run_sync(coro):
+    # The tool is invoked from sync agent code, which under uvicorn runs inside a
+    # live event loop where asyncio.run() would raise — fall back to a worker.
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+    with ThreadPoolExecutor(max_workers=1) as pool:
+        return pool.submit(asyncio.run, coro).result()
+
+
+class _A2AClient:
+    def __init__(
+        self,
+        url: str,
+        client_config: ClientConfig,
+        *,
+        name: str | None,
+        description: str | None,
+    ):
+        shared_client = client_config.httpx_client
+        if shared_client is None:
+            raise RuntimeError("A2A client config is missing an httpx client")
+        self._url = url
+        self._auth = shared_client.auth
+        self._timeout = shared_client.timeout
+        self._name = name
+        self._description = description
+
+    def __call__(self, prompt: str) -> AgentResult:
+        return _run_sync(self._invoke(prompt))
+
+    async def _invoke(self, prompt: str) -> AgentResult:
+        async with httpx.AsyncClient(auth=self._auth, timeout=self._timeout) as httpx_client:
+            agent = A2AAgent(
+                endpoint=self._url,
+                name=self._name,
+                description=self._description,
+                client_config=ClientConfig(httpx_client=httpx_client, streaming=False),
+            )
+            return await agent.invoke_async(prompt)
+
+
+def _build(config: tuple, *, name: str | None, description: str | None) -> _A2AClient:
     url, client_config = config
-    kwargs: dict = {"endpoint": url, "client_config": client_config}
-    if name:
-        kwargs["name"] = name
-    if description:
-        kwargs["description"] = description
-    return A2AAgent(**kwargs)
+    return _A2AClient(url, client_config, name=name, description=description)
 
 
 class AgentCoreA2aClientStrands:
@@ -68,7 +111,7 @@ class AgentCoreA2aClientStrands:
         *,
         name: str | None = None,
         description: str | None = None,
-    ) -> A2AAgent:
+    ) -> _A2AClient:
         """SigV4-authenticated client for a Bedrock AgentCore runtime."""
         return _build(
             AgentCoreA2aClientConfig.with_iam_auth(agent_runtime_arn),
@@ -83,7 +126,7 @@ class AgentCoreA2aClientStrands:
         *,
         name: str | None = None,
         description: str | None = None,
-    ) -> A2AAgent:
+    ) -> _A2AClient:
         """Bearer-authenticated client for a Bedrock AgentCore runtime."""
         return _build(
             AgentCoreA2aClientConfig.with_jwt_auth(agent_runtime_arn, access_token_provider),
@@ -97,7 +140,7 @@ class AgentCoreA2aClientStrands:
         *,
         name: str | None = None,
         description: str | None = None,
-    ) -> A2AAgent:
+    ) -> _A2AClient:
         """Plain-HTTP client — for local dev."""
         return _build(
             AgentCoreA2aClientConfig.without_auth(url),
@@ -110,8 +153,6 @@ class AgentCoreA2aClientStrands:
 exports[`py#agent#a2a-connection generator > should match snapshot for agent-connection core files > remote_client_strands.py 1`] = `
 "import os
 
-from strands.agent.a2a_agent import A2AAgent
-
 from test_agent_connection.core.agentcore_a2a_client_strands import (
     AgentCoreA2aClientStrands,
 )
@@ -124,7 +165,7 @@ class RemoteClientStrands:
     """Strands client for the Remote A2A agent."""
 
     @staticmethod
-    def create() -> A2AAgent:
+    def create():
         if os.environ.get("LOCAL_DEV") == "true":
             return AgentCoreA2aClientStrands.without_auth("http://localhost:9001/")
         config = get_agentcore_runtime_config()

package/src/py/agent/a2a-connection/files/agent-connection/app/__targetAgentSnakeCase___client_strands.py.template

@@ -1,7 +1,5 @@
 import os
 
-from strands.agent.a2a_agent import A2AAgent
-
 from <%- agentConnectionModuleName %>.core.agentcore_a2a_client_strands import (
     AgentCoreA2aClientStrands,
 )
@@ -14,7 +12,7 @@ class <%- targetAgentClassName %>ClientStrands:
     """Strands client for the <%- targetAgentClassName %> A2A agent."""
 
     @staticmethod
-    def create() -> A2AAgent:
+    def create():
         if os.environ.get("LOCAL_DEV") == "true":
             return AgentCoreA2aClientStrands.without_auth(
                 "http://localhost:<%- targetAgentPort %>/"

package/src/py/agent/files/langchain/common/agent.py.template

@@ -3,7 +3,8 @@ import os
 from langchain.agents import create_agent
 from langchain_aws import ChatBedrockConverse
 from langchain_core.tools import tool
-from langgraph.checkpoint.memory import InMemorySaver
+
+from .session import get_checkpointer
 
 REGION = os.environ.get("AWS_REGION", "us-east-1")
 MODEL_ID = os.environ.get("MODEL_ID", "global.anthropic.claude-haiku-4-5-20251001-v1:0")
@@ -17,7 +18,6 @@ def subtract(a: int, b: int) -> int:
 
 def get_agent():
     model = ChatBedrockConverse(model=MODEL_ID, region_name=REGION)
-    # Swap InMemorySaver for a durable checkpointer in a multi-replica deployment.
     return create_agent(
         model=model,
         tools=[subtract],
@@ -26,5 +26,5 @@ You are a mathematical wizard.
 Use your tools for mathematical tasks.
 Refer to tools as your 'spellbook'.
 """,
-        checkpointer=InMemorySaver(),
+        checkpointer=get_checkpointer(),
     )

package/src/py/agent/files/langchain/common/session.py.template

@@ -0,0 +1,61 @@
+import os
+
+<%_ if (session === 's3') { _%>
+import boto3
+<%_ } _%>
+import aiosqlite
+from langgraph.checkpoint.base import BaseCheckpointSaver
+<%_ if (session === 'in-memory') { _%>
+from langgraph.checkpoint.memory import InMemorySaver
+<%_ } _%>
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+<%_ if (session === 's3') { _%>
+from <%- agentConnectionModuleName %>.core.s3_checkpoint_saver_langchain import S3CheckpointSaver
+<%_ } else if (session === 'dynamodb-s3') { _%>
+from langgraph_checkpoint_aws import DynamoDBSaver
+<%_ } _%>
+<%_ if (session === 's3' || session === 'dynamodb-s3') { _%>
+from <%- agentConnectionModuleName %>.core.runtime_config import get_agentcore_runtime_config
+<%_ } _%>
+
+
+def get_checkpointer() -> BaseCheckpointSaver:
+    """Returns a LangGraph checkpointer for persisting conversation state across
+    invocations. Local development always uses a local SQLite database for
+    convenience, regardless of the configured session option.
+    """
+    if os.environ.get("LOCAL_DEV") == "true":
+        os.makedirs("<%- localSessionsDir %>", exist_ok=True)
+        conn = aiosqlite.connect(os.path.join("<%- localSessionsDir %>", "checkpoints.sqlite"))
+        return AsyncSqliteSaver(conn)
+
+<%_ if (session === 's3') { _%>
+    config = get_agentcore_runtime_config()
+    session_config = (config.get("agentRuntimes") or {}).get("<%- agentNameClassName %>", {}).get("session", {})
+    bucket_name = session_config.get("bucketName")
+    if not bucket_name:
+        raise RuntimeError(
+            "No S3 checkpoint bucket configured for this agent in runtime configuration."
+        )
+    return S3CheckpointSaver(
+        bucket_name=bucket_name,
+        prefix="checkpoints/",
+        s3_client=boto3.client("s3"),
+    )
+<%_ } else if (session === 'dynamodb-s3') { _%>
+    config = get_agentcore_runtime_config()
+    session_config = (config.get("agentRuntimes") or {}).get("<%- agentNameClassName %>", {}).get("session", {})
+    table_name = session_config.get("tableName")
+    bucket_name = session_config.get("bucketName")
+    if not table_name or not bucket_name:
+        raise RuntimeError(
+            "No DynamoDB checkpoint table or S3 offload bucket configured for this agent in runtime configuration."
+        )
+    return DynamoDBSaver(
+        table_name=table_name,
+        region_name=os.environ.get("AWS_REGION"),
+        s3_offload_config={"bucket_name": bucket_name},
+    )
+<%_ } else { _%>
+    return InMemorySaver()
+<%_ } _%>

package/src/py/agent/files/strands/ag-ui/main.py.template

@@ -4,7 +4,7 @@ from contextlib import asynccontextmanager
 
 from ag_ui.core import EventType, RunAgentInput, RunErrorEvent
 from ag_ui.encoder import EventEncoder
-from ag_ui_strands import StrandsAgent
+from ag_ui_strands import StrandsAgent, StrandsAgentConfig
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import StreamingResponse
@@ -12,6 +12,7 @@ from <%- agentConnectionModuleName %> import get_current_session_id, session_id_
 from starlette.middleware.base import BaseHTTPMiddleware
 
 from .agent import get_agent
+from .session import get_session_manager
 
 logging.basicConfig(level=logging.INFO)
 
@@ -25,6 +26,9 @@ async def lifespan(app: FastAPI):
             agent=agent,
             name="<%= agentNameClassName %>",
             description="A Strands Agent exposed via the AG-UI protocol.",
+            # A per-thread session manager, not the template Agent's own, since
+            # AG-UI caches one Strands agent per thread_id.
+            config=StrandsAgentConfig(session_manager_provider=lambda _input_data: get_session_manager()),
         )
         yield
 

package/src/py/agent/files/strands/common/agent.py.template

@@ -2,7 +2,11 @@ from contextlib import contextmanager
 
 from strands import Agent, tool
 from strands_tools import current_time
-from <%- agentConnectionModuleName %> import log_model_errors
+from <%- agentConnectionModuleName %> import log_model_errors, log_tool_errors
+<%_ if (protocol !== 'ag-ui') { _%>
+
+from .session import get_session_manager
+<%_ } _%>
 
 
 @tool
@@ -21,5 +25,8 @@ Use your tools for mathematical tasks.
 Refer to tools as your 'spellbook'.
 """,
         tools=[subtract, current_time],
-        hooks=[log_model_errors],
+        hooks=[log_model_errors, log_tool_errors],
+<%_ if (protocol !== 'ag-ui') { _%>
+        session_manager=get_session_manager(),
+<%_ } _%>
     )

package/src/py/agent/files/strands/common/session.py.template

@@ -0,0 +1,36 @@
+import os
+
+from strands.session import FileSessionManager, SessionManager<% if (session === 's3') { %>, S3SessionManager<% } %>
+
+from <%- agentConnectionModuleName %> import get_current_session_id
+<%_ if (session === 's3') { _%>
+from <%- agentConnectionModuleName %>.core.runtime_config import get_agentcore_runtime_config
+<%_ } _%>
+
+
+def get_session_manager() -> SessionManager | None:
+    """Returns a SessionManager for persisting conversation state across
+    invocations. Local development always uses local file storage for
+    convenience, regardless of the configured session option. Without a
+    configured session option, conversation state is kept in memory only and
+    does not survive process restarts.
+    """
+    session_id = get_current_session_id()
+    if not session_id:
+        raise RuntimeError(
+            "No current session id — cannot resolve a SessionManager outside of a request scope."
+        )
+    if os.environ.get("LOCAL_DEV") == "true":
+        return FileSessionManager(session_id=session_id, storage_dir="<%- localSessionsDir %>")
+
+<%_ if (session === 's3') { _%>
+    config = get_agentcore_runtime_config()
+    bucket_name = (
+        (config.get("agentRuntimes") or {}).get("<%- agentNameClassName %>", {}).get("session", {}).get("bucketName")
+    )
+    if not bucket_name:
+        raise RuntimeError("No S3 bucket configured for this agent's session in runtime configuration.")
+    return S3SessionManager(session_id=session_id, bucket=bucket_name)
+<%_ } else { _%>
+    return None
+<%_ } _%>

package/src/py/agent/generator.d.ts

@@ -5,7 +5,7 @@
 import { type GeneratorCallback, type Tree } from '@nx/devkit';
 import { type NxGeneratorInfo } from '../../utils/nx';
 import type { IacMetadata } from '../../utils/shared-constructs-constants';
-import type { AgentProtocol, PyAgentFramework, PyAgentGeneratorSchema } from './schema';
+import type { AgentProtocol, PyAgentFramework, PyAgentGeneratorSchema, PyAgentSession } from './schema';
 /** The metadata this generator records, which its predicates read. */
 export interface PyAgentMetadata extends IacMetadata {
     readonly port: number;
@@ -17,6 +17,7 @@ export interface PyAgentMetadata extends IacMetadata {
      * Strands vs LangChain Layer-2 client + agent.py transform.
      */
     readonly framework: PyAgentFramework;
+    readonly session: PyAgentSession;
 }
 export declare const DEPENDENCIES: import("../../utils/declared-dependencies").DependencyDeclaration<readonly [{
     readonly name: "agent-chat-cli";
@@ -120,6 +121,15 @@ export declare const DEPENDENCIES: import("../../utils/declared-dependencies").D
 }, {
     readonly name: "langgraph";
     readonly when: (m: PyAgentMetadata) => boolean;
+}, {
+    readonly name: "langgraph-checkpoint-sqlite";
+    readonly when: (m: PyAgentMetadata) => boolean;
+}, {
+    readonly name: "aiosqlite";
+    readonly when: (m: PyAgentMetadata) => boolean;
+}, {
+    readonly name: "langgraph-checkpoint-aws";
+    readonly when: (m: PyAgentMetadata) => boolean;
 }, {
     readonly name: "ag-ui-protocol";
     readonly when: (m: PyAgentMetadata) => boolean;

package/src/py/agent/generator.js

@@ -6,7 +6,7 @@ import { ensureLicenseExceptions } from "../../license/config.js";
 import { AG_UI_LANGGRAPH_EXCEPTIONS } from "../../license/known-exceptions.js";
 import { addPyDependencies, addTsDependencies } from "../../utils/add-dependencies.js";
 import { addAgentChatScripts } from "../../utils/agent-chat/agent-chat.js";
-import { AGENT_CONNECTION_PY_DEPENDENCIES, addPythonFrameworkBase, ensurePythonAgentConnectionProject, getPythonAgentConnectionModuleName, getPythonAgentConnectionProject } from "../../utils/agent-connection/agent-connection.js";
+import { AGENT_CONNECTION_PY_DEPENDENCIES, addPythonFrameworkBase, ensureLangchainS3CheckpointSaver, ensurePythonAgentConnectionProject, getPythonAgentConnectionModuleName, getPythonAgentConnectionProject } from "../../utils/agent-connection/agent-connection.js";
 import { addAgentInfra } from "../../utils/agent-core-constructs/agent-core-constructs.js";
 import { addPythonBundleTarget } from "../../utils/bundle/bundle.js";
 import { resolveContainers } from "../../utils/containers.js";
@@ -22,7 +22,7 @@ import { kebabCase, toClassName, toSnakeCase } from "../../utils/names.js";
 import { getNpmScope } from "../../utils/npm-scope.js";
 import { addComponentDevTarget, addComponentGeneratorMetadata, addDependencyToTargetIfNotPresent, getGeneratorInfo, normalizeTargetKeyOrder, readProjectConfigurationUnqualified } from "../../utils/nx.js";
 import { sortObjectKeys } from "../../utils/object.js";
-import { toProjectRelativePath } from "../../utils/paths.js";
+import { getRelativePathToRootByDirectory, toProjectRelativePath } from "../../utils/paths.js";
 import { assignPort } from "../../utils/port.js";
 import { addWorkspaceDependencyToPyProject } from "../../utils/py.js";
 import { SHARED_CONSTRUCTS_DEPENDENCIES, sharedConstructsGenerator } from "../../utils/shared-constructs.js";
@@ -117,6 +117,22 @@ export const DEPENDENCIES = declareDependencies()({
             name: 'langgraph',
             when: (m)=>m.framework === 'langchain'
         },
+        // Local dev uses a SQLite-backed checkpointer for convenience (parity
+        // with the strands framework's local FileSessionManager).
+        {
+            name: 'langgraph-checkpoint-sqlite',
+            when: (m)=>m.framework === 'langchain'
+        },
+        // AsyncSqliteSaver's driver, required alongside langgraph-checkpoint-sqlite.
+        {
+            name: 'aiosqlite',
+            when: (m)=>m.framework === 'langchain'
+        },
+        // Provides DynamoDBSaver (with S3 offloading for large checkpoints).
+        {
+            name: 'langgraph-checkpoint-aws',
+            when: (m)=>m.framework === 'langchain' && m.session === 'dynamodb-s3'
+        },
         {
             name: 'ag-ui-protocol',
             when: (m)=>m.framework === 'langchain' && m.protocol === 'ag-ui'
@@ -131,25 +147,25 @@ export const DEPENDENCIES = declareDependencies()({
         },
         {
             name: 'strands-agents[a2a]',
-            when: (m)=>m.framework !== 'langchain' && m.protocol === 'a2a'
+            when: (m)=>m.framework === 'strands' && m.protocol === 'a2a'
         },
         {
             name: 'strands-agents',
-            when: (m)=>m.framework !== 'langchain' && m.protocol !== 'a2a'
+            when: (m)=>m.framework === 'strands' && m.protocol !== 'a2a'
         },
         {
             name: 'strands-agents-tools',
-            when: (m)=>m.framework !== 'langchain'
+            when: (m)=>m.framework === 'strands'
         },
         // Declared again here so a Strands AG-UI agent lists it in the same order
         // the generated pyproject.toml had before.
         {
             name: 'ag-ui-protocol',
-            when: (m)=>m.framework !== 'langchain' && m.protocol === 'ag-ui'
+            when: (m)=>m.framework === 'strands' && m.protocol === 'ag-ui'
         },
         {
             name: 'ag-ui-strands',
-            when: (m)=>m.framework !== 'langchain' && m.protocol === 'ag-ui'
+            when: (m)=>m.framework === 'strands' && m.protocol === 'ag-ui'
         },
         {
             name: 'uvicorn'
@@ -193,9 +209,41 @@ export const pyAgentGenerator = async (tree, options)=>{
         console.warn('Warning: auth is ignored when no infrastructure is configured (no infrastructure is generated)');
     }
     const auth = options.auth ?? 'iam';
-    // Only 'in-memory' is currently supported for Python agents (session manager
-    // support for Python is not yet implemented).
-    const session = options.session ?? 'in-memory';
+    // Session backends are framework-specific: Strands' SessionManager only has
+    // an S3-backed implementation here (via strands.session.S3SessionManager),
+    // while LangChain uses dedicated S3 and DynamoDB checkpointer libraries.
+    // 'in-memory' is valid for both.
+    const SESSIONS_BY_FRAMEWORK = {
+        strands: [
+            's3',
+            'in-memory'
+        ],
+        langchain: [
+            's3',
+            'dynamodb-s3',
+            'in-memory'
+        ]
+    };
+    if (options.session && !SESSIONS_BY_FRAMEWORK[framework].includes(options.session)) {
+        throw new Error(`Unsupported combination: session '${options.session}' is not implemented for the ${framework} framework (supported: ${SESSIONS_BY_FRAMEWORK[framework].join(', ')}).`);
+    }
+    const session = options.session ?? 's3';
+    // With infra=none there's no CDK/Terraform construct to provision a bucket
+    // or table or set RUNTIME_CONFIG_APP_ID, so session.py's non-local-dev
+    // branch has nothing to read from AppConfig at runtime — the generated code
+    // still honors `session`, but only works outside local dev if the caller
+    // wires up matching infra/runtime config themselves.
+    if (infra === 'none' && session !== 'in-memory') {
+        console.warn(`Warning: session '${session}' requires infrastructure to configure it automatically (no infrastructure is generated for infra=none) — outside local dev this will fail unless you configure matching runtime config yourself`);
+    }
+    // Local-dev session storage lives at the workspace root
+    // (`tmp/agents/<framework>/<agent-name>`), not inside the project, so each
+    // agent gets its own storage directory — shared by both frameworks
+    // (Strands' FileSessionManager, LangChain's SqliteSaver). The
+    // `-dev`/`-serve` targets run with cwd={projectRoot}, so compute that
+    // directory relative to the project root here rather than resolving it at
+    // runtime.
+    const localSessionsDir = joinPathFragments(getRelativePathToRootByDirectory(project.root), `tmp/agents/${framework}/${name}`);
     // Ensure the shared agent-connection project exists so the server entry
     // point can import `session_id_context` and propagate the AgentCore
     // session ID to any downstream MCP / A2A clients a later connection
@@ -203,8 +251,8 @@ export const pyAgentGenerator = async (tree, options)=>{
     await ensurePythonAgentConnectionProject(tree, DEPENDENCIES);
     // The agent server imports the framework base helpers (session cache + model
     // error logging) regardless of whether a connection client is wired in. The
-    // langchain framework has no base layer (its AG-UI foundation reuses only the
-    // framework-agnostic session context), so this is a no-op for langchain.
+    // LangChain framework has no base layer (its AG-UI foundation reuses only the
+    // framework-agnostic session context), so this is a no-op for LangChain.
     await addPythonFrameworkBase(tree, DEPENDENCIES, framework);
     const agentConnectionModuleName = getPythonAgentConnectionModuleName(tree);
     addWorkspaceDependencyToPyProject(tree, project, getPythonAgentConnectionProject(tree));
@@ -214,27 +262,28 @@ export const pyAgentGenerator = async (tree, options)=>{
         agentNameClassName,
         moduleName,
         agentConnectionModuleName,
-        framework
+        framework,
+        protocol,
+        session,
+        localSessionsDir
     };
-    // Generate common files shared by both protocols. The agent module (agent.py)
-    // is framework-specific (Strands yields a contextmanaged Agent; LangChain
-    // returns a compiled create_agent graph), so it comes from a per-framework
-    // dir. The package __init__.py is framework-agnostic (it stays in `common`).
+    // Files live under a per-framework dir (files/strands, files/langchain),
+    // mirrored one-for-one — including files that don't vary by framework
+    // (e.g. the empty package __init__.py) — so there's a single, uniform
+    // <framework>/<protocol> layout with no cross-framework fallbacks.
+    // `framework` is itself the directory name.
+    // Common files shared by both protocols: the agent module (Strands yields a
+    // contextmanaged Agent with a session.py sibling; LangChain returns a
+    // compiled create_agent graph) and the package __init__.py.
     generateFiles(tree, joinPathFragments(import.meta.dirname, 'files', framework, 'common'), targetSourceDir, templateContext, {
         overwriteStrategy: OverwriteStrategy.KeepExisting
     });
-    if (framework === 'langchain') {
-        // langchain/common only carries agent.py; the empty package __init__.py is
-        // framework-agnostic, so emit it from the strands `common` dir.
-        generateFiles(tree, joinPathFragments(import.meta.dirname, 'files', 'strands', 'common'), targetSourceDir, templateContext, {
-            overwriteStrategy: OverwriteStrategy.KeepExisting
-        });
+    if (framework === 'langchain' && session === 's3') {
+        ensureLangchainS3CheckpointSaver(tree);
     }
-    // Generate protocol-specific files. Each protocol's server entry point (and,
-    // for HTTP, its init.py building the FastAPI app + lifespan) is
-    // framework-specific (Strands yields a contextmanaged Agent; LangChain drives
-    // a compiled create_agent graph), so it comes from a per-framework,
-    // per-protocol dir: `files/<framework>/<protocol>`.
+    // Protocol-specific files. Each protocol's server entry point is
+    // framework-specific (Strands yields a contextmanaged Agent; LangChain
+    // drives a compiled create_agent graph).
     const protocolLower = protocol.toLowerCase();
     generateFiles(tree, joinPathFragments(import.meta.dirname, 'files', framework, protocolLower), targetSourceDir, templateContext, {
         overwriteStrategy: OverwriteStrategy.KeepExisting
@@ -325,6 +374,7 @@ export const pyAgentGenerator = async (tree, options)=>{
         auth,
         protocol,
         framework,
+        session,
         ...iac ? {
             iac
         } : {}