chore: import upstream snapshot with attribution

integrations/aws_lambda/tools/lambda_config_tool/__init__.py

@@ -0,0 +1,57 @@
+"""Lambda configuration (lightweight, no code)."""
+
+from __future__ import annotations
+
+from core.tool_framework.tool_decorator import tool
+from integrations.aws.lambda_client import get_function_configuration
+from integrations.aws_lambda.tools.lambda_invocation_logs_tool import (
+    _lambda_available,
+    _lambda_name,
+)
+
+
+def _extract_lambda_config_params(sources: dict[str, dict]) -> dict:
+    return {"function_name": _lambda_name(sources)}
+
+
+@tool(
+    name="get_lambda_configuration",
+    source="cloudwatch",
+    description="Get Lambda function configuration details (lightweight — no code retrieval).",
+    use_cases=[
+        "Quick configuration checks for Lambda functions",
+        "Environment variable inspection",
+        "Timeout and memory settings review",
+    ],
+    requires=["function_name"],
+    input_schema={
+        "type": "object",
+        "properties": {
+            "function_name": {"type": "string"},
+        },
+        "required": ["function_name"],
+    },
+    is_available=_lambda_available,
+    extract_params=_extract_lambda_config_params,
+)
+def get_lambda_configuration(function_name: str) -> dict:
+    """Get Lambda function configuration details (lightweight, no code)."""
+    if not function_name:
+        return {"error": "function_name is required"}
+
+    result = get_function_configuration(function_name)
+    if not result.get("success"):
+        return {"error": result.get("error", "Unknown error"), "function_name": function_name}
+
+    config = result.get("data", {})
+    return {
+        "found": True,
+        "function_name": config.get("function_name"),
+        "runtime": config.get("runtime"),
+        "handler": config.get("handler"),
+        "timeout": config.get("timeout"),
+        "memory_size": config.get("memory_size"),
+        "last_modified": config.get("last_modified"),
+        "state": config.get("state"),
+        "environment_variables": config.get("environment", {}),
+    }

integrations/aws_lambda/tools/lambda_errors_tool/__init__.py

@@ -0,0 +1,41 @@
+"""Lambda error logs (filtered invocation logs)."""
+
+from __future__ import annotations
+
+from core.tool_framework.tool_decorator import tool
+from integrations.aws_lambda.tools.lambda_invocation_logs_tool import (
+    _lambda_available,
+    _lambda_name,
+    get_lambda_invocation_logs,
+)
+
+
+def _extract_lambda_errors_params(sources: dict[str, dict]) -> dict:
+    return {"function_name": _lambda_name(sources), "limit": 50}
+
+
+@tool(
+    name="get_lambda_errors",
+    display_name="Lambda errors",
+    source="cloudwatch",
+    description="Get Lambda function error logs.",
+    use_cases=[
+        "Quickly finding error messages from a Lambda function",
+        "Understanding Lambda failure patterns",
+        "Identifying root cause of Lambda failures",
+    ],
+    requires=["function_name"],
+    input_schema={
+        "type": "object",
+        "properties": {
+            "function_name": {"type": "string"},
+            "limit": {"type": "integer", "default": 50},
+        },
+        "required": ["function_name"],
+    },
+    is_available=_lambda_available,
+    extract_params=_extract_lambda_errors_params,
+)
+def get_lambda_errors(function_name: str, limit: int = 50) -> dict:
+    """Get Lambda function error logs (filtered view of invocation logs)."""
+    return get_lambda_invocation_logs(function_name=function_name, filter_errors=True, limit=limit)

integrations/aws_lambda/tools/lambda_inspect_tool/__init__.py

@@ -0,0 +1,78 @@
+"""Inspect Lambda configuration and code."""
+
+from __future__ import annotations
+
+from core.tool_framework.tool_decorator import tool
+from integrations.aws.lambda_client import get_function_code, get_function_configuration
+from integrations.aws_lambda.tools.lambda_invocation_logs_tool import (
+    _lambda_available,
+    _lambda_name,
+)
+
+
+def _extract_inspect_lambda_params(sources: dict[str, dict]) -> dict:
+    return {"function_name": _lambda_name(sources), "include_code": True}
+
+
+@tool(
+    name="inspect_lambda_function",
+    display_name="Lambda config",
+    source="cloudwatch",
+    description="Inspect a Lambda function's configuration and optionally its code.",
+    use_cases=[
+        "Understanding function configuration (timeout, memory, env vars)",
+        "Reviewing function code for data transformation logic",
+        "Identifying environment-related issues",
+        "Finding integration points with other services",
+    ],
+    requires=["function_name"],
+    input_schema={
+        "type": "object",
+        "properties": {
+            "function_name": {"type": "string"},
+            "include_code": {"type": "boolean", "default": True},
+        },
+        "required": ["function_name"],
+    },
+    is_available=_lambda_available,
+    extract_params=_extract_inspect_lambda_params,
+)
+def inspect_lambda_function(function_name: str, include_code: bool = True) -> dict:
+    """Inspect a Lambda function's configuration and optionally its code."""
+    if not function_name:
+        return {"error": "function_name is required"}
+
+    config_result = get_function_configuration(function_name)
+    if not config_result.get("success"):
+        return {
+            "error": config_result.get("error", "Unknown error"),
+            "function_name": function_name,
+        }
+
+    config = config_result.get("data", {})
+    result = {
+        "found": True,
+        "function_name": config.get("function_name"),
+        "function_arn": config.get("function_arn"),
+        "runtime": config.get("runtime"),
+        "handler": config.get("handler"),
+        "timeout": config.get("timeout"),
+        "memory_size": config.get("memory_size"),
+        "code_size": config.get("code_size"),
+        "last_modified": config.get("last_modified"),
+        "state": config.get("state"),
+        "environment_variables": config.get("environment", {}),
+        "description": config.get("description"),
+        "layers": config.get("layers", []),
+    }
+
+    if include_code:
+        code_result = get_function_code(function_name, extract_files=True)
+        if code_result.get("success"):
+            code_data = code_result.get("data", {})
+            result["code"] = {
+                "file_count": code_data.get("file_count", 0),
+                "files": code_data.get("files", {}),
+            }
+
+    return result

