sypho-sdk 0.1.0__tar.gz

sypho_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: sypho-sdk
+Version: 0.1.0
+Summary: Python SDK for building and deploying Sypho agents
+Author-email: Sypho <hello@sypho.ai>
+License: MIT
+Project-URL: Homepage, https://sypho.ai
+Project-URL: Documentation, https://docs.sypho.ai
+Project-URL: Repository, https://github.com/sypho/sypho-sdk
+Keywords: agent,ai,automation,sdk,sypho
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.3.1
+Requires-Dist: langchain>=1.2.13
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: requests>=2.32.5
+Requires-Dist: python-socketio[asyncio-client]>=5.11.0
+
+# Sypho SDK
+
+Python SDK for building and deploying AI agents on the Sypho platform.
+
+## Installation
+
+```bash
+pip install sypho-sdk
+```
+
+## Quick Start
+
+### 1. Define an Agent with Entrypoints
+
+```python
+from sypho_sdk import entrypoint, tool, AgentContext
+
+@entrypoint(name="search", description="Search for information")
+async def search_handler(input: dict, context: AgentContext):
+    query = input["query"]
+
+    # Call tools
+    results = await context.call_tool("web_search", {"query": query})
+
+    return {"results": results}
+
+@tool(name="web_search", description="Search the web")
+def web_search(query: str) -> dict:
+    # Your search implementation
+    return {"results": [...]}
+```
+
+### 2. Auto-Discovery
+
+The SDK automatically discovers all `@entrypoint` and `@tool` decorated functions when packaging your agent:
+
+```bash
+python -m sypho_sdk.auto_package my_agent.main my-agent 0.1.0
+```
+
+This generates a complete manifest with all entrypoints and tools automatically discovered.
+
+### 3. Local Development
+
+```python
+from sypho_sdk import Agent
+
+# Traditional agent definition (also supported)
+agent = Agent("my-agent")
+
+@agent.task
+async def run(input: dict, context):
+    # Agent logic
+    return {"output": "result"}
+```
+
+## Features
+
+- **@entrypoint decorator**: Mark functions as agent entry points
+- **@tool decorator**: Define reusable tools with automatic schema generation
+- **Auto-discovery**: Automatically generate manifests from decorated functions
+- **Agent Context**: Built-in context for tool calls, LLM interactions, and state management
+- **Local tools**: Mark tools as local with `@tool(local=True)`
+- **Type hints**: Automatic parameter schema generation from Python type hints
+
+## API Reference
+
+### Decorators
+
+#### `@entrypoint(name=None, description=None)`
+
+Marks a function as an agent entrypoint. Entrypoints are the main execution paths for your agent.
+
+```python
+@entrypoint(name="main", description="Main entry point")
+async def main_handler(input: dict, context: AgentContext):
+    return {"result": "success"}
+```
+
+#### `@tool(name=None, description=None, parameters=None, local=False)`
+
+Defines a tool that can be called by the agent.
+
+```python
+@tool(name="calculate", description="Perform calculations")
+def calculate(a: int, b: int, operation: str = "add") -> int:
+    if operation == "add":
+        return a + b
+    elif operation == "multiply":
+        return a * b
+```
+
+### Classes
+
+#### `AgentContext`
+
+Provides methods for interacting with the platform during agent execution:
+
+- `await context.call_tool(name, args)`: Call a tool
+- `await context.chat(messages, tools)`: Interact with LLM
+- `context.run_loop()`: Start agentic execution loop
+
+#### `Agent`
+
+Traditional agent definition class (backwards compatible):
+
+```python
+agent = Agent("agent-name")
+
+@agent.task
+async def run(input, context):
+    return {"output": "result"}
+```
+
+## Examples
+
+### Multi-Entrypoint Agent
+
+```python
+from sypho_sdk import entrypoint, tool, AgentContext
+
+@entrypoint(name="analyze", description="Analyze data")
+async def analyze(input: dict, context: AgentContext):
+    data = input["data"]
+    analysis = await context.call_tool("process_data", {"data": data})
+    return {"analysis": analysis}
+
+@entrypoint(name="report", description="Generate report")
+async def report(input: dict, context: AgentContext):
+    analysis_result = input["analysis_result"]
+    report = await context.call_tool("format_report", analysis_result)
+    return {"report": report}
+
+@tool(name="process_data")
+def process_data(data: list) -> dict:
+    return {"processed": len(data)}
+
+@tool(name="format_report")
+def format_report(data: dict) -> str:
+    return f"Analysis Report: {data}"
+```
+
+## Development
+
+### Building the Package
+
+```bash
+python -m build
+```
+
+### Installing Locally
+
+```bash
+pip install -e .
+```
+
+## License
+
+MIT
+
+## Support
+
+- Documentation: https://docs.sypho.ai
+- GitHub: https://github.com/sypho/sypho-sdk
+- Website: https://sypho.ai

sypho_sdk-0.1.0/README.md

