ocode 0.1.0__py3-none-any.whl

ocode/__init__.py

@@ -0,0 +1,26 @@
+from .agent import Agent
+from .client import OpenCodeClient
+from .config import OpenCodeConfig
+from .exceptions import (
+    MCPReadinessError,
+    OpenCodeError,
+    OpenCodeHTTPError,
+    SessionNotFoundError,
+    TaskTimeoutError,
+    ToolNotFoundError,
+)
+from .orchestrator import MultiAgentRunner, SingleAgentRunner
+
+__all__ = [
+    "Agent",
+    "MCPReadinessError",
+    "MultiAgentRunner",
+    "OpenCodeClient",
+    "OpenCodeConfig",
+    "OpenCodeError",
+    "OpenCodeHTTPError",
+    "SessionNotFoundError",
+    "SingleAgentRunner",
+    "TaskTimeoutError",
+    "ToolNotFoundError",
+]

ocode/agent.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from dataclasses import asdict, is_dataclass
+from typing import Any
+
+from .client import OpenCodeClient
+from .config import OpenCodeConfig
+from .managers import MCPManager, SessionManager, ToolManager
+from .models import ExecutionMetadata, ExecutionResult, StreamEvent
+from .orchestrator import EventStreamer, SingleAgentRunner
+
+
+class Agent:
+    def __init__(
+        self,
+        name: str = "OpenCodeAgent",
+        system_prompt: str | None = None,
+        *,
+        agent: str | None = None,
+        model: str | dict[str, Any] | None = None,
+        tools: list[str] | None = None,
+        mcp_servers: list[str] | None = None,
+        project_path: str | None = None,
+        base_url: str | None = None,
+        streaming: bool | None = None,
+        verbose: bool | None = None,
+    ):
+        config = OpenCodeConfig.from_env()
+        if project_path is not None:
+            config.project_path = project_path
+        if base_url is not None:
+            config.base_url = base_url
+        if streaming is not None:
+            config.streaming = streaming
+        if verbose is not None:
+            config.verbose = verbose
+        if model is not None:
+            config.default_model = model
+        if agent is not None:
+            config.default_agent = agent
+        if tools is not None:
+            config.default_tools = tools
+
+        self.name = name
+        self.system_prompt = system_prompt
+        self.default_mcp_servers = mcp_servers or []
+        self.config = config
+        self.client = OpenCodeClient(config=config)
+        self.session_manager = SessionManager(self.client)
+        self.tool_manager = ToolManager(self.client)
+        self.mcp_manager = MCPManager(self.client)
+        self.runner = SingleAgentRunner(
+            client=self.client,
+            config=self.config,
+            session_manager=self.session_manager,
+            tool_manager=self.tool_manager,
+            mcp_manager=self.mcp_manager,
+        )
+        self.event_streamer = EventStreamer(self.client)
+        self.session_id: str | None = None
+
+    def close(self) -> None:
+        self.client.close()
+
+    def set_model(self, model: str | dict[str, Any] | None) -> None:
+        self.config.default_model = model
+
+    def list_models(self, include_details: bool = False) -> list[Any]:
+        return self.client.list_available_models(include_details=include_details)
+
+    def run(
+        self,
+        user_prompt: str,
+        *,
+        agent: str | None = None,
+        model: str | dict[str, Any] | None = None,
+        tools: list[str] | None = None,
+        mcp_servers: list[str] | None = None,
+        session_id: str | None = None,
+        return_result: bool = False,
+    ) -> str | ExecutionResult:
+        result = self.runner.run(
+            user_prompt,
+            agent=agent,
+            model=model,
+            tools=tools,
+            mcp_servers=mcp_servers or self.default_mcp_servers or None,
+            session_id=session_id or self.session_id,
+            title=self.name,
+            system=self.system_prompt,
+        )
+        self.session_id = result.metadata.session_id
+        return result if return_result else result.output
+
+    def run_async(
+        self,
+        user_prompt: str,
+        *,
+        agent: str | None = None,
+        model: str | dict[str, Any] | None = None,
+        tools: list[str] | None = None,
+        session_id: str | None = None,
+    ) -> ExecutionMetadata:
+        metadata = self.runner.run_async(
+            user_prompt,
+            agent=agent,
+            model=model,
+            tools=tools,
+            session_id=session_id or self.session_id,
+            title=self.name,
+        )
+        self.session_id = metadata.session_id
+        return metadata
+
+    def run_shell(
+        self,
+        command: str,
+        *,
+        agent: str | None = None,
+        model: str | dict[str, Any] | None = None,
+        return_result: bool = False,
+    ) -> str | ExecutionResult:
+        if not self.session_id:
+            self.session_id = self.client.create_session(title=self.name).id
+        result = self.runner.run_shell(command, session_id=self.session_id, agent=agent, model=model)
+        return result if return_result else result.output
+
+    def stream(self, *, limit: int = 10) -> list[StreamEvent]:
+        return self.event_streamer.stream(limit=limit)
+
+    @staticmethod
+    def to_dict(value: Any) -> Any:
+        if isinstance(value, list):
+            return [Agent.to_dict(item) for item in value]
+        if is_dataclass(value):
+            return asdict(value)
+        return value

