signalwire-agents 1.0.7__py3-none-any.whl → 1.0.17.dev4__py3-none-any.whl

signalwire_agents/cli/init_project.py

@@ -18,6 +18,22 @@ from pathlib import Path
 from typing import Optional, Dict, List, Any
 
 
+# Cloud platform options
+CLOUD_PLATFORMS = {
+    "local": "Local Agent (FastAPI/uvicorn server)",
+    "aws": "AWS Lambda Function",
+    "gcp": "Google Cloud Function",
+    "azure": "Azure Function",
+}
+
+# Default regions per platform
+DEFAULT_REGIONS = {
+    "aws": "us-east-1",
+    "gcp": "us-central1",
+    "azure": "eastus",
+}
+
+
 # ANSI colors
 class Colors:
     RED = '\033[0;31m'
@@ -195,12 +211,968 @@ SWML_PROXY_URL_BASE=https://your-domain.ngrok.io
 DEBUG_WEBHOOK_LEVEL=1
 '''
 
-TEMPLATE_REQUIREMENTS = '''signalwire-agents>=1.0.6
+TEMPLATE_REQUIREMENTS = '''signalwire-agents>=1.0.10
 python-dotenv>=1.0.0
 requests>=2.28.0
 pytest>=7.0.0
 '''
 