@@ -0,0 +1,165 @@
+# Sypho SDK
+
+Python SDK for building and deploying AI agents on the Sypho platform.
+
+## Installation
+
+```bash
+pip install sypho-sdk
+```
+
+## Quick Start
+
+### 1. Define an Agent with Entrypoints
+
+```python
+from sypho_sdk import entrypoint, tool, AgentContext
+
+@entrypoint(name="search", description="Search for information")
+async def search_handler(input: dict, context: AgentContext):
+    query = input["query"]
+
+    # Call tools
+    results = await context.call_tool("web_search", {"query": query})
+
+    return {"results": results}
+
+@tool(name="web_search", description="Search the web")
+def web_search(query: str) -> dict:
+    # Your search implementation
+    return {"results": [...]}
+```
+
+### 2. Auto-Discovery
+
+The SDK automatically discovers all `@entrypoint` and `@tool` decorated functions when packaging your agent:
+
+```bash
+python -m sypho_sdk.auto_package my_agent.main my-agent 0.1.0
+```
+
+This generates a complete manifest with all entrypoints and tools automatically discovered.
+
+### 3. Local Development
+
+```python
+from sypho_sdk import Agent
+
+# Traditional agent definition (also supported)
+agent = Agent("my-agent")
+
+@agent.task
+async def run(input: dict, context):
+    # Agent logic
+    return {"output": "result"}
+```
+
+## Features
+
+- **@entrypoint decorator**: Mark functions as agent entry points
+- **@tool decorator**: Define reusable tools with automatic schema generation
+- **Auto-discovery**: Automatically generate manifests from decorated functions
+- **Agent Context**: Built-in context for tool calls, LLM interactions, and state management
+- **Local tools**: Mark tools as local with `@tool(local=True)`
+- **Type hints**: Automatic parameter schema generation from Python type hints
+
+## API Reference
+
+### Decorators
+
+#### `@entrypoint(name=None, description=None)`
+
+Marks a function as an agent entrypoint. Entrypoints are the main execution paths for your agent.
+
+```python
+@entrypoint(name="main", description="Main entry point")
+async def main_handler(input: dict, context: AgentContext):
+    return {"result": "success"}
+```
+
+#### `@tool(name=None, description=None, parameters=None, local=False)`
+
+Defines a tool that can be called by the agent.
+
+```python
+@tool(name="calculate", description="Perform calculations")
+def calculate(a: int, b: int, operation: str = "add") -> int:
+    if operation == "add":
+        return a + b
+    elif operation == "multiply":
+        return a * b
+```
+
+### Classes
+
+#### `AgentContext`
+
+Provides methods for interacting with the platform during agent execution:
+
+- `await context.call_tool(name, args)`: Call a tool
+- `await context.chat(messages, tools)`: Interact with LLM
+- `context.run_loop()`: Start agentic execution loop
+
+#### `Agent`
+
+Traditional agent definition class (backwards compatible):
+
+```python
+agent = Agent("agent-name")
+
+@agent.task
+async def run(input, context):
+    return {"output": "result"}
+```
+
+## Examples
+
+### Multi-Entrypoint Agent
+
+```python
+from sypho_sdk import entrypoint, tool, AgentContext
+
+@entrypoint(name="analyze", description="Analyze data")
+async def analyze(input: dict, context: AgentContext):
+    data = input["data"]
+    analysis = await context.call_tool("process_data", {"data": data})
+    return {"analysis": analysis}
+
+@entrypoint(name="report", description="Generate report")
+async def report(input: dict, context: AgentContext):
+    analysis_result = input["analysis_result"]
+    report = await context.call_tool("format_report", analysis_result)
+    return {"report": report}
+
+@tool(name="process_data")
+def process_data(data: list) -> dict:
+    return {"processed": len(data)}
+
+@tool(name="format_report")
+def format_report(data: dict) -> str:
+    return f"Analysis Report: {data}"
+```
+
+## Development
+
+### Building the Package
+
+```bash
+python -m build
+```
+
+### Installing Locally
+
+```bash
+pip install -e .
+```
+
+## License
+
+MIT
+
+## Support
+
+- Documentation: https://docs.sypho.ai
+- GitHub: https://github.com/sypho/sypho-sdk
+- Website: https://sypho.ai

sypho_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sypho-sdk"
+version = "0.1.0"
+description = "Python SDK for building and deploying Sypho agents"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [
+    {name = "Sypho", email = "hello@sypho.ai"}
+]
+keywords = ["agent", "ai", "automation", "sdk", "sypho"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "click>=8.3.1",
+    "langchain>=1.2.13",
+    "pyyaml>=6.0.3",
+    "requests>=2.32.5",
+    "python-socketio[asyncio-client]>=5.11.0",
+]
+
+[project.urls]
+Homepage = "https://sypho.ai"
+Documentation = "https://docs.sypho.ai"
+Repository = "https://github.com/sypho/sypho-sdk"
+
+[tool.setuptools.packages.find]
+include = ["sypho_sdk*"]
+
+[tool.setuptools.package-data]
+# Ship non-Python data files or `pip install .` drops them (the base image installs
+# the SDK this way). local_tools/assets holds the bundled sample upload files and the
+# fake-mic WAV — without these, set_files() for uploads and dictation audio fail with
+# FileNotFoundError inside the container.
+sypho_sdk = ["py.typed"]
+"sypho_sdk.local_tools" = ["assets/*"]

