FibonacciClient

from fibonacci import FibonacciClient

client = FibonacciClient(
    api_key="your-api-key",
    base_url="https://api.fibonacci.dev",
    timeout=60
)

import os
from fibonacci import FibonacciClient

# Uses FIBONACCI_API_KEY environment variable
client = FibonacciClient.from_env()

from fibonacci import FibonacciClient

# Uses system keychain
client = FibonacciClient.from_keychain()

client.deploy(
    workflow: Workflow | str,
    environment: str = "production",
    version: str | None = None
) -> DeploymentResult

result = client.deploy(
    workflow="workflows/analyzer.yaml",
    environment="production",
    version="1.2.0"
)
print(f"Deployed: {result.deployment_id}")

client.execute(
    workflow_name: str,
    inputs: dict,
    environment: str = "production",
    timeout: int | None = None,
    async_execution: bool = False
) -> ExecutionResult | ExecutionHandle

# Synchronous
result = client.execute(
    workflow_name="customer-analyzer",
    inputs={"text": "Hello world"}
)
print(result.outputs)

# Asynchronous
handle = client.execute(
    workflow_name="long-running",
    inputs={"data": large_data},
    async_execution=True
)
# Check status later
status = client.get_execution(handle.execution_id)

client.get_execution(execution_id: str) -> ExecutionResult

client.list_executions(
    workflow_name: str | None = None,
    environment: str | None = None,
    status: str | None = None,
    limit: int = 100,
    offset: int = 0
) -> list[ExecutionSummary]

client.cancel_execution(execution_id: str) -> bool

client.list_workflows(
    environment: str | None = None
) -> list[WorkflowSummary]

client.get_workflow(
    workflow_name: str,
    environment: str = "production"
) -> WorkflowDetails

client.delete_workflow(
    workflow_name: str,
    environment: str = "production"
) -> bool

client.list_tools(
    category: str | None = None
) -> list[ToolInfo]

tools = client.list_tools(category="google")
for tool in tools:
    print(f"{tool.name}: {tool.description}")

client.get_tool(tool_name: str) -> ToolDetails

client.connect_tool(
    tool_name: str,
    credentials: dict | None = None
) -> ConnectionResult

# OAuth-based connection (opens browser)
result = client.connect_tool("google")

# Credential-based connection
result = client.connect_tool("slack", credentials={
    "bot_token": "xoxb-..."
})

client.get_memory(
    key: str,
    scope: str = "workflow",
    user_id: str | None = None
) -> Any

client.set_memory(
    key: str,
    value: Any,
    scope: str = "workflow",
    user_id: str | None = None,
    ttl: int | None = None
) -> bool

client.delete_memory(
    key: str,
    scope: str = "workflow",
    user_id: str | None = None
) -> bool

from fibonacci import AsyncFibonacciClient
import asyncio

async def main():
    client = AsyncFibonacciClient(api_key="...")
    
    result = await client.execute(
        workflow_name="analyzer",
        inputs={"text": "Hello"}
    )
    print(result.outputs)

asyncio.run(main())

@dataclass
class DeploymentResult:
    deployment_id: str
    workflow_name: str
    version: str
    environment: str
    status: str
    url: str
    created_at: datetime

@dataclass
class ExecutionResult:
    execution_id: str
    workflow_name: str
    status: str  # running, success, failed
    outputs: dict | None
    error: str | None
    duration_ms: int
    started_at: datetime
    completed_at: datetime | None

@dataclass
class WorkflowSummary:
    name: str
    version: str
    environment: str
    status: str
    last_deployed: datetime
    execution_count: int

from fibonacci import FibonacciClient
from fibonacci.exceptions import (
    AuthenticationError,
    RateLimitError,
    WorkflowNotFoundError
)

client = FibonacciClient(api_key="...")

try:
    result = client.execute(
        workflow_name="my-workflow",
        inputs={"text": "Hello"}
    )
except AuthenticationError:
    print("Invalid API key")
except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after}s")
except WorkflowNotFoundError:
    print("Workflow not deployed")

from fibonacci import FibonacciClient, Workflow

# Initialize client
client = FibonacciClient.from_env()

# Deploy workflow
workflow = Workflow.from_yaml("workflows/analyzer.yaml")
deployment = client.deploy(
    workflow=workflow,
    environment="production",
    version="1.0.0"
)
print(f"Deployed: {deployment.url}")

# Execute workflow
result = client.execute(
    workflow_name="analyzer",
    inputs={"text": "Analyze this text"},
    timeout=60
)

if result.status == "success":
    print(f"Result: {result.outputs}")
else:
    print(f"Error: {result.error}")

# List recent executions
executions = client.list_executions(
    workflow_name="analyzer",
    status="failed",
    limit=10
)
for ex in executions:
    print(f"{ex.execution_id}: {ex.status}")