+# =============================================================================
+# Cloud Function Templates
+# =============================================================================
+
+# AWS Lambda Templates
+AWS_REQUIREMENTS_TEMPLATE = '''signalwire-agents>=1.0.10
+h11>=0.13,<0.15
+fastapi
+mangum
+uvicorn
+'''
+
+AWS_HANDLER_TEMPLATE = '''#!/usr/bin/env python3
+"""AWS Lambda handler for {agent_name} agent.
+
+This demonstrates deploying a SignalWire AI Agent to AWS Lambda
+with SWAIG functions and SWML output.
+
+Environment variables:
+    SWML_BASIC_AUTH_USER: Basic auth username (optional)
+    SWML_BASIC_AUTH_PASSWORD: Basic auth password (optional)
+"""
+
+import os
+from signalwire_agents import AgentBase, SwaigFunctionResult
+
+
+class {agent_class}(AgentBase):
+    """{agent_name} agent for AWS Lambda deployment."""
+
+    def __init__(self):
+        super().__init__(name="{agent_name_slug}")
+
+        self._configure_prompts()
+        self.add_language("English", "en-US", "rime.spore")
+        self._setup_functions()
+
+    def _configure_prompts(self):
+        self.prompt_add_section(
+            "Role",
+            "You are a helpful AI assistant deployed on AWS Lambda."
+        )
+
+        self.prompt_add_section(
+            "Guidelines",
+            bullets=[
+                "Be professional and courteous",
+                "Ask clarifying questions when needed",
+                "Keep responses concise and helpful"
+            ]
+        )
+
+    def _setup_functions(self):
+        @self.tool(
+            description="Get information about a topic",
+            parameters={{
+                "type": "object",
+                "properties": {{
+                    "topic": {{
+                        "type": "string",
+                        "description": "The topic to get information about"
+                    }}
+                }},
+                "required": ["topic"]
+            }}
+        )
+        def get_info(args, raw_data):
+            topic = args.get("topic", "")
+            return SwaigFunctionResult(
+                f"Information about {{topic}}: This is a placeholder response."
+            )
+
+        @self.tool(description="Get AWS Lambda deployment information")
+        def get_platform_info(args, raw_data):
+            region = os.getenv("AWS_REGION", "unknown")
+            function_name = os.getenv("AWS_LAMBDA_FUNCTION_NAME", "unknown")
+            memory = os.getenv("AWS_LAMBDA_FUNCTION_MEMORY_SIZE", "unknown")
+            runtime = os.getenv("AWS_EXECUTION_ENV", "unknown")
+
+            return SwaigFunctionResult(
+                f"Running on AWS Lambda. "
+                f"Function: {{function_name}}, Region: {{region}}, "
+                f"Memory: {{memory}}MB, Runtime: {{runtime}}."
+            )
+
+
+# Create agent instance outside handler for warm starts
+agent = {agent_class}()
+
+
+def lambda_handler(event, context):
+    """AWS Lambda entry point.
+
+    Args:
+        event: Lambda event (API Gateway request)
+        context: Lambda context with runtime info
+
+    Returns:
+        API Gateway response dict
+    """
+    return agent.run(event, context)
+'''
+
+AWS_DEPLOY_TEMPLATE = '''#!/bin/bash
+# AWS Lambda deployment script for {agent_name} agent
+#
+# Prerequisites:
+#   - AWS CLI configured with appropriate credentials
+#   - Docker installed and running (for building Lambda-compatible packages)
+#
+# Usage:
+#   ./deploy.sh                    # Deploy with defaults
+#   ./deploy.sh my-function        # Deploy with custom function name
+#   ./deploy.sh my-function us-west-2  # Custom function and region
+
+set -e
+
+# Configuration
+FUNCTION_NAME="${{1:-{function_name}}}"
+REGION="${{2:-{region}}}"
+RUNTIME="python3.11"
+HANDLER="handler.lambda_handler"
+MEMORY_SIZE=512
+TIMEOUT=30
+ROLE_NAME="${{FUNCTION_NAME}}-role"
+
+# Default credentials (change these or set via environment)
+AUTH_USER="${{SWML_BASIC_AUTH_USER:-{auth_user}}}"
+AUTH_PASS="${{SWML_BASIC_AUTH_PASSWORD:-{auth_password}}}"
+
+echo "=== {agent_name} - AWS Lambda Deployment ==="
+echo "Function: $FUNCTION_NAME"
+echo "Region: $REGION"
+echo ""
+
+# Check for Docker
+if ! command -v docker &> /dev/null; then
+    echo "ERROR: Docker is required but not installed."
+    echo "Please install Docker: https://docs.docker.com/get-docker/"
+    exit 1
+fi
+
+if ! docker info &> /dev/null; then
+    echo "ERROR: Docker is not running. Please start Docker."
+    exit 1
+fi
+
+# Get AWS account ID
+ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
+ROLE_ARN="arn:aws:iam::${{ACCOUNT_ID}}:role/${{ROLE_NAME}}"
+
+# Step 1: Create IAM role if it doesn't exist
+echo "Step 1: Setting up IAM role..."
+
+TRUST_POLICY='{{
+  "Version": "2012-10-17",
+  "Statement": [
+    {{
+      "Effect": "Allow",
+      "Principal": {{
+        "Service": "lambda.amazonaws.com"
+      }},
+      "Action": "sts:AssumeRole"
+    }}
+  ]
+}}'
+
+if ! aws iam get-role --role-name "$ROLE_NAME" --region "$REGION" 2>/dev/null; then
+    echo "Creating IAM role: $ROLE_NAME"
+    aws iam create-role \\
+        --role-name "$ROLE_NAME" \\
+        --assume-role-policy-document "$TRUST_POLICY" \\
+        --region "$REGION"
+
+    # Attach basic Lambda execution policy
+    aws iam attach-role-policy \\
+        --role-name "$ROLE_NAME" \\
+        --policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole" \\
+        --region "$REGION"
+
+    echo "Waiting for role to propagate..."
+    sleep 10
+else
+    echo "IAM role already exists: $ROLE_NAME"
+fi
+
+# Step 2: Package the function using Docker
+echo ""
+echo "Step 2: Packaging function with Docker (linux/amd64)..."
+
+SCRIPT_DIR="$(cd "$(dirname "${{BASH_SOURCE[0]}}")" && pwd)"
+BUILD_DIR=$(mktemp -d)
+PACKAGE_DIR="$BUILD_DIR/package"
+ZIP_FILE="$BUILD_DIR/function.zip"
+
+mkdir -p "$PACKAGE_DIR"
+
+# Build dependencies using Lambda Python image for correct architecture
+echo "Installing dependencies via Docker..."
+docker run --rm \\
+    --platform linux/amd64 \\
+    --entrypoint "" \\
+    -v "$SCRIPT_DIR:/var/task:ro" \\
+    -v "$PACKAGE_DIR:/var/output" \\
+    -w /var/task \\
+    public.ecr.aws/lambda/python:3.11 \\
+    bash -c "pip install -r requirements.txt -t /var/output --quiet && cp handler.py /var/output/"
+
+# Create zip
+echo "Creating deployment package..."
+cd "$PACKAGE_DIR"
+zip -r "$ZIP_FILE" . -q
+cd - > /dev/null
+
+PACKAGE_SIZE=$(du -h "$ZIP_FILE" | cut -f1)
+echo "Package size: $PACKAGE_SIZE"
+
+# Step 3: Create or update Lambda function
+echo ""
+echo "Step 3: Deploying Lambda function..."
+
+if aws lambda get-function --function-name "$FUNCTION_NAME" --region "$REGION" 2>/dev/null; then
+    echo "Updating existing function..."
+    aws lambda update-function-code \\
+        --function-name "$FUNCTION_NAME" \\
+        --zip-file "fileb://$ZIP_FILE" \\
+        --region "$REGION" \\
+        --cli-read-timeout 300 \\
+        --output text --query 'FunctionArn'
+else
+    echo "Creating new function..."
+    aws lambda create-function \\
+        --function-name "$FUNCTION_NAME" \\
+        --runtime "$RUNTIME" \\
+        --role "$ROLE_ARN" \\
+        --handler "$HANDLER" \\
+        --zip-file "fileb://$ZIP_FILE" \\
+        --memory-size "$MEMORY_SIZE" \\
+        --timeout "$TIMEOUT" \\
+        --region "$REGION" \\
+        --cli-read-timeout 300 \\
+        --environment "Variables={{SWML_BASIC_AUTH_USER=$AUTH_USER,SWML_BASIC_AUTH_PASSWORD=$AUTH_PASS}}" \\
+        --output text --query 'FunctionArn'
+fi
+
+# Wait for function to be active
+echo "Waiting for function to be active..."
+aws lambda wait function-active --function-name "$FUNCTION_NAME" --region "$REGION"
+
+# Step 4: Create or get API Gateway
+echo ""
+echo "Step 4: Setting up API Gateway..."
+
+API_NAME="${{FUNCTION_NAME}}-api"
+
+# Check if API exists
+API_ID=$(aws apigatewayv2 get-apis --region "$REGION" \\
+    --query "Items[?Name=='$API_NAME'].ApiId" --output text)
+
+if [ -z "$API_ID" ] || [ "$API_ID" == "None" ]; then
+    echo "Creating HTTP API..."
+    API_ID=$(aws apigatewayv2 create-api \\
+        --name "$API_NAME" \\
+        --protocol-type HTTP \\
+        --region "$REGION" \\
+        --output text --query 'ApiId')
+fi
+
+echo "API ID: $API_ID"
+
+# Step 5: Create Lambda integration
+echo ""
+echo "Step 5: Creating Lambda integration..."
+
+LAMBDA_ARN="arn:aws:lambda:${{REGION}}:${{ACCOUNT_ID}}:function:${{FUNCTION_NAME}}"
+
+# Check for existing integration
+INTEGRATION_ID=$(aws apigatewayv2 get-integrations \\
+    --api-id "$API_ID" \\
+    --region "$REGION" \\
+    --query "Items[?IntegrationUri=='${{LAMBDA_ARN}}'].IntegrationId" \\
+    --output text 2>/dev/null || echo "")
+
+if [ -z "$INTEGRATION_ID" ] || [ "$INTEGRATION_ID" == "None" ]; then
+    echo "Creating integration..."
+    INTEGRATION_ID=$(aws apigatewayv2 create-integration \\
+        --api-id "$API_ID" \\
+        --integration-type AWS_PROXY \\
+        --integration-uri "$LAMBDA_ARN" \\
+        --payload-format-version "2.0" \\
+        --region "$REGION" \\
+        --output text --query 'IntegrationId')
+fi
+
+echo "Integration ID: $INTEGRATION_ID"
+
+# Step 6: Create routes
+echo ""
+echo "Step 6: Creating routes..."
+
+create_route() {{
+    local route_key="$1"
+    local existing=$(aws apigatewayv2 get-routes \\
+        --api-id "$API_ID" \\
+        --region "$REGION" \\
+        --query "Items[?RouteKey=='$route_key'].RouteId" \\
+        --output text 2>/dev/null || echo "")
+
+    if [ -z "$existing" ] || [ "$existing" == "None" ]; then
+        echo "Creating route: $route_key"
+        aws apigatewayv2 create-route \\
+            --api-id "$API_ID" \\
+            --route-key "$route_key" \\
+            --target "integrations/$INTEGRATION_ID" \\
+            --region "$REGION" \\
+            --output text --query 'RouteId'
+    else
+        echo "Route exists: $route_key"
+    fi
+}}
+
+# Create routes for SWML and SWAIG
+create_route "GET /"
+create_route "POST /"
+create_route "POST /swaig"
+create_route "ANY /{{proxy+}}"
+
+# Step 7: Create/update stage
+echo ""
+echo "Step 7: Deploying stage..."
+
+STAGE_NAME="\\$default"
+
+if ! aws apigatewayv2 get-stage --api-id "$API_ID" --stage-name "$STAGE_NAME" --region "$REGION" 2>/dev/null; then
+    aws apigatewayv2 create-stage \\
+        --api-id "$API_ID" \\
+        --stage-name "$STAGE_NAME" \\
+        --auto-deploy \\
+        --region "$REGION" > /dev/null
+fi
+
+# Step 8: Add Lambda permission for API Gateway
+echo ""
+echo "Step 8: Configuring permissions..."
+
+STATEMENT_ID="${{API_NAME}}-invoke"
+
+# Remove existing permission if it exists (ignore errors)
+aws lambda remove-permission \\
+    --function-name "$FUNCTION_NAME" \\
+    --statement-id "$STATEMENT_ID" \\
+    --region "$REGION" 2>/dev/null || true
+
+# Add permission
+aws lambda add-permission \\
+    --function-name "$FUNCTION_NAME" \\
+    --statement-id "$STATEMENT_ID" \\
+    --action lambda:InvokeFunction \\
+    --principal apigateway.amazonaws.com \\
+    --source-arn "arn:aws:execute-api:${{REGION}}:${{ACCOUNT_ID}}:${{API_ID}}/*" \\
+    --region "$REGION" > /dev/null
+
+# Get the endpoint URL
+ENDPOINT="https://${{API_ID}}.execute-api.${{REGION}}.amazonaws.com"
+
+# Cleanup
+rm -rf "$BUILD_DIR"
+
+echo ""
+echo "=== Deployment Complete ==="
+echo ""
+echo "Endpoint URL: $ENDPOINT"
+echo ""
+echo "Authentication:"
+echo "  Username: $AUTH_USER"
+echo "  Password: $AUTH_PASS"
+echo ""
+echo "Test SWML output:"
+echo "  curl -u $AUTH_USER:$AUTH_PASS $ENDPOINT/"
+echo ""
+echo "Test SWAIG function:"
+echo "  curl -u $AUTH_USER:$AUTH_PASS -X POST $ENDPOINT/swaig \\\\"
+echo "    -H 'Content-Type: application/json' \\\\"
+echo "    -d '{{\\\"function\\\": \\\"get_info\\\", \\\"argument\\\": {{\\\"parsed\\\": [{{\\\"topic\\\": \\\"test\\\"}}]}}}}'"
+echo ""
+echo "Configure SignalWire:"
+echo "  Set your phone number's SWML URL to: https://$AUTH_USER:$AUTH_PASS@${{API_ID}}.execute-api.${{REGION}}.amazonaws.com/"
+echo ""
+'''
+
+# GCP Cloud Function Templates
+GCP_REQUIREMENTS_TEMPLATE = '''signalwire-agents>=1.0.10
+functions-framework>=3.0.0
+'''
+
+GCP_MAIN_TEMPLATE = '''#!/usr/bin/env python3
+"""Google Cloud Functions handler for {agent_name} agent.
+
+This demonstrates deploying a SignalWire AI Agent to Google Cloud Functions
+with SWAIG functions and SWML output.
+
+Environment variables:
+    SWML_BASIC_AUTH_USER: Basic auth username (optional)
+    SWML_BASIC_AUTH_PASSWORD: Basic auth password (optional)
+"""
+
+import os
+from signalwire_agents import AgentBase, SwaigFunctionResult
+
+
+class {agent_class}(AgentBase):
+    """{agent_name} agent for Google Cloud Functions deployment."""
+
+    def __init__(self):
+        super().__init__(name="{agent_name_slug}")
+
+        self._configure_prompts()
+        self.add_language("English", "en-US", "rime.spore")
+        self._setup_functions()
+
+    def _configure_prompts(self):
+        self.prompt_add_section(
+            "Role",
+            "You are a helpful AI assistant deployed on Google Cloud Functions."
+        )
+
+        self.prompt_add_section(
+            "Guidelines",
+            bullets=[
+                "Be professional and courteous",
+                "Ask clarifying questions when needed",
+                "Keep responses concise and helpful"
+            ]
+        )
+
+    def _setup_functions(self):
+        @self.tool(
+            description="Get information about a topic",
+            parameters={{
+                "type": "object",
+                "properties": {{
+                    "topic": {{
+                        "type": "string",
+                        "description": "The topic to get information about"
+                    }}
+                }},
+                "required": ["topic"]
+            }}
+        )
+        def get_info(args, raw_data):
+            topic = args.get("topic", "")
+            return SwaigFunctionResult(
+                f"Information about {{topic}}: This is a placeholder response."
+            )
+
+        @self.tool(description="Get Google Cloud deployment information")
+        def get_platform_info(args, raw_data):
+            import urllib.request
+
+            # Gen 2 Cloud Functions run on Cloud Run with these env vars
+            service = os.getenv("K_SERVICE", "unknown")
+            revision = os.getenv("K_REVISION", "unknown")
+
+            # Query metadata server for project ID
+            project = os.getenv("GOOGLE_CLOUD_PROJECT", "unknown")
+            if project == "unknown":
+                try:
+                    req = urllib.request.Request(
+                        "http://metadata.google.internal/computeMetadata/v1/project/project-id",
+                        headers={{"Metadata-Flavor": "Google"}}
+                    )
+                    with urllib.request.urlopen(req, timeout=2) as resp:
+                        project = resp.read().decode()
+                except Exception:
+                    pass
+
+            return SwaigFunctionResult(
+                f"Running on Google Cloud Functions Gen 2. "
+                f"Service: {{service}}, Revision: {{revision}}, "
+                f"Project: {{project}}."
+            )
+
+
+# Create agent instance outside handler for warm starts
+agent = {agent_class}()
+
+
+def main(request):
+    """Google Cloud Functions entry point.
+
+    Args:
+        request: Flask request object
+
+    Returns:
+        Flask response
+    """
+    return agent.run(request)
+'''
+
+GCP_DEPLOY_TEMPLATE = '''#!/bin/bash
+# Google Cloud Functions deployment script for {agent_name} agent
+#
+# Prerequisites:
+#   - gcloud CLI installed and authenticated
+#   - A Google Cloud project with Cloud Functions API enabled
+#
+# Usage:
+#   ./deploy.sh                           # Deploy with defaults
+#   ./deploy.sh my-function               # Custom function name
+#   ./deploy.sh my-function us-central1   # Custom function and region
+
+set -e
+
+# Configuration
+FUNCTION_NAME="${{1:-{function_name}}}"
+REGION="${{2:-{region}}}"
+RUNTIME="python311"
+ENTRY_POINT="main"
+MEMORY="512MB"
+TIMEOUT="60s"
+MIN_INSTANCES=0
+MAX_INSTANCES=10
+
+# Directory containing this script
+SCRIPT_DIR="$(cd "$(dirname "${{BASH_SOURCE[0]}}")" && pwd)"
+
+echo "=== {agent_name} - Google Cloud Functions Deployment ==="
+echo "Function: $FUNCTION_NAME"
+echo "Region: $REGION"
+echo ""
+
+# Get current project
+PROJECT=$(gcloud config get-value project 2>/dev/null)
+if [ -z "$PROJECT" ]; then
+    echo "Error: No project set. Run: gcloud config set project <project-id>"
+    exit 1
+fi
+echo "Project: $PROJECT"
+echo ""
+
+# Step 1: Enable required APIs
+echo "Step 1: Enabling required APIs..."
+gcloud services enable cloudfunctions.googleapis.com --quiet
+gcloud services enable cloudbuild.googleapis.com --quiet
+gcloud services enable artifactregistry.googleapis.com --quiet
+
+# Step 2: Create deployment package
+echo ""
+echo "Step 2: Creating deployment package..."
+
+# Create a temporary deployment directory
+DEPLOY_DIR=$(mktemp -d)
+trap "rm -rf $DEPLOY_DIR" EXIT
+
+# Copy the main files
+cp "$SCRIPT_DIR/main.py" "$DEPLOY_DIR/"
+cp "$SCRIPT_DIR/requirements.txt" "$DEPLOY_DIR/"
+
+echo "Deployment package contents:"
+ls -la "$DEPLOY_DIR/"
+
+# Step 3: Deploy function
+echo ""
+echo "Step 3: Deploying Cloud Function..."
+
+# Check if function exists (Gen 2 vs Gen 1)
+EXISTING_GEN2=$(gcloud functions describe "$FUNCTION_NAME" --region="$REGION" --gen2 2>/dev/null && echo "yes" || echo "no")
+
+if [ "$EXISTING_GEN2" == "yes" ]; then
+    echo "Updating existing Gen 2 function..."
+else
+    echo "Creating new Gen 2 function..."
+fi
+
+gcloud functions deploy "$FUNCTION_NAME" \\
+    --gen2 \\
+    --region="$REGION" \\
+    --runtime="$RUNTIME" \\
+    --source="$DEPLOY_DIR" \\
+    --entry-point="$ENTRY_POINT" \\
+    --trigger-http \\
+    --allow-unauthenticated \\
+    --memory="$MEMORY" \\
+    --timeout="$TIMEOUT" \\
+    --min-instances="$MIN_INSTANCES" \\
+    --max-instances="$MAX_INSTANCES" \\
+    --quiet
+
+# Step 4: Get the endpoint URL
+echo ""
+echo "Step 4: Getting endpoint URL..."
+
+ENDPOINT=$(gcloud functions describe "$FUNCTION_NAME" \\
+    --region="$REGION" \\
+    --gen2 \\
+    --format="value(serviceConfig.uri)")
+
+echo ""
+echo "=== Deployment Complete ==="
+echo ""
+echo "Endpoint URL: $ENDPOINT"
+echo ""
+echo "Test SWML output:"
+echo "  curl $ENDPOINT"
+echo ""
+echo "Test SWAIG function:"
+echo "  curl -X POST $ENDPOINT/swaig \\\\"
+echo "    -H 'Content-Type: application/json' \\\\"
+echo "    -d '{{\\\"function\\\": \\\"get_info\\\", \\\"argument\\\": {{\\\"parsed\\\": [{{\\\"topic\\\": \\\"test\\\"}}]}}}}'"
+echo ""
+echo "Configure SignalWire:"
+echo "  Set your phone number's SWML URL to: $ENDPOINT"
+echo ""
+echo "To set environment variables (optional):"
+echo "  gcloud functions deploy $FUNCTION_NAME \\\\"
+echo "    --region=$REGION \\\\"
+echo "    --gen2 \\\\"
+echo "    --update-env-vars SWML_BASIC_AUTH_USER=myuser,SWML_BASIC_AUTH_PASSWORD=mypass"
+echo ""
+'''
+
+# Azure Function Templates
+AZURE_REQUIREMENTS_TEMPLATE = '''azure-functions>=1.17.0
+signalwire-agents>=1.0.10
+'''
+
+AZURE_INIT_TEMPLATE = '''#!/usr/bin/env python3
+"""Azure Functions handler for {agent_name} agent.
+
+This demonstrates deploying a SignalWire AI Agent to Azure Functions
+with SWAIG functions and SWML output.
+
+Environment variables:
+    SWML_BASIC_AUTH_USER: Basic auth username (optional)
+    SWML_BASIC_AUTH_PASSWORD: Basic auth password (optional)
+"""
+
+import os
+import azure.functions as func
+from signalwire_agents import AgentBase, SwaigFunctionResult
+
+
+class {agent_class}(AgentBase):
+    """{agent_name} agent for Azure Functions deployment."""
+
+    def __init__(self):
+        super().__init__(name="{agent_name_slug}")
+
+        self._configure_prompts()
+        self.add_language("English", "en-US", "rime.spore")
+        self._setup_functions()
+
+    def _configure_prompts(self):
+        self.prompt_add_section(
+            "Role",
+            "You are a helpful AI assistant deployed on Azure Functions."
+        )
+
+        self.prompt_add_section(
+            "Guidelines",
+            bullets=[
+                "Be professional and courteous",
+                "Ask clarifying questions when needed",
+                "Keep responses concise and helpful"
+            ]
+        )
+
+    def _setup_functions(self):
+        @self.tool(
+            description="Get information about a topic",
+            parameters={{
+                "type": "object",
+                "properties": {{
+                    "topic": {{
+                        "type": "string",
+                        "description": "The topic to get information about"
+                    }}
+                }},
+                "required": ["topic"]
+            }}
+        )
+        def get_info(args, raw_data):
+            topic = args.get("topic", "")
+            return SwaigFunctionResult(
+                f"Information about {{topic}}: This is a placeholder response."
+            )
+
+        @self.tool(description="Get Azure Functions deployment information")
+        def get_platform_info(args, raw_data):
+            function_name = os.getenv("WEBSITE_SITE_NAME", "unknown")
+            region = os.getenv("REGION_NAME", "unknown")
+            runtime = os.getenv("FUNCTIONS_WORKER_RUNTIME", "unknown")
+            version = os.getenv("FUNCTIONS_EXTENSION_VERSION", "unknown")
+
+            return SwaigFunctionResult(
+                f"Running on Azure Functions. "
+                f"App: {{function_name}}, Region: {{region}}, "
+                f"Runtime: {{runtime}}, Version: {{version}}."
+            )
+
+
+# Create agent instance outside handler for warm starts
+agent = {agent_class}()
+
+
+def main(req: func.HttpRequest) -> func.HttpResponse:
+    """Azure Functions entry point.
+
+    Args:
+        req: Azure Functions HTTP request object
+
+    Returns:
+        Azure Functions HTTP response
+    """
+    return agent.run(req)
+'''
+
+AZURE_FUNCTION_JSON_TEMPLATE = '''{{
+    "scriptFile": "__init__.py",
+    "bindings": [
+        {{
+            "authLevel": "anonymous",
+            "type": "httpTrigger",
+            "direction": "in",
+            "name": "req",
+            "methods": ["get", "post"],
+            "route": "{{*path}}"
+        }},
+        {{
+            "type": "http",
+            "direction": "out",
+            "name": "$return"
+        }}
+    ]
+}}
+'''
+
+AZURE_HOST_JSON_TEMPLATE = '''{{
+    "version": "2.0",
+    "logging": {{
+        "applicationInsights": {{
+            "samplingSettings": {{
+                "isEnabled": true,
+                "excludedTypes": "Request"
+            }}
+        }}
+    }},
+    "extensionBundle": {{
+        "id": "Microsoft.Azure.Functions.ExtensionBundle",
+        "version": "[4.*, 5.0.0)"
+    }},
+    "extensions": {{
+        "http": {{
+            "routePrefix": ""
+        }}
+    }}
+}}
+'''
+
+AZURE_LOCAL_SETTINGS_TEMPLATE = '''{{
+    "IsEncrypted": false,
+    "Values": {{
+        "FUNCTIONS_WORKER_RUNTIME": "python",
+        "AzureWebJobsStorage": ""
+    }}
+}}
+'''
+
+AZURE_DEPLOY_TEMPLATE = '''#!/bin/bash
+# Azure Functions deployment script for {agent_name} agent
+#
+# Prerequisites:
+#   - Azure CLI installed and authenticated (az login)
+#   - Docker installed and running (for building correct architecture)
+#
+# Usage:
+#   ./deploy.sh                              # Deploy with defaults
+#   ./deploy.sh my-app                       # Custom app name
+#   ./deploy.sh my-app eastus my-rg          # Custom app, region, and resource group
+
+set -e
+
+# Configuration
+APP_NAME="${{1:-{function_name}}}"
+LOCATION="${{2:-{region}}}"
+RESOURCE_GROUP="${{3:-{resource_group}}}"
+STORAGE_ACCOUNT="${{APP_NAME//-/}}storage"  # Remove hyphens for storage account
+RUNTIME="python"
+RUNTIME_VERSION="3.11"
+FUNCTIONS_VERSION="4"
+
+# Truncate storage account name to 24 chars (Azure limit)
+STORAGE_ACCOUNT="${{STORAGE_ACCOUNT:0:24}}"
+
+SCRIPT_DIR="$(cd "$(dirname "${{BASH_SOURCE[0]}}")" && pwd)"
+
+echo "=== {agent_name} - Azure Functions Deployment ==="
+echo "App Name: $APP_NAME"
+echo "Location: $LOCATION"
+echo "Resource Group: $RESOURCE_GROUP"
+echo "Storage Account: $STORAGE_ACCOUNT"
+echo ""
+
+# Check for Docker
+if ! command -v docker &> /dev/null; then
+    echo "ERROR: Docker is required but not installed."
+    echo "Please install Docker: https://docs.docker.com/get-docker/"
+    exit 1
+fi
+
+if ! docker info &> /dev/null; then
+    echo "ERROR: Docker is not running. Please start Docker."
+    exit 1
+fi
+
+# Step 1: Login check
+echo "Step 1: Checking Azure login..."
+if ! az account show &>/dev/null; then
+    echo "Not logged in. Running: az login"
+    az login
+fi
+
+SUBSCRIPTION=$(az account show --query name -o tsv)
+echo "Subscription: $SUBSCRIPTION"
+echo ""
+
+# Step 2: Create resource group
+echo "Step 2: Creating resource group..."
+if ! az group show --name "$RESOURCE_GROUP" &>/dev/null; then
+    az group create \\
+        --name "$RESOURCE_GROUP" \\
+        --location "$LOCATION" \\
+        --output none
+    echo "Created resource group: $RESOURCE_GROUP"
+else
+    echo "Resource group exists: $RESOURCE_GROUP"
+fi
+
+# Step 3: Create storage account
+echo ""
+echo "Step 3: Creating storage account..."
+if ! az storage account show --name "$STORAGE_ACCOUNT" --resource-group "$RESOURCE_GROUP" &>/dev/null; then
+    az storage account create \\
+        --name "$STORAGE_ACCOUNT" \\
+        --resource-group "$RESOURCE_GROUP" \\
+        --location "$LOCATION" \\
+        --sku Standard_LRS \\
+        --output none
+    echo "Created storage account: $STORAGE_ACCOUNT"
+    echo "Waiting for storage account to propagate..."
+    sleep 10
+else
+    echo "Storage account exists: $STORAGE_ACCOUNT"
+fi
+
+# Step 4: Create Function App
+echo ""
+echo "Step 4: Creating Function App..."
+if ! az functionapp show --name "$APP_NAME" --resource-group "$RESOURCE_GROUP" &>/dev/null; then
+    az functionapp create \\
+        --name "$APP_NAME" \\
+        --resource-group "$RESOURCE_GROUP" \\
+        --storage-account "$STORAGE_ACCOUNT" \\
+        --consumption-plan-location "$LOCATION" \\
+        --runtime "$RUNTIME" \\
+        --runtime-version "$RUNTIME_VERSION" \\
+        --functions-version "$FUNCTIONS_VERSION" \\
+        --os-type Linux \\
+        --output none
+    echo "Created Function App: $APP_NAME"
+
+    # Wait for app to be ready
+    echo "Waiting for Function App to be ready..."
+    sleep 30
+else
+    echo "Function App exists: $APP_NAME"
+fi
+
+# Step 5: Build and deploy the function using Docker
+echo ""
+echo "Step 5: Building function with Docker (linux/amd64)..."
+
+DEPLOY_DIR=$(mktemp -d)
+
+# Copy function files
+cp -r "$SCRIPT_DIR/function_app" "$DEPLOY_DIR/"
+cp "$SCRIPT_DIR/host.json" "$DEPLOY_DIR/"
+cp "$SCRIPT_DIR/requirements.txt" "$DEPLOY_DIR/"
+cp "$SCRIPT_DIR/local.settings.json" "$DEPLOY_DIR/" 2>/dev/null || true
+
+# Build dependencies using Docker for correct architecture
+echo "Installing dependencies via Docker..."
+docker run --rm \\
+    --platform linux/amd64 \\
+    --entrypoint "" \\
+    -v "$DEPLOY_DIR:/var/task" \\
+    -w /var/task \\
+    mcr.microsoft.com/azure-functions/python:4-python3.11 \\
+    bash -c "pip install -r requirements.txt -t .python_packages/lib/site-packages --quiet"
+
+# Create zip for deployment
+echo "Creating deployment package..."
+ZIP_FILE="$DEPLOY_DIR/deploy.zip"
+cd "$DEPLOY_DIR"
+zip -r "$ZIP_FILE" . -x "*.pyc" -q
+cd - > /dev/null
+
+PACKAGE_SIZE=$(du -h "$ZIP_FILE" | cut -f1)
+echo "Package size: $PACKAGE_SIZE"
+
+# Deploy using zip deployment
+echo ""
+echo "Step 6: Deploying to Azure..."
+az functionapp deployment source config-zip \\
+    --name "$APP_NAME" \\
+    --resource-group "$RESOURCE_GROUP" \\
+    --src "$ZIP_FILE" \\
+    --output none
+
+echo "Deployment complete"
+
+# Cleanup
+rm -rf "$DEPLOY_DIR"
+
+# Step 7: Get the endpoint URL
+echo ""
+echo "Step 7: Getting endpoint URL..."
+
+ENDPOINT="https://${{APP_NAME}}.azurewebsites.net"
+
+# Verify deployment
+echo "Waiting for deployment to propagate..."
+sleep 10
+
+echo ""
+echo "=== Deployment Complete ==="
+echo ""
+echo "Endpoint URL: $ENDPOINT/api/function_app"
+echo ""
+echo "Test SWML output:"
+echo "  curl $ENDPOINT/api/function_app"
+echo ""
+echo "Test SWAIG function:"
+echo "  curl -X POST $ENDPOINT/api/function_app/swaig \\\\"
+echo "    -H 'Content-Type: application/json' \\\\"
+echo "    -d '{{\\\"function\\\": \\\"get_info\\\", \\\"argument\\\": {{\\\"parsed\\\": [{{\\\"topic\\\": \\\"test\\\"}}]}}}}'"
+echo ""
+echo "Configure SignalWire:"
+echo "  Set your phone number's SWML URL to: $ENDPOINT/api/function_app"
+echo ""
+echo "To set environment variables (optional):"
+echo "  az functionapp config appsettings set --name $APP_NAME --resource-group $RESOURCE_GROUP \\\\"
+echo "    --settings SWML_BASIC_AUTH_USER=myuser SWML_BASIC_AUTH_PASSWORD=mypass"
+echo ""
+'''
+
 
 def get_agent_template(agent_type: str, features: Dict[str, bool]) -> str:
     """Generate the main agent template based on type and features."""