sypho_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sypho_sdk-0.1.0/sypho_sdk/__init__.py

@@ -0,0 +1,58 @@
+"""
+Sypho SDK - Python library for building and deploying AI agents.
+
+Usage:
+    from sypho_sdk import entrypoint, tool, AgentContext, Agent
+
+    @entrypoint(name="main", description="Main entry point")
+    async def main_handler(input: dict, context: AgentContext):
+        result = await context.call_tool("my_tool", {"arg": "value"})
+        return {"result": result}
+
+    @tool(name="my_tool", description="A custom tool")
+    def my_tool(arg: str) -> dict:
+        return {"processed": arg}
+"""
+
+__version__ = "0.1.0"
+
+# Core decorators
+from .entrypoint import entrypoint
+from .tool import tool
+
+# Agent classes
+from .agent.agent import Agent
+from .agent.agent_context import AgentContext
+
+# Discovery utilities
+from .discovery import discover_entrypoints, discover_tools, scan_module_tree
+
+# Manifest types (for advanced users)
+from .manifest.manifest_types import (
+    AgentManifest,
+    EntrypointManifest,
+    ToolManifest,
+    AgentModeConfig,
+    ExecutionMode,
+)
+
+__all__ = [
+    # Version
+    "__version__",
+    # Decorators
+    "entrypoint",
+    "tool",
+    # Classes
+    "Agent",
+    "AgentContext",
+    # Discovery
+    "discover_entrypoints",
+    "discover_tools",
+    "scan_module_tree",
+    # Types
+    "AgentManifest",
+    "EntrypointManifest",
+    "ToolManifest",
+    "AgentModeConfig",
+    "ExecutionMode",
+]

sypho_sdk-0.1.0/sypho_sdk/agent/agent.py

@@ -0,0 +1,80 @@
+from sypho_sdk.manifest.manifest_types import AgentManifest, AgentModeConfig, ExecutionMode, SkillManifest
+
+
+class Agent:
+    def __init__(
+            self,
+            name: str,
+            tools=None,
+            skills: list[SkillManifest] | None = None,
+            execution_mode: ExecutionMode = "worker",
+            agent_config: AgentModeConfig | None = None,
+            allowed_sub_agents: list[str] | None = None,
+            structured_data_dependencies: dict | None = None,
+    ):
+        self.name = name
+        self.tools = list(tools or [])
+        self.skills = skills or []
+        self.execution_mode = execution_mode
+        self.agent_config = agent_config
+        self.allowed_sub_agents = allowed_sub_agents or []
+        self.structured_data_dependencies = structured_data_dependencies
+        self._task = None
+
+        if execution_mode == "agent" and not agent_config:
+            raise ValueError("agent_config is required when execution_mode is 'agent'")
+
+        if self.allowed_sub_agents:
+            from sypho_sdk.local_tools.sub_run_tools import make_spawn_sub_run_tool
+
+            self.tools.append(make_spawn_sub_run_tool(self.allowed_sub_agents))
+
+    def task(self, fn):
+        self._task = fn
+        return fn
+
+    async def run(self, input_data, ctx):
+        if not self._task:
+            raise RuntimeError("No task registered")
+        return await self._task(input_data, ctx)
+
+    def manifest_for_entrypoint(self, entrypoint: str, version: str = "0.1.0") -> AgentManifest:
+        local_tool_names = [
+            t._tool_name for t in self.tools if getattr(t, '_is_local_tool', False)
+        ]
+
+        entrypoint_manifest = {
+            "tools": [
+                {
+                    "name": t._tool_name,
+                    "description": t._tool_description,
+                    "parameters": t._tool_parameters,
+                }
+                for t in self.tools
+            ]
+        }
+
+        if local_tool_names:
+            entrypoint_manifest["local_tools"] = local_tool_names
+
+        if self.skills:
+            entrypoint_manifest["skills"] = self.skills
+
+        if self.allowed_sub_agents:
+            entrypoint_manifest["allowed_sub_agents"] = self.allowed_sub_agents
+
+        manifest: AgentManifest = {
+            "schema_version": "1.0",
+            "agent_name": self.name,
+            "version": version,
+            "execution_mode": self.execution_mode,
+            "entrypoints": {entrypoint: entrypoint_manifest},
+        }
+
+        if self.execution_mode == "agent" and self.agent_config:
+            manifest["agent_config"] = self.agent_config
+
+        if self.structured_data_dependencies:
+            manifest["structured_data_dependencies"] = self.structured_data_dependencies
+
+        return manifest