integrations/aws_lambda/tools/lambda_invocation_logs_tool/__init__.py

@@ -0,0 +1,126 @@
+"""Lambda invocation logs from CloudWatch."""
+
+from __future__ import annotations
+
+from core.tool_framework.tool_decorator import tool
+from integrations.aws.lambda_client import (
+    get_invocation_logs_by_request_id,
+    get_recent_invocations,
+)
+from platform.common.evidence_compaction import compact_invocations, compact_logs, summarize_counts
+
+
+def _lambda_available(sources: dict[str, dict]) -> bool:
+    return bool(sources.get("lambda", {}).get("function_name"))
+
+
+def _lambda_name(sources: dict[str, dict]) -> str:
+    return str(sources.get("lambda", {}).get("function_name", ""))
+
+
+def _extract_lambda_invocation_logs_params(sources: dict[str, dict]) -> dict:
+    return {"function_name": _lambda_name(sources), "filter_errors": False, "limit": 50}
+
+
+@tool(
+    name="get_lambda_invocation_logs",
+    display_name="Lambda logs",
+    source="cloudwatch",
+    description="Get Lambda invocation logs from CloudWatch.",
+    use_cases=[
+        "Finding error messages and stack traces from Lambda executions",
+        "Understanding data processing flow in Lambda functions",
+        "Identifying issues with external API calls made by Lambda",
+        "Tracing data transformation logic through log output",
+    ],
+    requires=["function_name"],
+    input_schema={
+        "type": "object",
+        "properties": {
+            "function_name": {"type": "string"},
+            "request_id": {"type": "string"},
+            "filter_errors": {"type": "boolean", "default": False},
+            "limit": {"type": "integer", "default": 50},
+        },
+        "required": ["function_name"],
+    },
+    is_available=_lambda_available,
+    extract_params=_extract_lambda_invocation_logs_params,
+)
+def get_lambda_invocation_logs(
+    function_name: str,
+    request_id: str | None = None,
+    filter_errors: bool = False,
+    limit: int = 50,
+) -> dict:
+    """Get Lambda invocation logs from CloudWatch."""
+    if not function_name:
+        return {"error": "function_name is required"}
+
+    if request_id:
+        result = get_invocation_logs_by_request_id(function_name, request_id, limit)
+        if not result.get("success"):
+            return {
+                "error": result.get("error", "Unknown error"),
+                "function_name": function_name,
+                "request_id": request_id,
+            }
+        data = result.get("data", {})
+        logs = data.get("logs", [])
+        # Compact logs to stay within prompt limits
+        compacted_logs = compact_logs(logs, limit=limit)
+        result_data = {
+            "found": bool(compacted_logs),
+            "function_name": function_name,
+            "request_id": request_id,
+            "log_group": data.get("log_group"),
+            "event_count": data.get("event_count", 0),
+            "logs": compacted_logs,
+        }
+        summary = summarize_counts(len(logs), len(compacted_logs), "logs")
+        if summary:
+            result_data["truncation_note"] = summary
+        return result_data
+
+    filter_pattern = "ERROR" if filter_errors else None
+    result = get_recent_invocations(function_name, limit, filter_pattern)
+    if not result.get("success"):
+        return {"error": result.get("error", "Unknown error"), "function_name": function_name}
+
+    data = result.get("data", {})
+    invocations = data.get("invocations", [])
+    all_logs = [
+        {"request_id": inv.get("request_id"), "message": log}
+        for inv in invocations
+        for log in inv.get("logs", [])
+    ]
+
+    # Compact invocations and logs to stay within prompt limits
+    compacted_invocations = compact_invocations(
+        invocations, limit=limit, max_logs_per_invocation=10
+    )
+    compacted_recent_logs = compact_logs(all_logs, limit=20)
+
+    # Build invocation summaries with limited log counts
+    invocation_summaries = [
+        {
+            "request_id": inv.get("request_id"),
+            "duration_ms": inv.get("duration_ms"),
+            "memory_used_mb": inv.get("memory_used_mb"),
+            "log_count": min(len(inv.get("logs", [])), 10),
+        }
+        for inv in compacted_invocations
+    ]
+
+    result_data = {
+        "found": bool(compacted_invocations),
+        "function_name": function_name,
+        "log_group": data.get("log_group"),
+        "invocation_count": data.get("invocation_count", 0),
+        "invocations": invocation_summaries,
+        "recent_logs": compacted_recent_logs,
+    }
+    summary = summarize_counts(len(invocations), len(compacted_invocations), "invocations")
+    if summary:
+        result_data["truncation_note"] = summary
+    return result_data