@@ -381,6 +1353,13 @@ def get_app_template(features: Dict[str, bool]) -> str:
 
     imports_str = '\n'.join(imports)
 
+    # Create agent at module level for swaig-test compatibility
+    agent_instance = '''
+
+# Create agent instance at module level for swaig-test compatibility
+agent = MainAgent()
+'''
+
     # Debug webhook code
     debug_code = ''
     if has_debug:
@@ -480,7 +1459,7 @@ def main():
 
     # Create server and register agent
     server = AgentServer(host=host, port=port)
-    server.register(MainAgent())
+    server.register(agent)
 ''']
 
     if has_web_ui:
@@ -538,6 +1517,7 @@ if __name__ == "__main__":
 """Main entry point for the agent server."""
 
 {imports_str}
+{agent_instance}
 {debug_code}
 {main_body}'''
 
@@ -872,31 +1852,397 @@ class ProjectGenerator:
         self.project_dir = Path(config['project_dir'])
         self.project_name = config['project_name']
         self.features = config['features']
-        self.credentials = config['credentials']
+        self.credentials = config.get('credentials', {})
+        self.platform = config.get('platform', 'local')
+        self.cloud_config = config.get('cloud_config', {})
 
     def generate(self) -> bool:
         """Generate the project. Returns True on success."""
         try:
