erdo 0.1.4__py3-none-any.whl

erdo/__init__.py

@@ -0,0 +1,35 @@
+# DO NOT EDIT THIS FILE MANUALLY - it will be overwritten.
+# Generated by: erdo gen-client
+"""Erdo Agent SDK - Build AI agents with Python."""
+
+# Import all condition functions from generated condition module
+from ._generated.condition import *  # noqa: F403,F401
+from ._generated.condition import __all__ as condition_all
+
+# Import all generated types first
+from ._generated.types import *  # noqa: F403,F401
+from ._generated.types import __all__ as generated_all
+
+# Import state object for template support
+from .state import state  # noqa: F401
+
+# Import all handwritten SDK classes last (override generated ones)
+from .types import *  # noqa: F403,F401  # type: ignore[assignment]
+from .types import __all__ as handwritten_all
+
+__version__ = "0.1.0"
+
+# Build __all__ dynamically by combining all available types
+__all__ = []
+
+# Add generated types first
+__all__.extend(generated_all)
+
+# Add all condition functions
+__all__.extend(condition_all)
+
+# Add handwritten SDK classes (may override generated ones in __all__)
+__all__.extend(handwritten_all)
+
+# Add state to __all__ for explicit import
+__all__.append("state")

erdo/_generated/__init__.py

@@ -0,0 +1,18 @@
+# DO NOT EDIT THIS FILE MANUALLY - it will be overwritten.
+# Generated by: erdo gen-client
+"""
+Re-exports for generated code.
+
+This module provides clean access to all generated types and actions.
+"""
+
+# Re-export actions module
+from . import actions  # noqa: F401
+
+# Re-export internal actions
+from .internal_actions import *  # noqa: F403,F401
+
+# Re-export all generated types
+from .parameters import *  # noqa: F403,F401
+from .secrets import *  # noqa: F403,F401
+from .types import *  # noqa: F403,F401

erdo/_generated/actions/__init__.py

@@ -0,0 +1,32 @@
+# DO NOT EDIT THIS FILE MANUALLY - it will be overwritten.
+# Generated by: erdo gen-client
+"""
+Action functions for type-safe parameter generation.
+
+Import individual functions or entire modules:
+- from erdo.actions import memory, codeexec
+- from erdo.actions.memory import search, store
+- from erdo.actions.codeexec import execute
+"""
+
+# Module-level imports for convenient access
+from . import analysis  # noqa: F401
+from . import bot  # noqa: F401
+from . import codeexec  # noqa: F401
+from . import llm  # noqa: F401
+from . import memory  # noqa: F401
+from . import resource_definitions  # noqa: F401
+from . import utils  # noqa: F401
+from . import webparser  # noqa: F401
+from . import websearch  # noqa: F401
+from .analysis import *  # noqa: F403,F401
+
+# Import all functions from service modules
+from .bot import *  # noqa: F403,F401
+from .codeexec import *  # noqa: F403,F401
+from .llm import *  # noqa: F403,F401
+from .memory import *  # noqa: F403,F401
+from .resource_definitions import *  # noqa: F403,F401
+from .utils import *  # noqa: F403,F401
+from .webparser import *  # noqa: F403,F401
+from .websearch import *  # noqa: F403,F401

erdo/_generated/actions/analysis.py

