agentex-sdk 0.8.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

agentex/lib/cli/commands/agents.py

@@ -26,6 +26,8 @@ from agentex.lib.sdk.config.agent_manifest import AgentManifest
 from agentex.lib.cli.handlers.agent_handlers import (
     run_agent,
     build_agent,
+    parse_build_args,
+    prepare_cloud_build_context,
 )
 from agentex.lib.cli.handlers.deploy_handlers import (
     HelmError,
@@ -83,26 +85,24 @@ def delete(
 @agents.command()
 def cleanup_workflows(
     agent_name: str = typer.Argument(..., help="Name of the agent to cleanup workflows for"),
-    force: bool = typer.Option(False, help="Force cleanup using direct Temporal termination (bypasses development check)"),
+    force: bool = typer.Option(
+        False, help="Force cleanup using direct Temporal termination (bypasses development check)"
+    ),
 ):
     """
     Clean up all running workflows for an agent.
-    
+
     By default, uses graceful cancellation via agent RPC.
     With --force, directly terminates workflows via Temporal client.
     This is a convenience command that does the same thing as 'agentex tasks cleanup'.
     """
     try:
         console.print(f"[blue]Cleaning up workflows for agent '{agent_name}'...[/blue]")
-        
-        cleanup_agent_workflows(
-            agent_name=agent_name,
-            force=force,
-            development_only=True
-        )
-        
+
+        cleanup_agent_workflows(agent_name=agent_name, force=force, development_only=True)
+
         console.print(f"[green]✓ Workflow cleanup completed for agent '{agent_name}'[/green]")
-        
+
     except Exception as e:
         console.print(f"[red]Cleanup failed: {str(e)}[/red]")
         logger.exception("Agent workflow cleanup failed")
@@ -112,12 +112,8 @@ def cleanup_workflows(
 @agents.command()
 def build(
     manifest: str = typer.Option(..., help="Path to the manifest you want to use"),
-    registry: str | None = typer.Option(
-        None, help="Registry URL for pushing the built image"
-    ),
-    repository_name: str | None = typer.Option(
-        None, help="Repository name to use for the built image"
-    ),
+    registry: str | None = typer.Option(None, help="Registry URL for pushing the built image"),
+    repository_name: str | None = typer.Option(None, help="Repository name to use for the built image"),
     platforms: str | None = typer.Option(
         None, help="Platform to build the image for. Please enter a comma separated list of platforms."
     ),
@@ -126,9 +122,7 @@ def build(
         None,
         help="Docker build secret in the format 'id=secret-id,src=path-to-secret-file'",
     ),
-    tag: str | None = typer.Option(
-        None, help="Image tag to use (defaults to 'latest')"
-    ),
+    tag: str | None = typer.Option(None, help="Image tag to use (defaults to 'latest')"),
     build_arg: builtins.list[str] | None = typer.Option(  # noqa: B008
         None,
         help="Docker build argument in the format 'KEY=VALUE' (can be used multiple times)",
@@ -143,7 +137,7 @@ def build(
     if push and not registry:
         typer.echo("Error: --registry is required when --push is enabled", err=True)
         raise typer.Exit(1)
-    
+
     # Only proceed with build if we have a registry (for now, to match existing behavior)
     if not registry:
         typer.echo("No registry provided, skipping image build")
@@ -172,13 +166,105 @@ def build(
         raise typer.Exit(1) from e
 
 
+@agents.command(name="package")
+def package(
+    manifest: str = typer.Option(..., help="Path to the manifest you want to use"),
+    tag: str | None = typer.Option(
+        None,
+        "--tag",
+        "-t",
+        help="Image tag (defaults to deployment.image.tag from manifest, or 'latest')",
+    ),
+    output: str | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output filename for the tarball (defaults to <agent-name>-<tag>.tar.gz)",
+    ),
+    build_arg: builtins.list[str] | None = typer.Option(  # noqa: B008
+        None,
+        "--build-arg",
+        "-b",
+        help="Build argument in KEY=VALUE format (can be repeated)",
+    ),
+):
+    """
+    Package an agent's build context into a tarball for cloud builds.
+
+    Reads manifest.yaml, prepares build context according to include_paths and
+    dockerignore, then saves a compressed tarball to the current directory.
+
+    The tag defaults to the value in deployment.image.tag from the manifest.
+
+    Example:
+        agentex agents package --manifest manifest.yaml
+        agentex agents package --manifest manifest.yaml --tag v1.0
+    """
+    typer.echo(f"Packaging build context from manifest: {manifest}")
+
+    # Validate manifest exists
+    manifest_path = Path(manifest)
+    if not manifest_path.exists():
+        typer.echo(f"Error: manifest not found at {manifest_path}", err=True)
+        raise typer.Exit(1)
+
+    try:
+        # Prepare the build context (tag defaults from manifest if not provided)
+        build_context = prepare_cloud_build_context(
+            manifest_path=str(manifest_path),
+            tag=tag,
+            build_args=build_arg,
+        )
+
+        # Determine output filename using the resolved tag
+        if output:
+            output_filename = output
+        else:
+            output_filename = f"{build_context.agent_name}-{build_context.tag}.tar.gz"
+
+        # Save tarball to current working directory
+        output_path = Path.cwd() / output_filename
+        output_path.write_bytes(build_context.archive_bytes)
+
+        typer.echo(f"\nTarball saved to: {output_path}")
+        typer.echo(f"Size: {build_context.build_context_size_kb:.1f} KB")
+
+        # Output the build parameters needed for cloud build
+        typer.echo("\n" + "=" * 60)
+        typer.echo("Build Parameters for Cloud Build API:")
+        typer.echo("=" * 60)
+        typer.echo(f"  agent_name:      {build_context.agent_name}")
+        typer.echo(f"  image_name:      {build_context.image_name}")
+        typer.echo(f"  tag:             {build_context.tag}")
+        typer.echo(f"  context_file:    {output_path}")
+
+        if build_arg:
+            parsed_args = parse_build_args(build_arg)
+            typer.echo(f"  build_args:      {parsed_args}")
+
+        typer.echo("")
+        typer.echo("Command:")
+        build_args_str = ""
+        if build_arg:
+            build_args_str = " ".join(f'--build-arg "{arg}"' for arg in build_arg)
+            build_args_str = f" {build_args_str}"
+        typer.echo(
+            f'  sgp agentex build --context "{output_path}" '
+            f'--image-name "{build_context.image_name}" '
+            f'--tag "{build_context.tag}"{build_args_str}'
+        )
+        typer.echo("=" * 60)
+
+    except Exception as e:
+        typer.echo(f"Error packaging build context: {str(e)}", err=True)
+        logger.exception("Error packaging build context")
+        raise typer.Exit(1) from e
+
+
 @agents.command()
 def run(
     manifest: str = typer.Option(..., help="Path to the manifest you want to use"),
-    cleanup_on_start: bool = typer.Option(
-        False, 
-        help="Clean up existing workflows for this agent before starting"
-    ),
+    cleanup_on_start: bool = typer.Option(False, help="Clean up existing workflows for this agent before starting"),
     # Debug options
     debug: bool = typer.Option(False, help="Enable debug mode for both worker and ACP (disables auto-reload)"),
     debug_worker: bool = typer.Option(False, help="Enable debug mode for temporal worker only"),
@@ -190,26 +276,22 @@ def run(
     Run an agent locally from the given manifest.
     """
     typer.echo(f"Running agent from manifest: {manifest}")
-    
+
     # Optionally cleanup existing workflows before starting
     if cleanup_on_start:
         try:
             # Parse manifest to get agent name
             manifest_obj = AgentManifest.from_yaml(file_path=manifest)
             agent_name = manifest_obj.agent.name
-            
+
             console.print(f"[yellow]Cleaning up existing workflows for agent '{agent_name}'...[/yellow]")
-            cleanup_agent_workflows(
-                agent_name=agent_name,
-                force=False,
-                development_only=True
-            )
+            cleanup_agent_workflows(agent_name=agent_name, force=False, development_only=True)
             console.print("[green]✓ Pre-run cleanup completed[/green]")
-            
+
         except Exception as e:
             console.print(f"[yellow]⚠ Pre-run cleanup failed: {str(e)}[/yellow]")
             logger.warning(f"Pre-run cleanup failed: {e}")
-    
+
     # Create debug configuration based on CLI flags
     debug_config = None
     if debug or debug_worker or debug_acp:
@@ -224,19 +306,19 @@ def run(
             mode = DebugMode.ACP
         else:
             mode = DebugMode.NONE
-        
+
         debug_config = DebugConfig(
             enabled=True,
             mode=mode,
             port=debug_port,
             wait_for_attach=wait_for_debugger,
-            auto_port=False  # Use fixed port to match VS Code launch.json
+            auto_port=False,  # Use fixed port to match VS Code launch.json
         )
-        
+
         console.print(f"[blue]🐛 Debug mode enabled: {mode.value}[/blue]")
         if wait_for_debugger:
             console.print("[yellow]⏳ Processes will wait for debugger attachment[/yellow]")
-    
+
     try:
         run_agent(manifest_path=manifest, debug_config=debug_config)
     except Exception as e:
@@ -247,30 +329,23 @@ def run(
 
 @agents.command()
 def deploy(
-    cluster: str = typer.Option(
-        ..., help="Target cluster name (must match kubectl context)"
-    ),
+    cluster: str = typer.Option(..., help="Target cluster name (must match kubectl context)"),
     manifest: str = typer.Option("manifest.yaml", help="Path to the manifest file"),
     namespace: str | None = typer.Option(
         None,
         help="Override Kubernetes namespace (defaults to namespace from environments.yaml)",
     ),
     environment: str | None = typer.Option(
-        None, help="Environment name (dev, prod, etc.) - must be defined in environments.yaml. If not provided, the namespace must be set explicitly."
-    ),    
-    tag: str | None = typer.Option(None, help="Override the image tag for deployment"),
-    repository: str | None = typer.Option(
-        None, help="Override the repository for deployment"
-    ),
-    interactive: bool = typer.Option(
-        True, "--interactive/--no-interactive", help="Enable interactive prompts"
+        None,
+        help="Environment name (dev, prod, etc.) - must be defined in environments.yaml. If not provided, the namespace must be set explicitly.",
     ),
+    tag: str | None = typer.Option(None, help="Override the image tag for deployment"),
+    repository: str | None = typer.Option(None, help="Override the repository for deployment"),
+    interactive: bool = typer.Option(True, "--interactive/--no-interactive", help="Enable interactive prompts"),
 ):
     """Deploy an agent to a Kubernetes cluster using Helm"""
 
-    console.print(
-        Panel.fit("🚀 [bold blue]Deploy Agent[/bold blue]", border_style="blue")
-    )
+    console.print(Panel.fit("🚀 [bold blue]Deploy Agent[/bold blue]", border_style="blue"))
 
     try:
         # Validate manifest exists
@@ -281,17 +356,12 @@ def deploy(
 
         # Validate manifest and environments configuration
         try:
-            if environment:
-                _, environments_config = validate_manifest_and_environments(
-                    str(manifest_path), 
-                    required_environment=environment
-                )
-                agent_env_config = environments_config.get_config_for_env(environment)
-                console.print(f"[green]✓[/green] Environment config validated: {environment}")
-            else:
-                agent_env_config = None
-                console.print(f"[yellow]⚠[/yellow] No environment provided, skipping environment-specific config")
-            
+            _, environments_config = validate_manifest_and_environments(
+                str(manifest_path), required_environment=environment
+            )
+            agent_env_config = environments_config.get_config_for_env(environment)
+            console.print(f"[green]✓[/green] Environment config validated: {environment}")
+
         except EnvironmentsValidationError as e:
             error_msg = generate_helpful_error_message(e, "Environment validation failed")
             console.print(f"[red]Configuration Error:[/red]\n{error_msg}")
@@ -310,9 +380,13 @@ def deploy(
                 console.print(f"[blue]ℹ[/blue] Using namespace from environments.yaml: {namespace_from_config}")
                 namespace = namespace_from_config
             else:
-                raise DeploymentError(f"No namespace found in environments.yaml for environment: {environment}, and not passed in as --namespace")
+                raise DeploymentError(
+                    f"No namespace found in environments.yaml for environment: {environment}, and not passed in as --namespace"
+                )
         elif not namespace:
-            raise DeploymentError("No namespace provided, and not passed in as --namespace and no environment provided to read from an environments.yaml file")
+            raise DeploymentError(
+                "No namespace provided, and not passed in as --namespace and no environment provided to read from an environments.yaml file"
+            )
 
         # Confirm deployment (only in interactive mode)
         console.print("\n[bold]Deployment Summary:[/bold]")
@@ -325,9 +399,7 @@ def deploy(
 
         if interactive:
             proceed = questionary.confirm("Proceed with deployment?").ask()
-            proceed = handle_questionary_cancellation(
-                proceed, "deployment confirmation"
-            )
+            proceed = handle_questionary_cancellation(proceed, "deployment confirmation")
 
             if not proceed:
                 console.print("Deployment cancelled")
@@ -337,9 +409,7 @@ def deploy(
 
         check_and_switch_cluster_context(cluster)
         if not validate_namespace(namespace, cluster):
-            console.print(
-                f"[red]Error:[/red] Namespace '{namespace}' does not exist in cluster '{cluster}'"
-            )
+            console.print(f"[red]Error:[/red] Namespace '{namespace}' does not exist in cluster '{cluster}'")
             raise typer.Exit(1)
 
         deploy_overrides = InputDeployOverrides(repository=repository, image_tag=tag)
@@ -356,9 +426,7 @@ def deploy(
         # Use the already loaded manifest object
         release_name = f"{manifest_obj.agent.name}-{cluster}"
 
-        console.print(
-            "\n[bold green]🎉 Deployment completed successfully![/bold green]"
-        )
+        console.print("\n[bold green]🎉 Deployment completed successfully![/bold green]")
         console.print("\nTo check deployment status:")
         console.print(f"  kubectl get pods -n {namespace}")
         console.print(f"  helm status {release_name} -n {namespace}")

agentex/lib/cli/commands/init.py

@@ -26,6 +26,7 @@ class TemplateType(str, Enum):
     TEMPORAL_OPENAI_AGENTS = "temporal-openai-agents"
     DEFAULT = "default"
     SYNC = "sync"
+    SYNC_OPENAI_AGENTS = "sync-openai-agents"
 
 
 def render_template(
@@ -58,6 +59,7 @@ def create_project_structure(
         TemplateType.TEMPORAL_OPENAI_AGENTS: ["acp.py", "workflow.py", "run_worker.py", "activities.py"],
         TemplateType.DEFAULT: ["acp.py"],
         TemplateType.SYNC: ["acp.py"],
+        TemplateType.SYNC_OPENAI_AGENTS: ["acp.py"],
     }[template_type]
 
     # Create project/code files
@@ -155,7 +157,7 @@ def init():
         choices=[
             {"name": "Async - ACP Only", "value": TemplateType.DEFAULT},
             {"name": "Async - Temporal", "value": "temporal_submenu"},
-            {"name": "Sync ACP", "value": TemplateType.SYNC},
+            {"name": "Sync ACP", "value": "sync_submenu"},
         ],
     ).ask()
     if not template_type:
@@ -163,7 +165,6 @@ def init():
 
     # If Temporal was selected, show sub-menu for Temporal variants
     if template_type == "temporal_submenu":
-        console.print()
         template_type = questionary.select(
             "Which Temporal template would you like to use?",
             choices=[
@@ -173,6 +174,16 @@ def init():
         ).ask()
         if not template_type:
             return
+    elif template_type == "sync_submenu":
+        template_type = questionary.select(
+            "Which Sync template would you like to use?",
+            choices=[
+                {"name": "Basic Sync ACP", "value": TemplateType.SYNC},
+                {"name": "Sync ACP + OpenAI Agents SDK (Recommended)", "value": TemplateType.SYNC_OPENAI_AGENTS},
+            ],
+        ).ask()
+        if not template_type:
+            return
 
     project_path = questionary.path(
         "Where would you like to create your project?", default="."

agentex/lib/cli/handlers/agent_handlers.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from typing import NamedTuple
 from pathlib import Path
 
 from rich.console import Console
@@ -8,7 +9,7 @@ from python_on_whales import DockerException, docker
 from agentex.lib.cli.debug import DebugConfig
 from agentex.lib.utils.logging import make_logger
 from agentex.lib.cli.handlers.run_handlers import RunError, run_agent as _run_agent
-from agentex.lib.sdk.config.agent_manifest import AgentManifest
+from agentex.lib.sdk.config.agent_manifest import AgentManifest, BuildContextManager
 
 logger = make_logger(__name__)
 console = Console()
@@ -18,6 +19,17 @@ class DockerBuildError(Exception):
     """An error occurred during docker build"""
 
 
+class CloudBuildContext(NamedTuple):
+    """Contains the prepared build context for cloud builds."""
+
+    archive_bytes: bytes
+    dockerfile_path: str
+    agent_name: str
+    tag: str
+    image_name: str
+    build_context_size_kb: float
+
+
 def build_agent(
     manifest_path: str,
     registry_url: str,
@@ -42,9 +54,7 @@ def build_agent(
         The image URL
     """
     agent_manifest = AgentManifest.from_yaml(file_path=manifest_path)
-    build_context_root = (
-        Path(manifest_path).parent / agent_manifest.build.context.root
-    ).resolve()
+    build_context_root = (Path(manifest_path).parent / agent_manifest.build.context.root).resolve()
 
     repository_name = repository_name or agent_manifest.agent.name
 
@@ -85,9 +95,7 @@ def build_agent(
                         key, value = arg.split("=", 1)
                         docker_build_args[key] = value
                     else:
-                        logger.warning(
-                            f"Invalid build arg format: {arg}. Expected KEY=VALUE"
-                        )
+                        logger.warning(f"Invalid build arg format: {arg}. Expected KEY=VALUE")
 
                 if docker_build_args:
                     docker_build_kwargs["build_args"] = docker_build_args
@@ -100,9 +108,7 @@ def build_agent(
             if push:
                 # Build and push in one step for multi-platform builds
                 logger.info("Building and pushing image...")
-                docker_build_kwargs["push"] = (
-                    True  # Push directly after build for multi-platform
-                )
+                docker_build_kwargs["push"] = True  # Push directly after build for multi-platform
                 docker.buildx.build(**docker_build_kwargs)
 
                 logger.info(f"Successfully built and pushed {image_name}")
@@ -146,11 +152,11 @@ def run_agent(manifest_path: str, debug_config: "DebugConfig | None" = None):
         shutting_down = True
         logger.info(f"Received signal {signum}, shutting down...")
         raise KeyboardInterrupt()
-    
+
     # Set up signal handling for the main thread
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
-    
+
     try:
         asyncio.run(_run_agent(manifest_path, debug_config))
     except KeyboardInterrupt:
@@ -158,3 +164,115 @@ def run_agent(manifest_path: str, debug_config: "DebugConfig | None" = None):
         sys.exit(0)
     except RunError as e:
         raise RuntimeError(str(e)) from e
+
+
+def parse_build_args(build_args: list[str] | None) -> dict[str, str]:
+    """Parse build arguments from KEY=VALUE format to a dictionary.
+
+    Args:
+        build_args: List of build arguments in KEY=VALUE format
+
+    Returns:
+        Dictionary mapping keys to values
+    """
+    result: dict[str, str] = {}
+    if not build_args:
+        return result
+
+    for arg in build_args:
+        if "=" in arg:
+            key, value = arg.split("=", 1)
+            result[key] = value
+        else:
+            logger.warning(f"Invalid build arg format: {arg}. Expected KEY=VALUE")
+
+    return result
+
+
+def prepare_cloud_build_context(
+    manifest_path: str,
+    tag: str | None = None,
+    build_args: list[str] | None = None,
+) -> CloudBuildContext:
+    """Prepare the build context for cloud-based container builds.
+
+    Reads the manifest, prepares the build context by copying files according to
+    the include_paths and dockerignore, then creates a compressed tar.gz archive
+    ready for upload to a cloud build service.
+
+    Args:
+        manifest_path: Path to the agent manifest file
+        tag: Image tag override (if None, reads from manifest's deployment.image.tag)
+        build_args: List of build arguments in KEY=VALUE format
+
+    Returns:
+        CloudBuildContext containing the archive bytes, dockerfile path, and metadata
+    """
+    agent_manifest = AgentManifest.from_yaml(file_path=manifest_path)
+    build_context_root = (Path(manifest_path).parent / agent_manifest.build.context.root).resolve()
+
+    agent_name = agent_manifest.agent.name
+    dockerfile_path = agent_manifest.build.context.dockerfile
+
+    # Validate that the Dockerfile exists
+    full_dockerfile_path = build_context_root / dockerfile_path
+    if not full_dockerfile_path.exists():
+        raise FileNotFoundError(
+            f"Dockerfile not found at: {full_dockerfile_path}\n"
+            f"Check that 'build.context.dockerfile' in your manifest points to an existing file."
+        )
+    if not full_dockerfile_path.is_file():
+        raise ValueError(
+            f"Dockerfile path is not a file: {full_dockerfile_path}\n"
+            f"'build.context.dockerfile' must point to a file, not a directory."
+        )
+
+    # Get tag and repository from manifest if not provided
+    if tag is None:
+        if agent_manifest.deployment and agent_manifest.deployment.image:
+            tag = agent_manifest.deployment.image.tag
+        else:
+            tag = "latest"
+
+    # Get repository name from manifest (just the repo name, not the full registry URL)
+    if agent_manifest.deployment and agent_manifest.deployment.image:
+        repository = agent_manifest.deployment.image.repository
+        if repository:
+            # Extract just the repo name (last part after any slashes)
+            image_name = repository.split("/")[-1]
+        else:
+            image_name = "<repository>"
+    else:
+        image_name = "<repository>"
+
+    logger.info(f"Agent: {agent_name}")
+    logger.info(f"Image name: {image_name}")
+    logger.info(f"Build context root: {build_context_root}")
+    logger.info(f"Dockerfile: {dockerfile_path}")
+    logger.info(f"Tag: {tag}")
+
+    if agent_manifest.build.context.include_paths:
+        logger.info(f"Include paths: {agent_manifest.build.context.include_paths}")
+
+    parsed_build_args = parse_build_args(build_args)
+    if parsed_build_args:
+        logger.info(f"Build args: {list(parsed_build_args.keys())}")
+
+    logger.info("Preparing build context...")
+
+    with agent_manifest.context_manager(build_context_root) as build_context:
+        # Compress the prepared context using the static zipped method
+        with BuildContextManager.zipped(root_path=build_context.path) as archive_buffer:
+            archive_bytes = archive_buffer.read()
+
+        build_context_size_kb = len(archive_bytes) / 1024
+        logger.info(f"Build context size: {build_context_size_kb:.1f} KB")
+
+        return CloudBuildContext(
+            archive_bytes=archive_bytes,
+            dockerfile_path=build_context.dockerfile_path,
+            agent_name=agent_name,
+            tag=tag,
+            image_name=image_name,
+            build_context_size_kb=build_context_size_kb,
+        )

agentex/lib/cli/templates/sync-openai-agents/.dockerignore.j2

@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Environments
+.env**
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Git
+.git
+.gitignore
+
+# Misc
+.DS_Store 

agentex/lib/cli/templates/sync-openai-agents/Dockerfile-uv.j2

@@ -0,0 +1,42 @@
+# syntax=docker/dockerfile:1.3
+FROM python:3.12-slim
+COPY --from=ghcr.io/astral-sh/uv:0.6.4 /uv /uvx /bin/
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    htop \
+    vim \
+    curl \
+    tar \
+    python3-dev \
+    postgresql-client \
+    build-essential \
+    libpq-dev \
+    gcc \
+    cmake \
+    netcat-openbsd \
+    nodejs \
+    npm \ 
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/**
+
+RUN uv pip install --system --upgrade pip setuptools wheel
+
+ENV UV_HTTP_TIMEOUT=1000
+
+# Copy just the pyproject.toml file to optimize caching
+COPY {{ project_path_from_build_root }}/pyproject.toml /app/{{ project_path_from_build_root }}/pyproject.toml
+
+WORKDIR /app/{{ project_path_from_build_root }}
+
+# Install the required Python packages using uv
+RUN uv pip install --system .
+
+# Copy the project code
+COPY {{ project_path_from_build_root }}/project /app/{{ project_path_from_build_root }}/project
+
+# Set environment variables
+ENV PYTHONPATH=/app
+
+# Run the agent using uvicorn
+CMD ["uvicorn", "project.acp:acp", "--host", "0.0.0.0", "--port", "8000"]