-            self._create_directories()
-            self._create_agent_files()
-            self._create_app_file()
-            self._create_config_files()
+            if self.platform == 'local':
+                return self._generate_local()
+            elif self.platform == 'aws':
+                return self._generate_aws()
+            elif self.platform == 'gcp':
+                return self._generate_gcp()
+            elif self.platform == 'azure':
+                return self._generate_azure()
+            else:
+                print_error(f"Unknown platform: {self.platform}")
+                return False
+        except Exception as e:
+            print_error(f"Failed to generate project: {e}")
+            return False
 
-            if self.features.get('tests'):
-                self._create_test_files()
+    def _generate_local(self) -> bool:
+        """Generate a local agent project."""
+        self._create_directories()
+        self._create_agent_files()
+        self._create_app_file()
+        self._create_config_files()
 
-            if self.features.get('web_ui'):
-                self._create_web_files()
+        if self.features.get('tests'):
+            self._create_test_files()
 
-            self._create_readme()
+        if self.features.get('web_ui'):
+            self._create_web_files()
 
-            if self.config.get('create_venv'):
-                self._create_virtualenv()
+        self._create_readme()
 
-            return True
-        except Exception as e:
-            print_error(f"Failed to generate project: {e}")
-            return False
+        if self.config.get('create_venv'):
+            self._create_virtualenv()
+
+        return True
+
+    def _generate_aws(self) -> bool:
+        """Generate an AWS Lambda project."""
+        self.project_dir.mkdir(parents=True, exist_ok=True)
+        print_success(f"Created {self.project_dir}/")
+
+        # Get template variables
+        template_vars = self._get_template_vars()
+
+        # handler.py
+        handler_code = AWS_HANDLER_TEMPLATE.format(**template_vars)
+        (self.project_dir / 'handler.py').write_text(handler_code)
+        print_success("Created handler.py")
+
+        # requirements.txt
+        (self.project_dir / 'requirements.txt').write_text(AWS_REQUIREMENTS_TEMPLATE)
+        print_success("Created requirements.txt")
+
+        # deploy.sh
+        deploy_code = AWS_DEPLOY_TEMPLATE.format(**template_vars)
+        deploy_path = self.project_dir / 'deploy.sh'
+        deploy_path.write_text(deploy_code)
+        deploy_path.chmod(0o755)
+        print_success("Created deploy.sh")
+
+        # .env.example
+        self._create_cloud_env_example('aws')
+
+        # .gitignore
+        (self.project_dir / '.gitignore').write_text(TEMPLATE_GITIGNORE)
+        print_success("Created .gitignore")
+
+        # README.md
+        self._create_cloud_readme('aws')
+
+        return True
+
+    def _generate_gcp(self) -> bool:
+        """Generate a Google Cloud Function project."""
+        self.project_dir.mkdir(parents=True, exist_ok=True)
+        print_success(f"Created {self.project_dir}/")
+
+        # Get template variables
+        template_vars = self._get_template_vars()
+
+        # main.py
+        main_code = GCP_MAIN_TEMPLATE.format(**template_vars)
+        (self.project_dir / 'main.py').write_text(main_code)
+        print_success("Created main.py")
+
+        # requirements.txt
+        (self.project_dir / 'requirements.txt').write_text(GCP_REQUIREMENTS_TEMPLATE)
+        print_success("Created requirements.txt")
+
+        # deploy.sh
+        deploy_code = GCP_DEPLOY_TEMPLATE.format(**template_vars)
+        deploy_path = self.project_dir / 'deploy.sh'
+        deploy_path.write_text(deploy_code)
+        deploy_path.chmod(0o755)
+        print_success("Created deploy.sh")
+
+        # .env.example
+        self._create_cloud_env_example('gcp')
+
+        # .gitignore
+        (self.project_dir / '.gitignore').write_text(TEMPLATE_GITIGNORE)
+        print_success("Created .gitignore")
+
+        # README.md
+        self._create_cloud_readme('gcp')
+
+        return True
+
+    def _generate_azure(self) -> bool:
+        """Generate an Azure Functions project."""
+        self.project_dir.mkdir(parents=True, exist_ok=True)
+        print_success(f"Created {self.project_dir}/")
+
+        # Create function_app directory
+        function_dir = self.project_dir / 'function_app'
+        function_dir.mkdir(exist_ok=True)
+
+        # Get template variables
+        template_vars = self._get_template_vars()
+
+        # function_app/__init__.py
+        init_code = AZURE_INIT_TEMPLATE.format(**template_vars)
+        (function_dir / '__init__.py').write_text(init_code)
+        print_success("Created function_app/__init__.py")
+
+        # function_app/function.json
+        (function_dir / 'function.json').write_text(AZURE_FUNCTION_JSON_TEMPLATE)
+        print_success("Created function_app/function.json")
+
+        # host.json
+        (self.project_dir / 'host.json').write_text(AZURE_HOST_JSON_TEMPLATE)
+        print_success("Created host.json")
+
+        # local.settings.json
+        (self.project_dir / 'local.settings.json').write_text(AZURE_LOCAL_SETTINGS_TEMPLATE)
+        print_success("Created local.settings.json")
+
+        # requirements.txt
+        (self.project_dir / 'requirements.txt').write_text(AZURE_REQUIREMENTS_TEMPLATE)
+        print_success("Created requirements.txt")
+
+        # deploy.sh
+        deploy_code = AZURE_DEPLOY_TEMPLATE.format(**template_vars)
+        deploy_path = self.project_dir / 'deploy.sh'
+        deploy_path.write_text(deploy_code)
+        deploy_path.chmod(0o755)
+        print_success("Created deploy.sh")
+
+        # .env.example
+        self._create_cloud_env_example('azure')
+
+        # .gitignore
+        (self.project_dir / '.gitignore').write_text(TEMPLATE_GITIGNORE)
+        print_success("Created .gitignore")
+
+        # README.md
+        self._create_cloud_readme('azure')
+
+        return True
+
+    def _get_template_vars(self) -> Dict[str, str]:
+        """Get template variables for cloud function templates."""
+        # Convert project name to various formats
+        agent_name = self.project_name
+        agent_name_slug = self.project_name.lower().replace(' ', '-').replace('_', '-')
+        agent_class = ''.join(word.capitalize() for word in self.project_name.replace('-', ' ').replace('_', ' ').split()) + 'Agent'
+        function_name = agent_name_slug
+
+        # Auth credentials
+        auth_user = 'admin'
+        auth_password = generate_password(16)
+
+        return {
+            'agent_name': agent_name,
+            'agent_name_slug': agent_name_slug,
+            'agent_class': agent_class,
+            'function_name': function_name,
+            'region': self.cloud_config.get('region', DEFAULT_REGIONS.get(self.platform, '')),
+            'resource_group': self.cloud_config.get('resource_group', f'{function_name}-rg'),
+            'auth_user': auth_user,
+            'auth_password': auth_password,
+        }
+
+    def _create_cloud_env_example(self, platform: str):
+        """Create .env.example for cloud platforms."""
+        env_content = '''# Optional: Basic authentication credentials
+# If not set, the SDK will auto-generate secure credentials
+SWML_BASIC_AUTH_USER=admin
+SWML_BASIC_AUTH_PASSWORD=your-secure-password
+'''
+        (self.project_dir / '.env.example').write_text(env_content)
+        print_success("Created .env.example")
+
+    def _create_cloud_readme(self, platform: str):
+        """Create README.md for cloud platforms."""
+        template_vars = self._get_template_vars()
+        platform_names = {'aws': 'AWS Lambda', 'gcp': 'Google Cloud Functions', 'azure': 'Azure Functions'}
+        platform_name = platform_names.get(platform, platform)
+
+        if platform == 'aws':
+            readme = f'''# {self.project_name}
+
+A SignalWire AI Agent deployed on {platform_name}.
+
+## Prerequisites
+
+- AWS CLI configured with appropriate credentials
+- Docker installed and running
+
+## Quick Start
+
+```bash
+cd {self.project_name}
+./deploy.sh
+```
+
+## Deployment Options
+
+```bash
+# Deploy with defaults
+./deploy.sh
+
+# Custom function name
+./deploy.sh my-function
+
+# Custom function and region
+./deploy.sh my-function us-west-2
+```
+
+## Project Structure
+
+```
+{self.project_name}/
+├── handler.py          # Lambda handler with agent
+├── requirements.txt    # Python dependencies
+├── deploy.sh           # Deployment script
+├── .env.example        # Environment template
+└── README.md
+```
+
+## Testing
+
+After deployment, test your function:
+
+```bash
+# Test SWML output
+curl -u admin:password https://YOUR-API-ID.execute-api.REGION.amazonaws.com/
+
+# Test SWAIG function
+curl -u admin:password -X POST https://YOUR-API-ID.execute-api.REGION.amazonaws.com/swaig \\
+  -H 'Content-Type: application/json' \\
+  -d '{{"function": "get_info", "argument": {{"parsed": [{{"topic": "test"}}]}}}}'
+```
+
+## Configure SignalWire
+
+Set your phone number's SWML URL to the endpoint URL shown after deployment.
+'''
+
+        elif platform == 'gcp':
+            readme = f'''# {self.project_name}
+
+A SignalWire AI Agent deployed on {platform_name}.
+
+## Prerequisites
+
+- gcloud CLI installed and authenticated
+- A Google Cloud project with Cloud Functions API enabled
+
+## Quick Start
+
+```bash
+cd {self.project_name}
+./deploy.sh
+```
+
+## Deployment Options
+
+```bash
+# Deploy with defaults
+./deploy.sh
+
+# Custom function name
+./deploy.sh my-function
+
+# Custom function and region
+./deploy.sh my-function us-central1
+```
+
+## Project Structure
+
+```
+{self.project_name}/
+├── main.py             # Cloud Function entry point
+├── requirements.txt    # Python dependencies
+├── deploy.sh           # Deployment script
+├── .env.example        # Environment template
+└── README.md
+```
+
+## Testing
+
+After deployment, test your function:
+
+```bash
+# Test SWML output
+curl https://YOUR-FUNCTION-URL
+
+# Test SWAIG function
+curl -X POST https://YOUR-FUNCTION-URL/swaig \\
+  -H 'Content-Type: application/json' \\
+  -d '{{"function": "get_info", "argument": {{"parsed": [{{"topic": "test"}}]}}}}'
+```
+
+## Configure SignalWire
+
+Set your phone number's SWML URL to the endpoint URL shown after deployment.
+'''
+
+        else:  # azure
+            readme = f'''# {self.project_name}
+
+A SignalWire AI Agent deployed on {platform_name}.
+
+## Prerequisites
+
+- Azure CLI installed and authenticated (`az login`)
+- Docker installed and running
+
+## Quick Start
+
+```bash
+cd {self.project_name}
+./deploy.sh
+```
+
+## Deployment Options
+
+```bash
+# Deploy with defaults
+./deploy.sh
+
+# Custom app name
+./deploy.sh my-app
+
+# Custom app, region, and resource group
+./deploy.sh my-app eastus my-resource-group
+```
+
+## Project Structure
+
+```
+{self.project_name}/
+├── function_app/
+│   ├── __init__.py     # Azure Function handler
+│   └── function.json   # HTTP trigger config
+├── host.json           # Host configuration
+├── local.settings.json # Local dev settings
+├── requirements.txt    # Python dependencies
+├── deploy.sh           # Deployment script
+├── .env.example        # Environment template
+└── README.md
+```
+
+## Testing
+
+After deployment, test your function:
+
+```bash
+# Test SWML output
+curl https://YOUR-APP.azurewebsites.net/api/function_app
+
+# Test SWAIG function
+curl -X POST https://YOUR-APP.azurewebsites.net/api/function_app/swaig \\
+  -H 'Content-Type: application/json' \\
+  -d '{{"function": "get_info", "argument": {{"parsed": [{{"topic": "test"}}]}}}}'
+```
+
+## Configure SignalWire
+
+Set your phone number's SWML URL to the endpoint URL shown after deployment.
+'''
+
+        (self.project_dir / 'README.md').write_text(readme)
+        print_success("Created README.md")
 
     def _create_directories(self):
         """Create project directory structure."""