@@ -0,0 +1,67 @@
+"""
+Analysis actions for creating and managing data analysis service functions.
+Auto-generated - DO NOT EDIT.
+
+Provides type-safe action definitions for analysis service.
+Actual execution happens in the Go backend after syncing.
+"""
+
+from typing import Any, List, Optional, Union
+
+from pydantic import BaseModel
+
+from erdo.template import TemplateString
+from erdo.types import StepMetadata
+
+
+class CreateAnalysisParams(BaseModel):
+    """Create an analysis for a dataset, resource, or dataset-resource combination parameters"""
+
+    name: str = "analysis.create_analysis"  # Action type for roundtrip compatibility
+    analysis: Optional[Any] = None  # analysis parameter
+    dataset_id: Optional[Union[str, TemplateString]] = None  # dataset_id parameter
+    resource_id: Optional[Union[str, TemplateString]] = None  # resource_id parameter
+
+
+class CreateAnalysisResult(BaseModel):
+    """Create an analysis for a dataset, resource, or dataset-resource combination result type
+
+    Result schema for analysis.create_analysis action.
+    """
+
+    analysis: Any
+    insights: Optional[List[str]]
+    recommendations: Optional[List[str]]
+
+
+def create_analysis(
+    analysis: Optional[Any] = None,
+    dataset_id: Optional[Union[str, TemplateString]] = None,
+    resource_id: Optional[Union[str, TemplateString]] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> CreateAnalysisParams:
+    """Create an analysis for a dataset, resource, or dataset-resource combination
+
+    Args:
+        analysis: analysis parameter
+        dataset_id: dataset_id parameter
+        resource_id: resource_id parameter
+
+    Returns:
+        CreateAnalysisParams: Type-safe parameter object
+    """
+    param_dict = {
+        "analysis": analysis,
+        "dataset_id": dataset_id,
+        "resource_id": resource_id,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+
+    return CreateAnalysisParams(**param_dict)
+
+
+# Associate parameter classes with their result types
+CreateAnalysisParams._result = CreateAnalysisResult

erdo/_generated/actions/bot.py

@@ -0,0 +1,124 @@
+"""
+Bot service functions.
+Auto-generated - DO NOT EDIT.
+
+Provides type-safe action definitions for Bot service with correct parameter names.
+Actual execution happens in the Go backend after syncing.
+
+NOTE: This module is hardcoded because bot.invoke requires bot_name parameter
+but the Go struct uses bot_id. The backend converts bot_name -> bot_id internally.
+"""
+
+from typing import Any, Dict, Optional, Union
+
+from pydantic import BaseModel
+
+from erdo.template import TemplateString
+from erdo.types import StepMetadata
+
+
+class InvokeParams(BaseModel):
+    """Invoke a bot with specified parameters and return the result parameters"""
+
+    name: str = "bot.invoke"  # Action type for roundtrip compatibility
+    bot_name: Optional[Union[str, TemplateString]] = (
+        None  # bot_name parameter (backend expects this, not bot_id)
+    )
+    parameters: Optional[Union[Dict[str, Any], TemplateString]] = (
+        None  # parameters parameter
+    )
+    bot_output_visibility_behaviour: Optional[Union[str, TemplateString]] = (
+        None  # Output visibility behaviour
+    )
+    transparent: Optional[Union[bool, TemplateString]] = (
+        None  # Whether the invocation is transparent
+    )
+    disable_tools: Optional[Union[bool, TemplateString]] = (
+        None  # Whether to disable tools for this invocation
+    )
+
+
+class AskParams(BaseModel):
+    """Ask a bot a question and get a response parameters"""
+
+    name: str = "bot.ask"  # Action type for roundtrip compatibility
+    query: Optional[Union[str, TemplateString]] = None  # query parameter
+    bot_name: Optional[Union[str, TemplateString]] = None  # bot_name parameter
+    bot_id: Optional[Union[str, TemplateString]] = None  # bot_id parameter
+    invocation_id: Optional[Union[str, TemplateString]] = (
+        None  # invocation_id parameter
+    )
+
+
+def invoke(
+    bot_name: Optional[Union[str, TemplateString]] = None,
+    parameters: Optional[Union[Dict[str, Any], TemplateString]] = None,
+    bot_output_visibility_behaviour: Optional[Union[str, TemplateString]] = None,
+    transparent: Optional[Union[bool, TemplateString]] = None,
+    disable_tools: Optional[Union[bool, TemplateString]] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> InvokeParams:
+    """Invoke a bot with specified parameters and return the result
+
+    The bot.invoke action expects bot_name (not bot_id) as the parameter.
+    The backend will look up the bot by name and convert to bot_id internally.
+
+    Args:
+        bot_name: Name of the bot to invoke
+        parameters: Parameters to pass to the bot
+        bot_output_visibility_behaviour: Output visibility behaviour
+        transparent: Whether the invocation is transparent
+        disable_tools: Whether to disable tools for this invocation
+
+    Returns:
+        InvokeParams: Type-safe parameter object
+    """
+    params_dict = {
+        "bot_name": bot_name,
+        "parameters": parameters,
+        "bot_output_visibility_behaviour": bot_output_visibility_behaviour,
+        "transparent": transparent,
+        "disable_tools": disable_tools,
+    }
+
+    # Remove None values for optional parameters
+    params_dict = {k: v for k, v in params_dict.items() if v is not None}
+    params_dict.update(params)
+
+    # Use normal constructor for proper validation
+    return InvokeParams(**params_dict)
+
+
+def ask(
+    query: Optional[Union[str, TemplateString]] = None,
+    bot_name: Optional[Union[str, TemplateString]] = None,
+    bot_id: Optional[Union[str, TemplateString]] = None,
+    invocation_id: Optional[Union[str, TemplateString]] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> AskParams:
+    """Ask a bot a question and get a response
+
+    Args:
+        query: Question to ask the bot
+        bot_name: Name of the bot to ask
+        bot_id: ID of the bot to ask (alternative to bot_name)
+        invocation_id: Invocation ID for tracking
+
+    Returns:
+        AskParams: Type-safe parameter object
+    """
+    params_dict = {
+        "query": query,
+        "bot_name": bot_name,
+        "bot_id": bot_id,
+        "invocation_id": invocation_id,
+    }
+
+    # Remove None values for optional parameters
+    params_dict = {k: v for k, v in params_dict.items() if v is not None}
+    params_dict.update(params)
+
+    # Use normal constructor for proper validation
+    return AskParams(**params_dict)

erdo/_generated/actions/codeexec.py

@@ -0,0 +1,172 @@
+"""
+Code execution actions for running and processing code in sandboxed environments service functions.
+Auto-generated - DO NOT EDIT.
+
+Provides type-safe action definitions for codeexec service.
+Actual execution happens in the Go backend after syncing.
+"""
+
+from typing import Any, Dict, Optional, Union
+
+from pydantic import BaseModel
+
+from erdo.template import TemplateString
+from erdo.types import StepMetadata
+
+
+class ExecuteParams(BaseModel):
+    """Execute code in a sandboxed environment and return the results parameters"""
+
+    name: str = "codeexec.execute"  # Action type for roundtrip compatibility
+    entrypoint: Optional[Union[str, TemplateString]] = None  # entrypoint parameter
+    code_files: Optional[Any] = None  # code_files parameter
+    resources: Optional[Any] = None  # resources parameter
+    encrypted_secrets: Optional[Union[str, TemplateString]] = (
+        None  # encrypted_secrets parameter
+    )
+    parameters: Optional[Union[str, TemplateString]] = None  # parameters parameter
+
+
+class ParseFileAsBotResourceParams(BaseModel):
+    """Parse a file from code execution results into a bot resource with dataset and analysis parameters"""
+
+    name: str = (
+        "codeexec.parse_file_as_bot_resource"  # Action type for roundtrip compatibility
+    )
+    file: Optional[Any] = None  # file parameter
+    files_analysis: Optional[Any] = None  # files_analysis parameter
+    files_metadata: Optional[Any] = None  # files_metadata parameter
+
+
+class ParseFileAsJsonParams(BaseModel):
+    """Parse a file from code execution results as JSON data parameters"""
+
+    name: str = "codeexec.parse_file_as_json"  # Action type for roundtrip compatibility
+    file: Optional[Any] = None  # file parameter
+    thread_id: Optional[Any] = None  # thread_id parameter
+
+
+class ExecuteResult(BaseModel):
+    """Execute code in a sandboxed environment and return the results result type
+
+    Result schema for codeexec.execute action.
+    """
+
+    output: str
+    error: Optional[str]
+    exit_code: Optional[float]
+    files: Optional[Any]
+
+
+class ParseFileAsBotResourceResult(BaseModel):
+    """Parse a file from code execution results into a bot resource with dataset and analysis result type
+
+    Result schema for codeexec.parse_file_as_bot_resource action.
+    """
+
+    data: Optional[Dict[str, Any]]  # Action result data
+
+
+class ParseFileAsJsonResult(BaseModel):
+    """Parse a file from code execution results as JSON data result type
+
+    Result schema for codeexec.parse_file_as_json action.
+    """
+
+    data: Any
+
+
+def execute(
+    entrypoint: Optional[Union[str, TemplateString]] = None,
+    code_files: Optional[Any] = None,
+    resources: Optional[Any] = None,
+    encrypted_secrets: Optional[Union[str, TemplateString]] = None,
+    parameters: Optional[Union[str, TemplateString]] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> ExecuteParams:
+    """Execute code in a sandboxed environment and return the results
+
+    Args:
+        entrypoint: entrypoint parameter
+        code_files: code_files parameter
+        resources: resources parameter
+        encrypted_secrets: encrypted_secrets parameter
+        parameters: parameters parameter
+
+    Returns:
+        ExecuteParams: Type-safe parameter object
+    """
+    param_dict = {
+        "entrypoint": entrypoint,
+        "code_files": code_files,
+        "resources": resources,
+        "encrypted_secrets": encrypted_secrets,
+        "parameters": parameters,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+
+    return ExecuteParams(**param_dict)
+
+
+def parse_file_as_bot_resource(
+    file: Optional[Any] = None,
+    files_analysis: Optional[Any] = None,
+    files_metadata: Optional[Any] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> ParseFileAsBotResourceParams:
+    """Parse a file from code execution results into a bot resource with dataset and analysis
+
+    Args:
+        file: file parameter
+        files_analysis: files_analysis parameter
+        files_metadata: files_metadata parameter
+
+    Returns:
+        ParseFileAsBotResourceParams: Type-safe parameter object
+    """
+    param_dict = {
+        "file": file,
+        "files_analysis": files_analysis,
+        "files_metadata": files_metadata,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+
+    return ParseFileAsBotResourceParams(**param_dict)
+
+
+def parse_file_as_json(
+    file: Optional[Any] = None,
+    thread_id: Optional[Any] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> ParseFileAsJsonParams:
+    """Parse a file from code execution results as JSON data
+
+    Args:
+        file: file parameter
+        thread_id: thread_id parameter
+
+    Returns:
+        ParseFileAsJsonParams: Type-safe parameter object
+    """
+    param_dict = {
+        "file": file,
+        "thread_id": thread_id,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+
+    return ParseFileAsJsonParams(**param_dict)
+
+
+# Associate parameter classes with their result types
+ExecuteParams._result = ExecuteResult
+ParseFileAsBotResourceParams._result = ParseFileAsBotResourceResult
+ParseFileAsJsonParams._result = ParseFileAsJsonResult

erdo/_generated/actions/llm.py

@@ -0,0 +1,104 @@
+"""
+LLM service functions.
+Auto-generated - DO NOT EDIT.
+
+Provides type-safe action definitions for LLM service with bot-compatible parameters.
+Actual execution happens in the Go backend after syncing.
+
+NOTE: This module is hardcoded to provide bot-compatible parameter names
+that match the exported bot code format.
+"""
+
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel
+
+from erdo.template import TemplateString
+from erdo.types import StepMetadata
+
+from ..types import Tool
+
+
+class MessageParams(BaseModel):
+    """LLM message parameters (bot-compatible)"""
+
+    name: str = "llm.message"  # Action type for roundtrip compatibility
+
+    # Bot definition parameters (high-level)
+    system_prompt: Optional[Union[str, TemplateString]] = (
+        None  # System prompt for the conversation
+    )
+    message_history: Optional[Union[List[Dict[str, Any]], TemplateString]] = (
+        None  # Previous messages in the conversation
+    )
+    query: Optional[Union[str, TemplateString]] = None  # User query/message
+    context: Optional[Union[str, TemplateString]] = None  # Additional context
+
+    # LLM configuration parameters
+    model: Optional[Union[str, TemplateString]] = None  # LLM model to use
+    tools: Optional[List[Tool]] = None  # Available tools for the LLM
+    response_format: Optional[Union[Dict[str, Any], TemplateString]] = (
+        None  # Response format specification
+    )
+    max_tokens: Optional[Union[int, TemplateString]] = (
+        None  # Maximum tokens in response
+    )
+    metadata: Optional[Union[Dict[str, Any], TemplateString]] = (
+        None  # Additional metadata
+    )
+    disable_tools: Optional[Union[bool, TemplateString]] = (
+        None  # Whether to disable tools for this message
+    )
+
+
+def message(
+    system_prompt: Optional[Union[str, TemplateString]] = None,
+    message_history: Optional[Union[List[Dict[str, Any]], TemplateString]] = None,
+    query: Optional[Union[str, TemplateString]] = None,
+    context: Optional[Union[str, TemplateString]] = None,
+    model: Optional[Union[str, TemplateString]] = None,
+    tools: Optional[List[Tool]] = None,
+    response_format: Optional[Union[Dict[str, Any], TemplateString]] = None,
+    max_tokens: Optional[Union[int, TemplateString]] = None,
+    metadata: Optional[Union[Dict[str, Any], TemplateString]] = None,
+    disable_tools: Optional[Union[bool, TemplateString]] = None,
+    step_metadata: Optional[StepMetadata] = None,
+) -> MessageParams:
+    """Generate LLM message with bot-compatible parameters
+
+    This function accepts the same parameters that bot definitions use,
+    making it compatible with exported bot code.
+
+    Args:
+        system_prompt: System prompt for the conversation
+        message_history: Previous messages in the conversation
+        query: User query/message
+        context: Additional context
+        model: LLM model to use
+        tools: Available tools for the LLM
+        response_format: Response format specification
+        max_tokens: Maximum tokens in response
+        metadata: Additional metadata
+        disable_tools: Whether to disable tools for this message
+
+    Returns:
+        MessageParams: Type-safe parameter object
+    """
+    params = {
+        "system_prompt": system_prompt,
+        "message_history": message_history,
+        "query": query,
+        "context": context,
+        "model": model,
+        "tools": tools,
+        "response_format": response_format,
+        "max_tokens": max_tokens,
+        "metadata": metadata,
+        "disable_tools": disable_tools,
+    }
+
+    # Remove None values for optional parameters
+    params = {k: v for k, v in params.items() if v is not None}
+
+    # Use normal constructor for proper validation
+    return MessageParams(**params)