honeycomb-api 0.1.0__py3-none-any.whl → 0.5.3__py3-none-any.whl

honeycomb/tools/resources/derived_columns.py

@@ -0,0 +1,311 @@
+"""Derived Columns tool definitions for Claude API.
+
+This module provides tool generators and descriptions for
+derived columns resources.
+"""
+
+from typing import Any
+
+from honeycomb.models import DerivedColumnCreate
+from honeycomb.tools.schemas import add_parameter, generate_schema_from_model
+
+# ==============================================================================
+# Derived Columns Descriptions
+# ==============================================================================
+
+_DERIVED_COLUMN_SYNTAX_GUIDE = """
+EXPRESSION SYNTAX REFERENCE:
+- Column refs: $column_name or $"column with spaces" (CASE-SENSITIVE)
+- Strings: double quotes ("value")
+- Regex patterns: backticks (`pattern`)
+- DCs operate on ONE ROW at a time - they are NOT aggregation functions
+
+CONDITIONALS:
+- IF(cond, true_val, false_val) - e.g., IF(LT($status, 400), "ok", "error")
+- SWITCH($field, "case1", result1, "case2", result2, default) - string matching
+- COALESCE(a, b, c) - first non-null value
+
+COMPARISONS (return bool):
+- LT, LTE, GT, GTE - e.g., LT($duration_ms, 1000)
+- EQUALS($a, $b) - e.g., EQUALS($method, "GET")
+- IN($field, val1, val2, ...) - e.g., IN($status, 200, 201, 204)
+
+BOOLEAN:
+- EXISTS($field) - true if field is non-null
+- NOT(cond), AND(a, b, ...), OR(a, b, ...)
+
+MATH: MIN, MAX, SUM, SUB, MUL, DIV, MOD, LOG10
+
+STRING:
+- CONCAT($a, " ", $b) - join strings
+- STARTS_WITH($str, "prefix"), ENDS_WITH, CONTAINS - return bool
+- TO_LOWER($str), LENGTH($str)
+
+REGEX (use backticks for patterns):
+- REG_MATCH($str, `pattern`) - returns bool
+- REG_VALUE($str, `^/api/(.+)`) - extracts first capture group
+- REG_COUNT($str, `pattern`) - count matches
+
+TIME:
+- EVENT_TIMESTAMP() - event time as Unix timestamp
+- UNIX_TIMESTAMP($field) - parse field as timestamp
+- FORMAT_TIME("%Y-%m-%d", $timestamp_field) - strftime formatting
+
+DATA: BUCKET($val, size) - numeric bucketing
+
+TYPE CONVERSION: INT(), FLOAT(), BOOL(), STRING()
+
+COMMON PATTERNS:
+- SLI for SLOs (MUST return boolean; 1/0 coerced to true/false): LT($status_code, 500)
+- Root span detection: NOT(EXISTS($trace.parent_id))
+- Error classification: IF(GTE($status, 500), "server_error", IF(GTE($status, 400), "client_error", "success"))
+"""
+
+DERIVED_COLUMN_DESCRIPTIONS = {
+    "honeycomb_list_derived_columns": (
+        "Lists all derived columns (calculated fields) in a dataset. "
+        "Use this to discover existing calculated fields before creating new ones, understand available computed metrics, or audit data transformations. "
+        "Requires the dataset slug parameter (use '__all__' to list environment-wide derived columns). "
+        "Returns a list of derived column objects including their IDs, aliases, expressions, and descriptions."
+    ),
+    "honeycomb_get_derived_column": (
+        "Retrieves detailed configuration for a specific derived column by ID. "
+        "Use this to inspect a derived column's expression syntax, alias, and description before modifying it. "
+        "Requires both the dataset slug and derived column ID parameters. "
+        "Returns the complete derived column configuration including the calculation expression and metadata."
+    ),
+    "honeycomb_create_derived_column": (
+        "Creates a new standalone derived column that calculates values from event fields using expressions. "
+        "Use this for general-purpose computed metrics, data normalization, or calculations that will be used in multiple queries. "
+        "NOTE: If you are creating a derived column specifically for an SLO, use honeycomb_create_slo instead with an inline SLI expression - it creates both in one operation. "
+        "Requires the dataset slug (use '__all__' for environment-wide), an alias (the column name), and an expression. "
+        "Optional description parameter documents the column's purpose for team members. "
+        + _DERIVED_COLUMN_SYNTAX_GUIDE
+    ),
+    "honeycomb_update_derived_column": (
+        "Updates an existing derived column's alias, expression, or description. "
+        "Use this to fix calculation logic, rename computed fields, or improve documentation as your understanding evolves. "
+        "Requires the dataset slug, derived column ID, and the complete updated configuration. "
+        "Note: Changing the expression only affects new queries - existing query results are not recalculated. "
+        + _DERIVED_COLUMN_SYNTAX_GUIDE
+    ),
+    "honeycomb_delete_derived_column": (
+        "Permanently deletes a derived column from a dataset. "
+        "Use this when removing unused calculated fields or cleaning up temporary analysis columns. "
+        "Requires both the dataset slug and derived column ID parameters. "
+        "Warning: This action cannot be undone. SLOs, triggers, or queries using this derived column may break if they reference it."
+    ),
+}
+
+
+def get_description(tool_name: str) -> str:
+    """Get the description for a tool in this resource."""
+    return DERIVED_COLUMN_DESCRIPTIONS[tool_name]
+
+
+def create_tool_definition(
+    name: str,
+    description: str,
+    input_schema: dict[str, Any],
+    input_examples: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Create a Claude tool definition."""
+    from honeycomb.tools.descriptions import validate_description
+    from honeycomb.tools.schemas import add_metadata_fields, validate_schema, validate_tool_name
+
+    validate_tool_name(name)
+    validate_description(description)
+    validate_schema(input_schema)
+    add_metadata_fields(input_schema)
+
+    definition: dict[str, Any] = {
+        "name": name,
+        "description": description,
+        "input_schema": input_schema,
+    }
+
+    if input_examples:
+        definition["input_examples"] = input_examples
+
+    return definition
+
+
+# ==============================================================================
+# Derived Columns Tool Definitions
+# ==============================================================================
+
+
+def generate_list_derived_columns_tool() -> dict[str, Any]:
+    """Generate honeycomb_list_derived_columns tool definition."""
+    schema: dict[str, Any] = {"type": "object", "properties": {}, "required": ["dataset"]}
+
+    add_parameter(
+        schema,
+        "dataset",
+        "string",
+        "The dataset slug to list derived columns from (use '__all__' for environment-wide)",
+        required=True,
+    )
+
+    examples: list[dict[str, Any]] = [
+        {"dataset": "api-logs"},
+        {"dataset": "__all__"},
+    ]
+
+    return create_tool_definition(
+        name="honeycomb_list_derived_columns",
+        description=get_description("honeycomb_list_derived_columns"),
+        input_schema=schema,
+        input_examples=examples,
+    )
+
+
+def generate_get_derived_column_tool() -> dict[str, Any]:
+    """Generate honeycomb_get_derived_column tool definition."""
+    schema: dict[str, Any] = {
+        "type": "object",
+        "properties": {},
+        "required": ["dataset", "derived_column_id"],
+    }
+
+    add_parameter(schema, "dataset", "string", "The dataset slug", required=True)
+    add_parameter(
+        schema, "derived_column_id", "string", "The derived column ID to retrieve", required=True
+    )
+
+    examples: list[dict[str, Any]] = [
+        {"dataset": "api-logs", "derived_column_id": "dc-123"},
+        {"dataset": "__all__", "derived_column_id": "dc-456"},
+    ]
+
+    return create_tool_definition(
+        name="honeycomb_get_derived_column",
+        description=get_description("honeycomb_get_derived_column"),
+        input_schema=schema,
+        input_examples=examples,
+    )
+
+
+def generate_create_derived_column_tool() -> dict[str, Any]:
+    """Generate honeycomb_create_derived_column tool definition."""
+    base_schema = generate_schema_from_model(
+        DerivedColumnCreate,
+        exclude_fields={"id", "created_at", "updated_at"},
+    )
+
+    schema: dict[str, Any] = {"type": "object", "properties": {}, "required": ["dataset"]}
+    add_parameter(
+        schema,
+        "dataset",
+        "string",
+        "The dataset slug (use '__all__' for environment-wide)",
+        required=True,
+    )
+
+    schema["properties"].update(base_schema["properties"])
+    schema["required"].extend(base_schema.get("required", []))
+
+    examples: list[dict[str, Any]] = [
+        # Boolean flag
+        {
+            "dataset": "api-logs",
+            "alias": "is_error",
+            "expression": "IF(GTE($status_code, 500), 1, 0)",
+            "description": "1 if error, 0 otherwise",
+        },
+        # Categorization
+        {
+            "dataset": "api-logs",
+            "alias": "status_category",
+            "expression": "IF(LT($status_code, 400), 'success', IF(LT($status_code, 500), 'client_error', 'server_error'))",
+        },
+        # Environment-wide
+        {
+            "dataset": "__all__",
+            "alias": "request_success",
+            "expression": "IF(LT($status_code, 400), 1, 0)",
+            "description": "Success indicator for all datasets",
+        },
+    ]
+
+    return create_tool_definition(
+        name="honeycomb_create_derived_column",
+        description=get_description("honeycomb_create_derived_column"),
+        input_schema=schema,
+        input_examples=examples,
+    )
+
+
+def generate_update_derived_column_tool() -> dict[str, Any]:
+    """Generate honeycomb_update_derived_column tool definition."""
+    base_schema = generate_schema_from_model(
+        DerivedColumnCreate,
+        exclude_fields={"id", "created_at", "updated_at"},
+    )
+
+    schema: dict[str, Any] = {
+        "type": "object",
+        "properties": {},
+        "required": ["dataset", "derived_column_id"],
+    }
+    add_parameter(schema, "dataset", "string", "The dataset slug", required=True)
+    add_parameter(
+        schema, "derived_column_id", "string", "The derived column ID to update", required=True
+    )
+
+    schema["properties"].update(base_schema["properties"])
+    schema["required"].extend(base_schema.get("required", []))
+
+    examples: list[dict[str, Any]] = [
+        {
+            "dataset": "api-logs",
+            "derived_column_id": "dc-123",
+            "alias": "is_error",
+            "expression": "IF(GTE($status_code, 500), 1, 0)",
+            "description": "Updated error flag",
+        },
+    ]
+
+    return create_tool_definition(
+        name="honeycomb_update_derived_column",
+        description=get_description("honeycomb_update_derived_column"),
+        input_schema=schema,
+        input_examples=examples,
+    )
+
+
+def generate_delete_derived_column_tool() -> dict[str, Any]:
+    """Generate honeycomb_delete_derived_column tool definition."""
+    schema: dict[str, Any] = {
+        "type": "object",
+        "properties": {},
+        "required": ["dataset", "derived_column_id"],
+    }
+
+    add_parameter(schema, "dataset", "string", "The dataset slug", required=True)
+    add_parameter(
+        schema, "derived_column_id", "string", "The derived column ID to delete", required=True
+    )
+
+    examples: list[dict[str, Any]] = [
+        {"dataset": "api-logs", "derived_column_id": "dc-123"},
+        {"dataset": "__all__", "derived_column_id": "dc-456"},
+    ]
+
+    return create_tool_definition(
+        name="honeycomb_delete_derived_column",
+        description=get_description("honeycomb_delete_derived_column"),
+        input_schema=schema,
+        input_examples=examples,
+    )
+
+
+def get_tools() -> list[dict[str, Any]]:
+    """Get all derived columns tool definitions."""
+    return [
+        generate_list_derived_columns_tool(),
+        generate_get_derived_column_tool(),
+        generate_create_derived_column_tool(),
+        generate_update_derived_column_tool(),
+        generate_delete_derived_column_tool(),
+    ]

honeycomb/tools/resources/environments.py

@@ -0,0 +1,211 @@
+"""Environments tool definitions for Claude API.
+
+This module provides tool generators and descriptions for
+environments resources.
+"""
+
+from typing import Any
+
+from honeycomb.tools.schemas import add_parameter
+
+# ==============================================================================
+# Environments Descriptions
+# ==============================================================================
+
+ENVIRONMENT_DESCRIPTIONS = {
+    "honeycomb_list_environments": (
+        "Lists all environments for your authenticated team. "
+        "Use this to discover existing environments, understand team organization, or before creating API keys scoped to specific environments. "
+        "Requires management key authentication. The team is automatically detected from your credentials (no team parameter needed). "
+        "Returns a list of environment objects with their IDs, names, slugs, colors, descriptions, and delete protection status. "
+        "Environments help organize your telemetry data by separating production, staging, development, etc."
+    ),
+    "honeycomb_get_environment": (
+        "Retrieves detailed information about a specific environment by ID, optionally including its datasets. "
+        "Use this to inspect an environment's configuration or get a complete view of an environment including all its datasets. "
+        "Requires only the environment ID parameter - the team is automatically detected from your management key. "
+        "Set with_datasets=true to also return the list of datasets in this environment (useful for understanding environment contents). "
+        "Returns the environment configuration plus optionally a datasets array with all datasets in this environment."
+    ),
+    "honeycomb_create_environment": (
+        "Creates a new environment for organizing telemetry data within your authenticated team. "
+        "Use this when setting up new deployment stages (production, staging, dev), isolating customer data, or creating test environments. "
+        "Requires only the environment name - the team is automatically detected from your management key. "
+        "Optional parameters include description for documentation and color (blue, green, gold, red, purple, or light variants) for visual distinction. "
+        "The environment slug is auto-generated from the name and used for API operations and dataset scoping. "
+        "New environments are delete-protected by default to prevent accidental deletion."
+    ),
+    "honeycomb_update_environment": (
+        "Updates an existing environment's description, color, or delete protection status. "
+        "Use this to add documentation, change visual appearance, or enable/disable delete protection for production environments. "
+        "Requires environment ID and at least one of: description, color, or delete_protected (boolean). The team is automatically detected from your credentials. "
+        "Note: The name and slug cannot be changed after creation. Setting delete_protected=true prevents accidental deletion. "
+        "To delete a protected environment, you must first update it with delete_protected=false."
+    ),
+    "honeycomb_delete_environment": (
+        "Permanently deletes an environment from Honeycomb. "
+        "Use this when decommissioning deployment stages, cleaning up test environments, or reorganizing team structure. "
+        "Requires only the environment ID parameter - the team is automatically detected from your management key. "
+        "Warning: This action cannot be undone. The environment must not be delete-protected. "
+        "All API keys scoped to this environment will become invalid. Datasets are NOT deleted automatically."
+    ),
+}
+
+
+def get_description(tool_name: str) -> str:
+    """Get the description for a tool in this resource."""
+    return ENVIRONMENT_DESCRIPTIONS[tool_name]
+
+
+def create_tool_definition(
+    name: str,
+    description: str,
+    input_schema: dict[str, Any],
+    input_examples: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Create a Claude tool definition."""
+    from honeycomb.tools.descriptions import validate_description
+    from honeycomb.tools.schemas import add_metadata_fields, validate_schema, validate_tool_name
+
+    validate_tool_name(name)
+    validate_description(description)
+    validate_schema(input_schema)
+    add_metadata_fields(input_schema)
+
+    definition: dict[str, Any] = {
+        "name": name,
+        "description": description,
+        "input_schema": input_schema,
+    }
+
+    if input_examples:
+        definition["input_examples"] = input_examples
+
+    return definition
+
+
+# ==============================================================================
+# Environments Tool Definitions
+# ==============================================================================
+
+
+def generate_list_environments_tool() -> dict[str, Any]:
+    """Generate honeycomb_list_environments tool definition."""
+    schema: dict[str, Any] = {"type": "object", "properties": {}, "required": []}
+
+    examples: list[dict[str, Any]] = [{}]
+
+    return create_tool_definition(
+        name="honeycomb_list_environments",
+        description=get_description("honeycomb_list_environments"),
+        input_schema=schema,
+        input_examples=examples,
+    )
+
+
+def generate_get_environment_tool() -> dict[str, Any]:
+    """Generate honeycomb_get_environment tool definition."""
+    schema: dict[str, Any] = {"type": "object", "properties": {}, "required": ["env_id"]}
+
+    add_parameter(schema, "env_id", "string", "The environment ID", required=True)
+    add_parameter(
+        schema,
+        "with_datasets",
+        "boolean",
+        "Also return list of datasets in this environment",
+        required=False,
+    )
+
+    examples: list[dict[str, Any]] = [
+        {"env_id": "hcaen_123"},
+        {"env_id": "hcaen_123", "with_datasets": True},
+    ]
+
+    return create_tool_definition(
+        name="honeycomb_get_environment",
+        description=get_description("honeycomb_get_environment"),
+        input_schema=schema,
+        input_examples=examples,
+    )
+
+
+def generate_create_environment_tool() -> dict[str, Any]:
+    """Generate honeycomb_create_environment tool definition."""
+    schema: dict[str, Any] = {"type": "object", "properties": {}, "required": ["name"]}
+
+    add_parameter(schema, "name", "string", "Environment name", required=True)
+    add_parameter(schema, "description", "string", "Environment description", required=False)
+    add_parameter(
+        schema,
+        "color",
+        "string",
+        "Display color (blue, green, gold, red, purple, or light variants)",
+        required=False,
+    )
+
+    examples: list[dict[str, Any]] = [
+        {"name": "Production"},
+        {"name": "Staging", "color": "blue", "description": "Staging env"},
+    ]
+
+    return create_tool_definition(
+        name="honeycomb_create_environment",
+        description=get_description("honeycomb_create_environment"),
+        input_schema=schema,
+        input_examples=examples,
+    )
+
+
+def generate_update_environment_tool() -> dict[str, Any]:
+    """Generate honeycomb_update_environment tool definition."""
+    schema: dict[str, Any] = {"type": "object", "properties": {}, "required": ["env_id"]}
+
+    add_parameter(schema, "env_id", "string", "The environment ID", required=True)
+    add_parameter(schema, "description", "string", "New description", required=False)
+    add_parameter(schema, "color", "string", "New color", required=False)
+    add_parameter(
+        schema,
+        "delete_protected",
+        "boolean",
+        "Enable (true) or disable (false) delete protection",
+        required=False,
+    )
+
+    examples: list[dict[str, Any]] = [
+        {"env_id": "hcaen_123", "description": "Updated description"},
+        {"env_id": "hcaen_123", "delete_protected": False},
+    ]
+
+    return create_tool_definition(
+        name="honeycomb_update_environment",
+        description=get_description("honeycomb_update_environment"),
+        input_schema=schema,
+        input_examples=examples,
+    )
+
+
+def generate_delete_environment_tool() -> dict[str, Any]:
+    """Generate honeycomb_delete_environment tool definition."""
+    schema: dict[str, Any] = {"type": "object", "properties": {}, "required": ["env_id"]}
+
+    add_parameter(schema, "env_id", "string", "The environment ID to delete", required=True)
+
+    examples: list[dict[str, Any]] = [{"env_id": "hcaen_123"}]
+
+    return create_tool_definition(
+        name="honeycomb_delete_environment",
+        description=get_description("honeycomb_delete_environment"),
+        input_schema=schema,
+        input_examples=examples,
+    )
+
+
+def get_tools() -> list[dict[str, Any]]:
+    """Get all environments tool definitions."""
+    return [
+        generate_list_environments_tool(),
+        generate_get_environment_tool(),
+        generate_create_environment_tool(),
+        generate_update_environment_tool(),
+        generate_delete_environment_tool(),
+    ]

honeycomb/tools/resources/events.py

@@ -0,0 +1,158 @@
+"""Events tool definitions for Claude API.
+
+This module provides tool generators and descriptions for
+events resources.
+"""
+
+from typing import Any
+
+from honeycomb.tools.schemas import add_parameter
+
+# ==============================================================================
+# Events Descriptions
+# ==============================================================================
+
+EVENT_DESCRIPTIONS = {
+    "honeycomb_send_event": (
+        "Sends a SINGLE telemetry event to a Honeycomb dataset. Use ONLY for one-off events or testing. "
+        "STRUCTURE: Flat - parameters are 'dataset' (string) and 'data' (object with key-value pairs) provided directly at top level. "
+        "Example: {dataset: 'api-logs', data: {status_code: 200, endpoint: '/api/users'}}. "
+        "For 2+ events, you MUST use honeycomb_send_batch_events instead. "
+        "Optional parameters: timestamp (Unix seconds), samplerate (integer). "
+        "IMPORTANT: This is for SINGLE events only - batch tool is required for multiple events."
+    ),
+    "honeycomb_send_batch_events": (
+        "Sends MULTIPLE telemetry events to a Honeycomb dataset in a single API call (preferred for 2+ events). "
+        "STRUCTURE: Nested - requires 'dataset' (string) and 'events' (array) where EACH event object has a 'data' field. "
+        "Example: {dataset: 'api-logs', events: [{data: {status_code: 200}}, {data: {status_code: 201}}]}. "
+        "CRITICAL: The 'events' parameter is REQUIRED and must be an ARRAY of event objects. Each event MUST have a 'data' field containing key-value pairs. "
+        "Per-event optional fields: 'time' (ISO8601 string like '2024-01-15T10:30:00Z'), 'samplerate' (integer). "
+        "Use this for efficient bulk data ingestion, application logs, traces, or metrics. "
+        "Returns status for each event, allowing identification and retry of failed events."
+    ),
+}
+
+
+def get_description(tool_name: str) -> str:
+    """Get the description for a tool in this resource."""
+    return EVENT_DESCRIPTIONS[tool_name]
+
+
+def create_tool_definition(
+    name: str,
+    description: str,
+    input_schema: dict[str, Any],
+    input_examples: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Create a Claude tool definition."""
+    from honeycomb.tools.descriptions import validate_description
+    from honeycomb.tools.schemas import add_metadata_fields, validate_schema, validate_tool_name
+
+    validate_tool_name(name)
+    validate_description(description)
+    validate_schema(input_schema)
+    add_metadata_fields(input_schema)
+
+    definition: dict[str, Any] = {
+        "name": name,
+        "description": description,
+        "input_schema": input_schema,
+    }
+
+    if input_examples:
+        definition["input_examples"] = input_examples
+
+    return definition
+
+
+# ==============================================================================
+# Events Tool Definitions
+# ==============================================================================
+
+
+def generate_send_event_tool() -> dict[str, Any]:
+    """Generate honeycomb_send_event tool definition."""
+    schema: dict[str, Any] = {"type": "object", "properties": {}, "required": ["dataset", "data"]}
+    add_parameter(schema, "dataset", "string", "The dataset slug", required=True)
+    add_parameter(schema, "data", "object", "Event data as key-value pairs", required=True)
+    add_parameter(schema, "timestamp", "integer", "Unix timestamp for the event", required=False)
+    add_parameter(schema, "samplerate", "integer", "Sample rate (default: 1)", required=False)
+
+    examples: list[dict[str, Any]] = [
+        {
+            "dataset": "api-logs",
+            "data": {"endpoint": "/api/users", "duration_ms": 42, "status_code": 200},
+        },
+        {
+            "dataset": "production",
+            "data": {"service": "auth", "latency": 15},
+            "timestamp": 1640000000,
+        },
+    ]
+
+    return create_tool_definition(
+        name="honeycomb_send_event",
+        description=get_description("honeycomb_send_event"),
+        input_schema=schema,
+        input_examples=examples,
+    )
+
+
+def generate_send_batch_events_tool() -> dict[str, Any]:
+    """Generate honeycomb_send_batch_events tool definition."""
+    schema: dict[str, Any] = {"type": "object", "properties": {}, "required": ["dataset", "events"]}
+    add_parameter(schema, "dataset", "string", "The dataset slug", required=True)
+
+    schema["properties"]["events"] = {
+        "type": "array",
+        "description": "Array of event objects. Each event must have a 'data' field with event payload.",
+        "items": {
+            "type": "object",
+            "properties": {
+                "data": {
+                    "type": "object",
+                    "description": "Event payload as key-value pairs (required for each event)",
+                },
+                "time": {
+                    "type": "string",
+                    "description": "Event timestamp in ISO8601 format (e.g., '2024-01-15T10:30:00Z'). Optional, defaults to server time.",
+                },
+                "samplerate": {
+                    "type": "integer",
+                    "description": "Sample rate for this event (optional, defaults to 1)",
+                },
+            },
+            "required": ["data"],
+        },
+    }
+
+    examples: list[dict[str, Any]] = [
+        {
+            "dataset": "api-logs",
+            "events": [
+                {
+                    "data": {"endpoint": "/api/users", "duration_ms": 42, "status_code": 200},
+                    "time": "2024-01-15T10:30:00Z",
+                },
+                {
+                    "data": {"endpoint": "/api/posts", "duration_ms": 18, "status_code": 201},
+                    "time": "2024-01-15T10:30:15Z",
+                },
+            ],
+        },
+    ]
+
+    return create_tool_definition(
+        name="honeycomb_send_batch_events",
+        description=get_description("honeycomb_send_batch_events"),
+        input_schema=schema,
+        input_examples=examples,
+    )
+
+
+def get_tools() -> list[dict[str, Any]]:
+    """Get all events tool definitions."""
+    return [
+        generate_send_event_tool(),
+        generate_send_batch_events_tool(),
+    ]