@@ -1043,6 +2389,11 @@ def run_interactive() -> Dict[str, Any]:
     """Run interactive prompts and return configuration."""
     print(f"\n{Colors.BOLD}{Colors.CYAN}Welcome to SignalWire Agent Init!{Colors.NC}\n")
 
+    # Platform selection
+    platform_options = list(CLOUD_PLATFORMS.values())
+    platform_idx = prompt_select("Target platform:", platform_options, default=1)
+    platform = list(CLOUD_PLATFORMS.keys())[platform_idx - 1]
+
     # Project name
     default_name = "my-agent"
     project_name = prompt("Project name", default_name)
@@ -1058,76 +2409,102 @@ def run_interactive() -> Dict[str, Any]:
             print("Aborted.")
             sys.exit(0)
 
-    # Agent type
-    agent_types = [
-        "Basic - Minimal agent with example tool",
-        "Full - Debug webhooks, web UI, all features",
-    ]
-    agent_type_idx = prompt_select("Agent type:", agent_types, default=1)
-    agent_type = 'basic' if agent_type_idx == 1 else 'full'
+    # Cloud-specific configuration
+    cloud_config = {}
+    if platform != 'local':
+        default_region = DEFAULT_REGIONS.get(platform, '')
+        cloud_config['region'] = prompt("Region", default_region)
+
+        if platform == 'azure':
+            cloud_config['resource_group'] = prompt("Resource group", f"{project_name}-rg")
+
+    # Agent type (for local) or simplified for cloud
+    if platform == 'local':
+        agent_types = [
+            "Basic - Minimal agent with example tool",
+            "Full - Debug webhooks, web UI, all features",
+        ]
+        agent_type_idx = prompt_select("Agent type:", agent_types, default=1)
+        agent_type = 'basic' if agent_type_idx == 1 else 'full'
+
+        # Set default features based on type
+        if agent_type == 'full':
+            default_features = [True, True, True, True, True, True]
+        else:
+            default_features = [False, False, False, True, True, False]
+
+        # Feature selection
+        feature_names = [
+            "Debug webhooks (console output)",
+            "Post-prompt summary",
+            "Web UI",
+            "Example SWAIG tool",
+            "Test scaffolding (pytest)",
+            "Basic authentication",
+        ]
+        selected = prompt_multiselect("Include features:", feature_names, default_features)
 