ocode/cli.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import argparse
+from dataclasses import asdict, is_dataclass
+import json
+from typing import Any
+
+from .client import OpenCodeClient
+from .config import OpenCodeConfig
+from .logging import configure_logging
+from .managers import MCPManager, SessionManager, ToolManager
+from .orchestrator import EventStreamer, MultiAgentRunner, SingleAgentRunner
+
+
+def _build_runtime(config: OpenCodeConfig) -> dict[str, Any]:
+    client = OpenCodeClient(config)
+    session_manager = SessionManager(client)
+    tool_manager = ToolManager(client)
+    mcp_manager = MCPManager(client)
+    return {
+        "client": client,
+        "single": SingleAgentRunner(client=client, config=config, session_manager=session_manager, tool_manager=tool_manager, mcp_manager=mcp_manager),
+        "multi": MultiAgentRunner(client=client, config=config, session_manager=session_manager, tool_manager=tool_manager, mcp_manager=mcp_manager),
+        "session_manager": session_manager,
+        "tool_manager": tool_manager,
+        "mcp_manager": mcp_manager,
+        "event_streamer": EventStreamer(client),
+    }
+
+
+def _to_json(payload: Any) -> str:
+    def _default(obj: Any) -> Any:
+        if is_dataclass(obj):
+            return asdict(obj)
+        return str(obj)
+    return json.dumps(payload, indent=2, default=_default)
+
+
+def _print_json(payload: Any) -> None:
+    print(_to_json(payload))
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="opencode-agent",
+        description="Python orchestration CLI for the OpenCode Agent API.",
+    )
+    parser.add_argument("--base-url", help="Override OpenCode base URL")
+    parser.add_argument("--project-path", help="Override OpenCode project path")
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose logging")
+    parser.add_argument("--json", dest="output_json", action="store_true", help="Output raw JSON instead of plain text")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    run_parser = subparsers.add_parser("run", help="Run a single-agent task")
+    run_parser.add_argument("prompt")
+    run_parser.add_argument("--agent")
+    run_parser.add_argument("--model")
+    run_parser.add_argument("--session-id")
+    run_parser.add_argument("--title")
+    run_parser.add_argument("--tool", action="append", default=[])
+    run_parser.add_argument("--mcp", action="append", default=[])
+    run_parser.add_argument("--stream", action="store_true")
+    run_parser.add_argument("--async", dest="async_mode", action="store_true")
+
+    orchestration_parser = subparsers.add_parser("orchestrate", help="Run a multi-agent task")
+    orchestration_parser.add_argument("prompt")
+    orchestration_parser.add_argument("--strategy", default="plan-explore-build-review")
+    orchestration_parser.add_argument("--session-id")
+    orchestration_parser.add_argument("--title")
+    orchestration_parser.add_argument("--tool", action="append", default=[])
+    orchestration_parser.add_argument("--mcp", action="append", default=[])
+    orchestration_parser.add_argument("--parallel", action="store_true")
+
+    sessions_parser = subparsers.add_parser("sessions", help="Inspect sessions")
+    sessions_subparsers = sessions_parser.add_subparsers(dest="sessions_command", required=True)
+    sessions_subparsers.add_parser("list", help="List sessions")
+    status_parser = sessions_subparsers.add_parser("status", help="Show session status")
+    status_parser.add_argument("session_id", nargs="?")
+    abort_parser = sessions_subparsers.add_parser("abort", help="Abort a session")
+    abort_parser.add_argument("session_id")
+
+    tool_parser = subparsers.add_parser("tools", help="Inspect tools")
+    tool_parser.add_argument("--provider")
+    tool_parser.add_argument("--model")
+    tool_parser.add_argument("--ids", action="store_true")
+
+    mcp_parser = subparsers.add_parser("mcp", help="Inspect or register MCP servers")
+    mcp_subparsers = mcp_parser.add_subparsers(dest="mcp_command", required=True)
+    mcp_subparsers.add_parser("list", help="List MCP servers")
+    register_parser = mcp_subparsers.add_parser("register", help="Register an MCP server")
+    register_parser.add_argument("name")
+    register_parser.add_argument("config_json")
+
+    shell_parser = subparsers.add_parser("shell", help="Run a shell command inside a session")
+    shell_parser.add_argument("session_id")
+    shell_parser.add_argument("command_text")
+    shell_parser.add_argument("--agent")
+    shell_parser.add_argument("--model")
+
+    stream_parser = subparsers.add_parser("stream", help="Read SSE events")
+    stream_parser.add_argument("--limit", type=int, default=10)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    config = OpenCodeConfig.from_env()
+    if args.base_url:
+        config.base_url = args.base_url
+    if args.project_path:
+        config.project_path = args.project_path
+    if args.verbose:
+        config.verbose = True
+    configure_logging(config.verbose)
+    runtime = _build_runtime(config)
+    client: OpenCodeClient = runtime["client"]
+    output_json: bool = args.output_json
+    try:
+        if args.command == "run":
+            if args.async_mode:
+                result = runtime["single"].run_async(
+                    args.prompt,
+                    agent=args.agent,
+                    model=args.model,
+                    session_id=args.session_id,
+                    title=args.title,
+                    tools=args.tool or None,
+                )
+                # async just returns metadata — always show as JSON
+                _print_json(result)
+                return 0
+            result = runtime["single"].run(
+                args.prompt,
+                agent=args.agent,
+                model=args.model,
+                session_id=args.session_id,
+                title=args.title,
+                tools=args.tool or None,
+                mcp_servers=args.mcp or None,
+                streaming=args.stream,
+            )
+            if output_json:
+                _print_json({"output": result.output, "metadata": result.metadata})
+            else:
+                print(result.output)
+            return 0
+
+        if args.command == "orchestrate":
+            result = runtime["multi"].run(
+                args.prompt,
+                strategy=args.strategy,
+                session_id=args.session_id,
+                title=args.title,
+                tools=args.tool or None,
+                mcp_servers=args.mcp or None,
+                parallel=args.parallel,
+            )
+            if output_json:
+                _print_json(result)
+            else:
+                print(result.output)
+            return 0
+
+        if args.command == "sessions":
+            if args.sessions_command == "list":
+                _print_json(client.list_sessions())
+                return 0
+            if args.sessions_command == "status":
+                status = client.get_session_status()
+                if args.session_id:
+                    _print_json(status.get(args.session_id))
+                else:
+                    _print_json(status)
+                return 0
+            if args.sessions_command == "abort":
+                client.abort_session(args.session_id)
+                print(f"aborted {args.session_id}")
+                return 0
+
+        if args.command == "tools":
+            _print_json(client.list_tool_ids() if args.ids else client.list_tools(provider=args.provider, model=args.model))
+            return 0
+
+        if args.command == "mcp":
+            if args.mcp_command == "list":
+                _print_json(runtime["mcp_manager"].list_servers())
+                return 0
+            if args.mcp_command == "register":
+                _print_json(runtime["mcp_manager"].register(args.name, json.loads(args.config_json)))
+                return 0
+
+        if args.command == "shell":
+            result = runtime["single"].run_shell(args.command_text, session_id=args.session_id, agent=args.agent, model=args.model)
+            if output_json:
+                _print_json(result)
+            else:
+                print(result.output)
+            return 0
+
+        if args.command == "stream":
+            _print_json(runtime["event_streamer"].stream(limit=args.limit))
+            return 0
+
+        return 1
+    finally:
+        client.close()