agentcore-cli 0.31.1__py3-none-any.whl

agentcore/operations/agent/import_/langgraph_translator.py

@@ -0,0 +1,294 @@
+"""LangChain/LangGraph-specific translator for Bedrock Agent import (port of langgraph-translator.ts)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agentcore.operations.agent.import_.base_translator import (
+    BaseBedrockTranslator,
+    CollaboratorContext,
+    TranslationResult,
+    TranslatorOptions,
+    arn_region,
+    escape_py_double_quote,
+    js_json,
+    js_num,
+    nn,
+    sanitize_py_identifier,
+)
+
+
+class LangGraphTranslator(BaseBedrockTranslator):
+    def __init__(
+        self,
+        config: Any,
+        options: TranslatorOptions,
+        collaborator_context: CollaboratorContext | None = None,
+    ) -> None:
+        super().__init__(config, options, collaborator_context)
+
+    def translate(self) -> TranslationResult:
+        collaborator_files: dict[str, str] = {}
+
+        imports_code = self.imports_code + self._generate_langchain_imports()
+        prompts_code = self.generate_prompts()
+        models_code = self._generate_model_configurations()
+        collaboration_code = self._generate_collaboration_code(collaborator_files)
+        tools_code = self.generate_function_action_group_tools()
+        memory_code = self.generate_memory_code("InMemorySaver")
+        kb_code = self._generate_knowledge_base_code()
+        agent_setup_code = self._generate_agent_setup()
+        entrypoint_code = self.generate_entrypoint_code("langchain")
+
+        iam_comment = self.generate_iam_permissions_comment()
+
+        if self.observability_enabled:
+            imports_code += """
+from opentelemetry.instrumentation.langchain import LangchainInstrumentor
+LangchainInstrumentor().instrument()
+"""
+
+        main_py_content = self.assemble_code(
+            [
+                imports_code,
+                iam_comment,
+                models_code,
+                prompts_code,
+                collaboration_code,
+                tools_code,
+                memory_code,
+                kb_code,
+                agent_setup_code,
+                entrypoint_code,
+            ]
+        )
+        return TranslationResult(main_py_content, collaborator_files, self.get_features())
+
+    def _generate_langchain_imports(self) -> str:
+        return """
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from langchain_aws import ChatBedrock
+from langchain_aws.retrievers import AmazonKnowledgeBasesRetriever
+
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage, ToolMessage
+from langchain_core.globals import set_verbose, set_debug
+
+from langchain.tools import tool
+
+from langgraph.prebuilt import create_react_agent, InjectedState
+from langgraph.checkpoint.memory import InMemorySaver
+"""
+
+    def _generate_model_configurations(self) -> str:
+        configs: list[str] = []
+        provider_name = nn((self.agent_info.get("model") or {}).get("providerName"), "anthropic").lower()
+
+        for i, config in enumerate(self.prompt_configs):
+            prompt_type = nn(config.get("promptType"), f"CUSTOM_{i}")
+            if prompt_type == "KNOWLEDGE_BASE_RESPONSE_GENERATION" and not self.knowledge_bases:
+                continue
+            ic = nn(config.get("inferenceConfiguration"), {}) or {}
+            supports_top_k = provider_name in ("anthropic", "amazon")
+
+            model_kwargs = (
+                "{\n"
+                f'        "top_p": {js_num(nn(ic.get("topP"), 1.0))},\n'
+                f'        "temperature": {js_num(nn(ic.get("temperature"), 0))},\n'
+                f'        "max_tokens": {js_num(nn(ic.get("maximumLength"), 2048))}'
+            )
+            if supports_top_k:
+                model_kwargs += (
+                    ",\n"
+                    f'        "top_k": {js_num(nn(ic.get("topK"), 250))},\n'
+                    f'        "stop_sequences": {js_json(nn(ic.get("stopSequences"), []))}'
+                )
+            model_kwargs += "\n    }"
+
+            model_config = (
+                "\n"
+                f"# {prompt_type} LLM configuration\n"
+                f"llm_{prompt_type} = ChatBedrock(\n"
+                f'    model_id="{self.model_id}",\n'
+                f'    region_name="{self.agent_region}",\n'
+                f'    provider="{provider_name}",\n'
+                f"    model_kwargs={model_kwargs}"
+            )
+            if self.guardrail_config:
+                model_config += f",\n    guardrails={js_json(self.guardrail_config)}"
+            model_config += "\n)"
+            configs.append(model_config)
+
+        if not any(c.get("promptType") == "ORCHESTRATION" for c in self.prompt_configs):
+            configs.append(
+                "\n"
+                "llm_ORCHESTRATION = ChatBedrock(\n"
+                f'    model_id="{self.model_id}",\n'
+                f'    region_name="{self.agent_region}",\n'
+                f'    provider="{provider_name}"\n'
+                ")"
+            )
+        return "\n".join(configs)
+
+    def _generate_knowledge_base_code(self) -> str:
+        if not self.knowledge_bases:
+            return ""
+        code = "\n# --- Knowledge Base Tools ---\n"
+        for kb in self.knowledge_bases:
+            kb_name = sanitize_py_identifier(nn(kb.get("name"), ""))
+            kb_description = escape_py_double_quote(nn(kb.get("description"), ""))
+            kb_id = kb.get("knowledgeBaseId")
+            kb_region = nn(arn_region(kb.get("knowledgeBaseArn")), self.agent_region)
+            code += (
+                f"retriever_{kb_name} = AmazonKnowledgeBasesRetriever(\n"
+                f'    knowledge_base_id="{kb_id}",\n'
+                '    retrieval_config={"vectorSearchConfiguration": {"numberOfResults": 5}},\n'
+                f'    region_name="{kb_region}"\n'
+                ")\n"
+                "\n"
+                f'retriever_tool_{kb_name} = retriever_{kb_name}.as_tool(name="kb_{kb_name}", description="{kb_description}")\n'
+                "\n"
+            )
+            self.tools.append(f"retriever_tool_{kb_name}")
+        return code
+
+    def _generate_collaboration_code(self, collaborator_files: dict[str, str]) -> str:
+        if not self.multi_agent_enabled or not self.collaborators:
+            return ""
+        code = "\n# --- Multi-Agent Collaboration ---\n"
+        for i, collaborator in enumerate(self.collaborators):
+            collab_name = sanitize_py_identifier(nn(collaborator.get("collaboratorName"), ""))
+            file_name = f"langchain_collaborator_{collab_name}"
+
+            collab_translator = LangGraphTranslator(
+                collaborator,
+                self.options,
+                CollaboratorContext(
+                    name=collab_name,
+                    instruction=nn(collaborator.get("collaborationInstruction"), ""),
+                    relay_history=nn(collaborator.get("relayConversationHistory"), "DISABLED"),
+                ),
+            )
+            collab_result = collab_translator.translate()
+            collaborator_files[f"{file_name}.py"] = collab_result.main_py_content
+            collaborator_files.update(collab_result.collaborator_files)
+
+            relay = collaborator.get("relayConversationHistory") == "TO_COLLABORATOR"
+            relay_line = 'relay_history = state.get("messages", [])[:-1]' if relay else ""
+
+            code += f"from {file_name} import invoke_agent as invoke_{collab_name}_collaborator\n"
+            code += (
+                "\n@tool\n"
+                f"def invoke_{collab_name}(query: str, state: Annotated[dict, InjectedState]) -> str:\n"
+                f'    """Invoke the collaborator agent/specialist with the following description: {self.collaborator_descriptions[i]}"""\n'
+                f"    {relay_line}\n"
+                f"    invoke_agent_response = invoke_{collab_name}_collaborator(query{', relay_history' if relay else ''})\n"
+                "    tools_used.update([msg.name for msg in invoke_agent_response if isinstance(msg, ToolMessage)])\n"
+                "    return invoke_agent_response\n"
+                "\n"
+            )
+            self.tools.append(f"invoke_{collab_name}")
+        return code
+
+    def _generate_agent_setup(self) -> str:
+        code = f"\n# --- Agent Setup ---\ntools = [{', '.join(self.tools)}]\ntools_used = set()\n"
+        if self.custom_action_groups:
+            code += "tools += action_group_tools\n"
+
+        if self.agentcore_memory_enabled and self.has_long_term_strategies:
+            memory_retrieve_code = """
+            semantic_memories = memory_client.retrieve_memories(memory_id=memory_id, namespace_path=f'/users/{user_id}/facts', query="Retrieve relevant facts.", actor_id=user_id, top_k=3)
+            pref_memories = memory_client.retrieve_memories(memory_id=memory_id, namespace_path=f'/users/{user_id}/preferences', query="Retrieve user preferences.", actor_id=user_id, top_k=3)
+            summary_memories = memory_client.retrieve_memories(memory_id=memory_id, namespace_path=f'/summaries/{user_id}/', query="Retrieve the most recent session summaries.", actor_id=user_id, top_k=3)
+            all_memories = semantic_memories + pref_memories + summary_memories
+            memory_synopsis = "\\n".join([m.get("content", {}).get("text", "") for m in all_memories])"""
+        elif self.memory_enabled:
+            memory_retrieve_code = (
+                '    memory_synopsis = ""  # TODO: Configure memory manager for local memory retrieval'
+            )
+        else:
+            memory_retrieve_code = ""
+
+        memory_replace_code = (
+            '    system_prompt = system_prompt.replace("$memory_synopsis$", memory_synopsis)'
+            if self.memory_enabled
+            else ""
+        )
+        checkpointer_line = "\n            checkpointer=checkpointer_STM," if self.memory_enabled else ""
+
+        code += (
+            """
+config = {"configurable": {"thread_id": "1"}}
+set_verbose(False)
+set_debug(False)
+
+_agent = None
+first_turn = True
+last_input = ""
+user_id = ""
+
+# agent update loop
+def get_agent():
+    global _agent, user_id
+    if _agent is None:
+        """
+            + memory_retrieve_code
+            + """
+        system_prompt = ORCHESTRATION_TEMPLATE
+        """
+            + memory_replace_code
+            + """
+        _agent = create_react_agent(
+            model=llm_ORCHESTRATION,
+            prompt=system_prompt,
+            tools=tools,"""
+            + checkpointer_line
+            + """
+            debug=False
+        )
+    return _agent
+"""
+        )
+
+        relay_param_def = ", relayed_messages = []" if self.is_accepting_relays else ""
+        relay_code = (
+            """if relayed_messages:
+            agent.update_state(config, {"messages": relayed_messages})"""
+            if self.is_accepting_relays
+            else ""
+        )
+
+        preprocess_code = ""
+        if "PRE_PROCESSING" in self.enabled_prompts:
+            preprocess_code = """
+        pre_process_output = llm_PRE_PROCESSING.invoke([SystemMessage(PRE_PROCESSING_TEMPLATE), HumanMessage(question)])
+        question += "\\n<PRE_PROCESSING>{}</PRE_PROCESSING>".format(pre_process_output.content)"""
+
+        post_process_code = (
+            """
+        post_process_prompt = POST_PROCESSING_TEMPLATE.replace("$question$", question).replace("$latest_response$", response["messages"][-1].content).replace("$responses$", str(response["messages"]))
+        post_process_output = llm_POST_PROCESSING.invoke([HumanMessage(post_process_prompt)])
+        return [AIMessage(post_process_output.content)]"""
+            if "POST_PROCESSING" in self.enabled_prompts
+            else "    return response['messages']"
+        )
+
+        code += (
+            f"""
+def invoke_agent(question: str{relay_param_def}):
+    global last_input
+    last_input = question
+    agent = get_agent()
+    """
+            + relay_code
+            + """
+    """
+            + preprocess_code
+            + """
+
+    response = asyncio.run(agent.ainvoke({"messages": [{"role": "user", "content": question}]}, config))
+    """
+            + post_process_code
+            + "\n"
+        )
+        return code

agentcore/operations/agent/import_/pyproject_generator.py

@@ -0,0 +1,73 @@
+"""Generates pyproject.toml with dependencies based on agent features and framework
+(port of operations/agent/import/pyproject-generator.ts)."""
+
+from __future__ import annotations
+
+import re
+
+from agentcore.operations.agent.import_.base_translator import ImportedFeatures
+
+BASE_DEPS = (
+    "aws-opentelemetry-distro",
+    "bedrock-agentcore >= 1.9.1",
+    "botocore[crt] >= 1.35.0",
+    "boto3>=1.38.0",
+)
+
+STRANDS_DEPS = ("strands-agents>=1.13.0", "strands-agents-tools>=0.2.16")
+
+LANGGRAPH_DEPS = (
+    "langgraph>=1.0.2",
+    "langchain>=1.0.3",
+    "langchain_aws>=1.0.0",
+    "langchain-mcp-adapters>=0.1.11",
+    "opentelemetry-instrumentation-langchain>=0.59.0",
+    "tiktoken==0.11.0",
+)
+
+MEMORY_DEPS = ("bedrock-agentcore[memory] >= 1.9.1",)
+
+_NAME_SPLIT = re.compile(r"[>=<\[]")
+
+
+def generate_pyproject_toml(agent_name: str, framework: str, features: ImportedFeatures) -> str:
+    deps = list(BASE_DEPS)
+    deps.extend(STRANDS_DEPS if framework == "Strands" else LANGGRAPH_DEPS)
+
+    if features.has_memory:
+        # Replace base bedrock-agentcore with the [memory] extra variant.
+        base_idx = next(
+            (i for i, d in enumerate(deps) if d.startswith("bedrock-agentcore") and "[" not in d),
+            -1,
+        )
+        if base_idx != -1:
+            deps[base_idx] = MEMORY_DEPS[0]
+        else:
+            deps.extend(MEMORY_DEPS)
+
+    # Deduplicate (keep first occurrence).
+    seen: set[str] = set()
+    unique: list[str] = []
+    for dep in deps:
+        name = _NAME_SPLIT.split(dep)[0]
+        if name in seen:
+            continue
+        seen.add(name)
+        unique.append(dep)
+
+    deps_str = "\n".join(f'    "{d}",' for d in unique)
+    return f"""[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{agent_name}"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = [
+{deps_str}
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+"""

agentcore/operations/agent/import_/strands_translator.py

@@ -0,0 +1,289 @@
+"""Strands-specific translator for Bedrock Agent import (port of strands-translator.ts)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agentcore.operations.agent.import_.base_translator import (
+    BaseBedrockTranslator,
+    CollaboratorContext,
+    TranslationResult,
+    TranslatorOptions,
+    arn_region,
+    escape_py_triple_quote,
+    js_json,
+    js_num,
+    nn,
+    sanitize_py_identifier,
+)
+
+
+class StrandsTranslator(BaseBedrockTranslator):
+    def __init__(
+        self,
+        config: Any,
+        options: TranslatorOptions,
+        collaborator_context: CollaboratorContext | None = None,
+    ) -> None:
+        super().__init__(config, options, collaborator_context)
+
+    def translate(self) -> TranslationResult:
+        collaborator_files: dict[str, str] = {}
+
+        imports_code = self.imports_code + self._generate_strands_imports()
+        prompts_code = self.generate_prompts()
+        models_code = self._generate_model_configurations()
+        collaboration_code = self._generate_collaboration_code(collaborator_files)
+        tools_code = self.generate_function_action_group_tools()
+        memory_code = self.generate_memory_code("SlidingWindowConversationManager")
+        kb_code = self._generate_knowledge_base_code()
+        agent_setup_code = self._generate_agent_setup()
+        entrypoint_code = self.generate_entrypoint_code("strands")
+
+        iam_comment = self.generate_iam_permissions_comment()
+
+        guardrail_warning = (
+            "\n# WARNING: Guardrails were configured on the Bedrock Agent but Strands SDK does not\n"
+            "# natively support guardrails on BedrockModel. Consider using Bedrock Guardrails API directly.\n"
+            if self.guardrail_config
+            else ""
+        )
+
+        main_py_content = self.assemble_code(
+            [
+                imports_code,
+                iam_comment,
+                guardrail_warning,
+                models_code,
+                prompts_code,
+                collaboration_code,
+                tools_code,
+                memory_code,
+                kb_code,
+                agent_setup_code,
+                entrypoint_code,
+            ]
+        )
+        return TranslationResult(main_py_content, collaborator_files, self.get_features())
+
+    def _generate_strands_imports(self) -> str:
+        return """
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from strands import Agent, tool
+from strands.agent.conversation_manager import SlidingWindowConversationManager
+from strands.models import BedrockModel
+from strands.types.content import Message
+"""
+
+    def _generate_model_configurations(self) -> str:
+        configs: list[str] = []
+        for i, config in enumerate(self.prompt_configs):
+            prompt_type = nn(config.get("promptType"), f"CUSTOM_{i}")
+            if prompt_type == "KNOWLEDGE_BASE_RESPONSE_GENERATION" and not self.knowledge_bases:
+                continue
+            ic = nn(config.get("inferenceConfiguration"), {}) or {}
+            configs.append(
+                f"""
+llm_{prompt_type} = BedrockModel(
+    model_id="{self.model_id}",
+    region_name="{self.agent_region}",
+    temperature={js_num(nn(ic.get("temperature"), 0))},
+    max_tokens={js_num(nn(ic.get("maximumLength"), 2048))},
+    stop_sequences={js_json(nn(ic.get("stopSequences"), []))},
+    top_p={js_num(nn(ic.get("topP"), 1.0))}
+)"""
+            )
+
+        if not any(c.get("promptType") == "ORCHESTRATION" for c in self.prompt_configs):
+            configs.append(
+                f"""
+llm_ORCHESTRATION = BedrockModel(
+    model_id="{self.model_id}",
+    region_name="{self.agent_region}"
+)"""
+            )
+        return "\n".join(configs)
+
+    def _generate_knowledge_base_code(self) -> str:
+        if not self.knowledge_bases:
+            return ""
+        code = "\n# --- Knowledge Base Tools ---\n"
+        for kb in self.knowledge_bases:
+            kb_name = sanitize_py_identifier(nn(kb.get("name"), ""))
+            kb_description = escape_py_triple_quote(nn(kb.get("description"), ""))
+            kb_id = kb.get("knowledgeBaseId")
+            kb_region = nn(arn_region(kb.get("knowledgeBaseArn")), self.agent_region)
+            code += (
+                "\n@tool\n"
+                f"def retrieve_{kb_name}(query: str):\n"
+                f'    """This is a knowledge base with the following description: {kb_description}. Invoke it with a query to get relevant results."""\n'
+                f'    client = boto3.client("bedrock-agent-runtime", region_name="{kb_region}")\n'
+                "    return client.retrieve(\n"
+                '        retrievalQuery={"text": query},\n'
+                f'        knowledgeBaseId="{kb_id}",\n'
+                "        retrievalConfiguration={\n"
+                '            "vectorSearchConfiguration": {"numberOfResults": 10},\n'
+                "        },\n"
+                "    ).get('retrievalResults', [])\n"
+                "\n"
+            )
+            self.tools.append(f"retrieve_{kb_name}")
+        return code
+
+    def _generate_collaboration_code(self, collaborator_files: dict[str, str]) -> str:
+        if not self.multi_agent_enabled or not self.collaborators:
+            return ""
+        code = "\n# --- Multi-Agent Collaboration ---\n"
+        for i, collaborator in enumerate(self.collaborators):
+            collab_name = sanitize_py_identifier(nn(collaborator.get("collaboratorName"), ""))
+            file_name = f"strands_collaborator_{collab_name}"
+
+            collab_translator = StrandsTranslator(
+                collaborator,
+                self.options,
+                CollaboratorContext(
+                    name=collab_name,
+                    instruction=nn(collaborator.get("collaborationInstruction"), ""),
+                    relay_history=nn(collaborator.get("relayConversationHistory"), "DISABLED"),
+                ),
+            )
+            collab_result = collab_translator.translate()
+            collaborator_files[f"{file_name}.py"] = collab_result.main_py_content
+            collaborator_files.update(collab_result.collaborator_files)
+
+            relay = collaborator.get("relayConversationHistory") == "TO_COLLABORATOR"
+
+            code += f"from {file_name} import invoke_agent as invoke_{collab_name}_collaborator\n"
+            code += (
+                "\n@tool\n"
+                f"def invoke_{collab_name}(query: str) -> str:\n"
+                f'    """Invoke the collaborator agent/specialist with the following description: {self.collaborator_descriptions[i]}"""\n'
+                f"    {'relay_history = get_agent().messages[:-2]' if relay else ''}\n"
+                f"    invoke_agent_response = invoke_{collab_name}_collaborator(query{', relay_history' if relay else ''})\n"
+                "    return invoke_agent_response\n"
+                "\n"
+            )
+            self.tools.append(f"invoke_{collab_name}")
+        return code
+
+    def _generate_agent_setup(self) -> str:
+        code = f"\n# --- Agent Setup ---\ntools = [{', '.join(self.tools)}]\ntools_used = set()\n"
+        if self.custom_action_groups:
+            code += "tools += action_group_tools\n"
+
+        if self.agentcore_memory_enabled and self.has_long_term_strategies:
+            memory_retrieve_lines = [
+                "        semantic_memories = memory_client.retrieve_memories(memory_id=memory_id, namespace_path=f'/users/{user_id}/facts', query=\"Retrieve relevant facts.\", actor_id=user_id, top_k=3)",
+                "        pref_memories = memory_client.retrieve_memories(memory_id=memory_id, namespace_path=f'/users/{user_id}/preferences', query=\"Retrieve user preferences.\", actor_id=user_id, top_k=3)",
+                "        summary_memories = memory_client.retrieve_memories(memory_id=memory_id, namespace_path=f'/summaries/{user_id}/', query=\"Retrieve the most recent session summaries.\", actor_id=user_id, top_k=3)",
+                "        all_memories = semantic_memories + pref_memories + summary_memories",
+                '        memory_synopsis = "\\n".join([m.get("content", {}).get("text", "") for m in all_memories])',
+            ]
+        elif self.memory_enabled:
+            memory_retrieve_lines = [
+                '        memory_synopsis = ""  # TODO: Configure memory manager for local memory retrieval'
+            ]
+        else:
+            memory_retrieve_lines = []
+
+        memory_replace_lines = (
+            ['        system_prompt = system_prompt.replace("$memory_synopsis$", memory_synopsis)']
+            if self.memory_enabled
+            else []
+        )
+
+        conversation_manager = "checkpointer_STM" if self.memory_enabled else "SlidingWindowConversationManager()"
+        get_agent_lines = [
+            "# agent update loop",
+            "def get_agent():",
+            "    global _agent",
+            "    if _agent is None:",
+            *memory_retrieve_lines,
+            "        system_prompt = ORCHESTRATION_TEMPLATE",
+            *memory_replace_lines,
+            "        _agent = Agent(",
+            "            model=llm_ORCHESTRATION,",
+            "            system_prompt=system_prompt,",
+            "            tools=tools,",
+            f"            conversation_manager={conversation_manager}",
+            "        )",
+            "    return _agent",
+        ]
+
+        code += (
+            """
+
+def make_msg(role, text):
+    return {
+        "role": role,
+        "content": [{"text": text}]
+    }
+
+def inference(model, messages, system_prompt=""):
+    async def run_inference():
+        results = []
+        async for event in model.stream(messages=messages, system_prompt=system_prompt):
+            results.append(event)
+        return results
+
+    response = asyncio.run(run_inference())
+
+    text = ""
+    for chunk in response:
+        if "contentBlockDelta" not in chunk:
+            continue
+        text += chunk["contentBlockDelta"].get("delta", {}).get("text", "")
+
+    return text
+
+_agent = None
+first_turn = True
+last_input = ""
+user_id = ""
+
+"""
+            + "\n".join(get_agent_lines)
+            + "\n"
+        )
+
+        relay_param_def = ", relayed_messages = []" if self.is_accepting_relays else ""
+        relay_lines = (
+            ["    if relayed_messages:", "        agent.messages = relayed_messages"]
+            if self.is_accepting_relays
+            else []
+        )
+
+        preprocess_lines: list[str] = []
+        if "PRE_PROCESSING" in self.enabled_prompts:
+            preprocess_lines.extend(
+                [
+                    '    pre_process_output = inference(llm_PRE_PROCESSING, [make_msg("user", question)], system_prompt=PRE_PROCESSING_TEMPLATE)',
+                    '    question += "\\n<PRE_PROCESSING>{}</PRE_PROCESSING>".format(pre_process_output)',
+                ]
+            )
+
+        post_process_code = (
+            """    post_process_prompt = POST_PROCESSING_TEMPLATE.replace("$question$", question).replace("$latest_response$", str(response)).replace("$responses$", str(agent.messages))
+    post_process_output = inference(llm_POST_PROCESSING, [make_msg("user", post_process_prompt)])
+    return post_process_output"""
+            if "POST_PROCESSING" in self.enabled_prompts
+            else "    return response"
+        )
+
+        invoke_lines = [
+            f"def invoke_agent(question: str{relay_param_def}):",
+            "    global last_input",
+            "    last_input = question",
+            "    agent = get_agent()",
+            *relay_lines,
+            *preprocess_lines,
+            "",
+            "    original_stdout = sys.stdout",
+            "    sys.stdout = io.StringIO()",
+            "    response = agent(question)",
+            "    sys.stdout = original_stdout",
+            post_process_code,
+        ]
+        code += "\n" + "\n".join(invoke_lines) + "\n"
+        return code

agentcore/operations/config_bundle/__init__.py

@@ -0,0 +1 @@
+"""Config-bundle operations (port of operations/config-bundle)."""

agentcore/operations/config_bundle/bundle_name_variants.py

@@ -0,0 +1,9 @@
+"""API-side names for a config bundle (port of operations/config-bundle/bundle-name-variants.ts)."""
+
+
+def get_bundle_name_variants(bundle_name: str, project_name: str | None = None) -> list[str]:
+    """The API stores bundles with a project-name prefix; users reference them by local name."""
+    variants = [bundle_name]
+    if project_name:
+        variants += [f"{project_name}{bundle_name}", f"{project_name}_{bundle_name}"]
+    return [v for v in variants if v]