-    # Set default features based on type
-    if agent_type == 'full':
-        default_features = [True, True, True, True, True, True]
+        features = {
+            'debug_webhooks': selected[0],
+            'post_prompt': selected[1],
+            'web_ui': selected[2],
+            'example_tool': selected[3],
+            'tests': selected[4],
+            'basic_auth': selected[5],
+        }
     else:
-        default_features = [False, False, False, True, True, False]
-
-    # Feature selection
-    feature_names = [
-        "Debug webhooks (console output)",
-        "Post-prompt summary",
-        "Web UI",
-        "Example SWAIG tool",
-        "Test scaffolding (pytest)",
-        "Basic authentication",
-    ]
-    selected = prompt_multiselect("Include features:", feature_names, default_features)
-
-    features = {
-        'debug_webhooks': selected[0],
-        'post_prompt': selected[1],
-        'web_ui': selected[2],
-        'example_tool': selected[3],
-        'tests': selected[4],
-        'basic_auth': selected[5],
-    }
+        # Cloud platforms have simplified features
+        agent_type = 'basic'
+        features = {
+            'debug_webhooks': False,
+            'post_prompt': False,
+            'web_ui': False,
+            'example_tool': True,
+            'tests': False,
+            'basic_auth': prompt_yes_no("Enable basic authentication?", default=True),
+        }
 
-    # Credentials
-    env_creds = get_env_credentials()
+    # Credentials (only for local)
     credentials = {'space': '', 'project': '', 'token': ''}
-
-    if env_creds['space'] or env_creds['project'] or env_creds['token']:
-        print(f"\n{Colors.GREEN}SignalWire credentials found in environment:{Colors.NC}")
-        if env_creds['space']:
-            print(f"  Space: {env_creds['space']}")
-        if env_creds['project']:
-            print(f"  Project: {env_creds['project'][:12]}...{env_creds['project'][-4:]}")
-        if env_creds['token']:
-            print(f"  Token: {mask_token(env_creds['token'])}")
-
-        if prompt_yes_no("Use these credentials?", default=True):
-            credentials = env_creds
+    if platform == 'local':
+        env_creds = get_env_credentials()
+
+        if env_creds['space'] or env_creds['project'] or env_creds['token']:
+            print(f"\n{Colors.GREEN}SignalWire credentials found in environment:{Colors.NC}")
+            if env_creds['space']:
+                print(f"  Space: {env_creds['space']}")
+            if env_creds['project']:
+                print(f"  Project: {env_creds['project'][:12]}...{env_creds['project'][-4:]}")
+            if env_creds['token']:
+                print(f"  Token: {mask_token(env_creds['token'])}")
+
+            if prompt_yes_no("Use these credentials?", default=True):
+                credentials = env_creds
+            else:
+                credentials['space'] = prompt("Space name", env_creds['space'])
+                credentials['project'] = prompt("Project ID", env_creds['project'])
+                credentials['token'] = prompt("Token", env_creds['token'])
         else:
-            credentials['space'] = prompt("Space name", env_creds['space'])
-            credentials['project'] = prompt("Project ID", env_creds['project'])
-            credentials['token'] = prompt("Token", env_creds['token'])
-    else:
-        print(f"\n{Colors.YELLOW}No SignalWire credentials found in environment.{Colors.NC}")
-        if prompt_yes_no("Enter credentials now?", default=False):
-            credentials['space'] = prompt("Space name")
-            credentials['project'] = prompt("Project ID")
-            credentials['token'] = prompt("Token")
+            print(f"\n{Colors.YELLOW}No SignalWire credentials found in environment.{Colors.NC}")
+            if prompt_yes_no("Enter credentials now?", default=False):
+                credentials['space'] = prompt("Space name")
+                credentials['project'] = prompt("Project ID")
+                credentials['token'] = prompt("Token")
 
-    # Virtual environment
-    create_venv = prompt_yes_no("\nCreate virtual environment?", default=True)
+    # Virtual environment (only for local)
+    create_venv = False
+    if platform == 'local':
+        create_venv = prompt_yes_no("\nCreate virtual environment?", default=True)
 
     return {
         'project_name': project_name,
         'project_dir': project_dir,
+        'platform': platform,
         'agent_type': agent_type,
         'features': features,
         'credentials': credentials,
         'create_venv': create_venv,
+        'cloud_config': cloud_config,
     }
 
 
@@ -1135,38 +2512,66 @@ def run_quick(project_name: str, args: Any) -> Dict[str, Any]:
     """Run in quick mode with minimal prompts."""
     project_dir = os.path.abspath(os.path.join('.', project_name))
 
+    # Get platform from args
+    platform = getattr(args, 'platform', 'local') or 'local'
+
+    # Get region from args or use default
+    region = getattr(args, 'region', None)
+    if not region and platform != 'local':
+        region = DEFAULT_REGIONS.get(platform, '')
+
+    # Build cloud config
+    cloud_config = {}
+    if platform != 'local':
+        cloud_config['region'] = region
+        if platform == 'azure':
+            cloud_config['resource_group'] = f"{project_name}-rg"
+
     # Determine features from args
     agent_type = getattr(args, 'type', 'basic') or 'basic'
 
-    if agent_type == 'full':
-        features = {
-            'debug_webhooks': True,
-            'post_prompt': True,
-            'web_ui': True,
-            'example_tool': True,
-            'tests': True,
-            'basic_auth': True,
-        }
+    if platform == 'local':
+        if agent_type == 'full':
+            features = {
+                'debug_webhooks': True,
+                'post_prompt': True,
+                'web_ui': True,
+                'example_tool': True,
+                'tests': True,
+                'basic_auth': True,
+            }
+        else:
+            features = {
+                'debug_webhooks': False,
+                'post_prompt': False,
+                'web_ui': False,
+                'example_tool': True,
+                'tests': True,
+                'basic_auth': False,
+            }
     else:
+        # Cloud platforms have simplified features
         features = {
             'debug_webhooks': False,
             'post_prompt': False,
             'web_ui': False,
             'example_tool': True,
-            'tests': True,
-            'basic_auth': False,
+            'tests': False,
+            'basic_auth': True,
         }
 
-    # Get credentials from environment
-    credentials = get_env_credentials()
+    # Get credentials from environment (only for local)
+    credentials = get_env_credentials() if platform == 'local' else {'space': '', 'project': '', 'token': ''}
 
     return {
         'project_name': project_name,
         'project_dir': project_dir,
+        'platform': platform,
         'agent_type': agent_type,
         'features': features,
         'credentials': credentials,
-        'create_venv': not getattr(args, 'no_venv', False),
+        'create_venv': not getattr(args, 'no_venv', False) and platform == 'local',
+        'cloud_config': cloud_config,
     }
 
 
@@ -1179,15 +2584,21 @@ def main():
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog='''
 Examples:
-  sw-agent-init                    Interactive mode
-  sw-agent-init myagent            Quick mode with defaults
-  sw-agent-init myagent --type full
-  sw-agent-init myagent --no-venv
+  sw-agent-init                        Interactive mode
+  sw-agent-init myagent                Quick mode with defaults
+  sw-agent-init myagent --type full    Full-featured local agent
+  sw-agent-init myagent -p aws         AWS Lambda function
+  sw-agent-init myagent -p gcp         Google Cloud Function
+  sw-agent-init myagent -p azure       Azure Function
+  sw-agent-init myagent -p aws -r us-west-2  Custom region
 '''
     )
     parser.add_argument('name', nargs='?', help='Project name')
     parser.add_argument('--type', choices=['basic', 'full'], default='basic',
                         help='Agent type (default: basic)')
+    parser.add_argument('--platform', '-p', choices=['local', 'aws', 'gcp', 'azure'],
+                        default='local', help='Target platform (default: local)')
+    parser.add_argument('--region', '-r', help='Cloud region (e.g., us-east-1, us-central1, eastus)')
     parser.add_argument('--no-venv', action='store_true',
                         help='Skip virtual environment creation')
     parser.add_argument('--dir', help='Parent directory for project')