flowai-cli 0.2.0__py3-none-any.whl

flowai/providers/ollama.py

@@ -0,0 +1,237 @@
+"""Ollama Local Inference Provider implementation."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import AsyncIterator, Sequence
+from typing import Any
+
+import httpx
+
+from flowai.errors import ConfigurationError
+from flowai.providers.base import (
+    BaseProvider,
+    Message,
+    ProviderResponse,
+    ProviderUsage,
+    StreamChunk,
+    ToolCall,
+)
+
+
+class OllamaProvider(BaseProvider):
+    """Local Ollama Provider running at http://localhost:11434."""
+
+    DEFAULT_BASE_URL = "http://localhost:11434"
+    requires_api_key = False
+
+    def __init__(
+        self,
+        model: str = "llama3.2",
+        api_key: str | None = None,
+        base_url: str | None = None,
+        timeout: float = 120.0,
+        **kwargs: Any,
+    ):
+        resolved_url = base_url or os.getenv("OLLAMA_BASE_URL", self.DEFAULT_BASE_URL)
+        super().__init__(
+            model=model,
+            api_key=api_key,
+            base_url=resolved_url,
+            timeout=timeout,
+            **kwargs,
+        )
+
+    def _convert_messages(self, messages: Sequence[Message]) -> list[dict[str, Any]]:
+        out = []
+        for m in messages:
+            msg: dict[str, Any] = {"role": m.role, "content": m.content or ""}
+            if m.tool_calls:
+                msg["tool_calls"] = [
+                    {
+                        "function": {
+                            "name": tc.name,
+                            "arguments": tc.arguments,
+                        }
+                    }
+                    for tc in m.tool_calls
+                ]
+            out.append(msg)
+        return out
+
+    async def generate(
+        self,
+        messages: Sequence[Message],
+        tools: Sequence[dict[str, Any]] | None = None,
+        temperature: float = 0.7,
+        max_tokens: int | None = None,
+        **kwargs: Any,
+    ) -> ProviderResponse:
+        url = f"{self.base_url.rstrip('/')}/api/chat"
+        payload: dict[str, Any] = {
+            "model": self.model,
+            "messages": self._convert_messages(messages),
+            "stream": False,
+            "options": {"temperature": temperature},
+        }
+        if max_tokens:
+            payload["options"]["num_predict"] = max_tokens
+        if tools:
+            # Transform OpenAI-style tools to Ollama tools if needed
+            ollama_tools = []
+            for t in tools:
+                if "function" in t:
+                    ollama_tools.append(t)
+                else:
+                    ollama_tools.append({"type": "function", "function": t})
+            payload["tools"] = ollama_tools
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                resp = await client.post(url, json=payload)
+                await self._raise_for_status(resp)
+                data = resp.json()
+        except httpx.ConnectError as exc:
+            raise self._not_running(exc) from exc
+
+        raw_msg = data.get("message", {})
+        content = raw_msg.get("content", "")
+        tool_calls: list[ToolCall] = []
+
+        if raw_msg.get("tool_calls"):
+            for i, tc in enumerate(raw_msg["tool_calls"]):
+                fn = tc.get("function", {})
+                args = fn.get("arguments", {})
+                if isinstance(args, str):
+                    try:
+                        args = json.loads(args)
+                    except Exception:
+                        args = {"raw": args}
+                tool_calls.append(
+                    ToolCall(
+                        id=f"call_{i}_{fn.get('name')}",
+                        name=fn.get("name", ""),
+                        arguments=args,
+                    )
+                )
+
+        prompt_eval = data.get("prompt_eval_count", 0)
+        eval_count = data.get("eval_count", 0)
+        usage = ProviderUsage(
+            prompt_tokens=prompt_eval,
+            completion_tokens=eval_count,
+            total_tokens=prompt_eval + eval_count,
+        )
+
+        return ProviderResponse(
+            content=content,
+            tool_calls=tool_calls,
+            finish_reason="stop" if data.get("done") else "length",
+            usage=usage,
+        )
+
+    async def stream(
+        self,
+        messages: Sequence[Message],
+        tools: Sequence[dict[str, Any]] | None = None,
+        temperature: float = 0.7,
+        max_tokens: int | None = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[StreamChunk]:
+        url = f"{self.base_url.rstrip('/')}/api/chat"
+        payload: dict[str, Any] = {
+            "model": self.model,
+            "messages": self._convert_messages(messages),
+            "stream": True,
+            "options": {"temperature": temperature},
+        }
+        if max_tokens:
+            payload["options"]["num_predict"] = max_tokens
+        if tools:
+            payload["tools"] = tools
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                async with client.stream("POST", url, json=payload) as response:
+                    await self._raise_for_status(response)
+                    call_index = 0
+                    async for line in response.aiter_lines():
+                        line = line.strip()
+                        if not line:
+                            continue
+                        try:
+                            data = json.loads(line)
+                        except json.JSONDecodeError:
+                            continue
+
+                        raw_msg = data.get("message", {})
+                        content_delta = raw_msg.get("content", "")
+                        done = bool(data.get("done"))
+
+                        # Ollama sends each tool call whole, so emit them all.
+                        for raw_tc in raw_msg.get("tool_calls") or []:
+                            fn = raw_tc.get("function", {})
+                            call_index += 1
+                            yield StreamChunk(
+                                tool_call_delta=ToolCall(
+                                    id=f"call_{call_index}_{fn.get('name', '')}",
+                                    name=fn.get("name", ""),
+                                    arguments=self._parse_arguments(fn.get("arguments", {})),
+                                )
+                            )
+
+                        if content_delta or done:
+                            yield StreamChunk(
+                                text_delta=content_delta,
+                                finish_reason="stop" if done else None,
+                                usage=self._usage_from(data) if done else None,
+                            )
+        except httpx.ConnectError as exc:
+            raise self._not_running(exc) from exc
+
+    async def embeddings(
+        self,
+        texts: list[str],
+        model: str | None = None,
+        **kwargs: Any,
+    ) -> list[list[float]]:
+        url = f"{self.base_url.rstrip('/')}/api/embed"
+        payload = {
+            "model": model or self.model,
+            "input": texts,
+        }
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                resp = await client.post(url, json=payload)
+                await self._raise_for_status(resp)
+                data = resp.json()
+        except httpx.ConnectError as exc:
+            raise self._not_running(exc) from exc
+        return data.get("embeddings", [])
+
+    def _not_running(self, exc: Exception) -> ConfigurationError:
+        """Ollama is local: a refused connection means it is not started."""
+        return ConfigurationError(
+            f"Cannot reach Ollama at {self.base_url} ({exc}). "
+            "Start it with 'ollama serve', or point FlowAI elsewhere with OLLAMA_BASE_URL."
+        )
+
+    @staticmethod
+    def _parse_arguments(args):
+        if isinstance(args, str):
+            try:
+                args = json.loads(args)
+            except json.JSONDecodeError:
+                return {"raw": args}
+        return args if isinstance(args, dict) else {"value": args}
+
+    @staticmethod
+    def _usage_from(data: dict[str, Any]) -> ProviderUsage:
+        prompt_eval = data.get("prompt_eval_count", 0)
+        eval_count = data.get("eval_count", 0)
+        return ProviderUsage(
+            prompt_tokens=prompt_eval,
+            completion_tokens=eval_count,
+            total_tokens=prompt_eval + eval_count,
+        )

flowai/providers/openai.py

@@ -0,0 +1,274 @@
+"""OpenAI and OpenRouter Provider implementations."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import AsyncIterator, Sequence
+from typing import Any
+
+import httpx
+
+from flowai.providers.base import (
+    BaseProvider,
+    Message,
+    ProviderResponse,
+    ProviderUsage,
+    StreamChunk,
+    ToolCall,
+)
+
+
+class OpenAIProvider(BaseProvider):
+    """Standard OpenAI Provider (GPT-4o, GPT-4o-mini, o1, etc.)."""
+
+    DEFAULT_BASE_URL = "https://api.openai.com/v1"
+    api_key_env = "OPENAI_API_KEY"
+
+    def __init__(
+        self,
+        model: str = "gpt-4o",
+        api_key: str | None = None,
+        base_url: str | None = None,
+        timeout: float = 60.0,
+        **kwargs: Any,
+    ):
+        resolved_key = api_key or os.getenv("OPENAI_API_KEY", "")
+        resolved_url = base_url or os.getenv("OPENAI_BASE_URL", self.DEFAULT_BASE_URL)
+        super().__init__(
+            model=model,
+            api_key=resolved_key,
+            base_url=resolved_url,
+            timeout=timeout,
+            **kwargs,
+        )
+
+    def _get_headers(self) -> dict[str, str]:
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+    def _convert_messages(self, messages: Sequence[Message]) -> list[dict[str, Any]]:
+        out = []
+        for m in messages:
+            msg: dict[str, Any] = {"role": m.role}
+            if m.content is not None:
+                msg["content"] = m.content
+            if m.tool_calls:
+                msg["tool_calls"] = [
+                    {
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {
+                            "name": tc.name,
+                            "arguments": json.dumps(tc.arguments),
+                        },
+                    }
+                    for tc in m.tool_calls
+                ]
+            if m.tool_call_id:
+                msg["tool_call_id"] = m.tool_call_id
+            if m.name:
+                msg["name"] = m.name
+            out.append(msg)
+        return out
+
+    async def generate(
+        self,
+        messages: Sequence[Message],
+        tools: Sequence[dict[str, Any]] | None = None,
+        temperature: float = 0.7,
+        max_tokens: int | None = None,
+        **kwargs: Any,
+    ) -> ProviderResponse:
+        url = f"{self.base_url.rstrip('/')}/chat/completions"
+        payload: dict[str, Any] = {
+            "model": self.model,
+            "messages": self._convert_messages(messages),
+            "temperature": temperature,
+        }
+        if max_tokens:
+            payload["max_tokens"] = max_tokens
+        if tools:
+            payload["tools"] = tools
+
+        self.require_api_key()
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            resp = await client.post(url, headers=self._get_headers(), json=payload)
+            await self._raise_for_status(resp)
+            data = resp.json()
+
+        choice = data["choices"][0]
+        raw_msg = choice.get("message", {})
+        content = raw_msg.get("content") or ""
+
+        tool_calls: list[ToolCall] = []
+        if raw_msg.get("tool_calls"):
+            for tc in raw_msg["tool_calls"]:
+                tool_calls.append(self.parse_tool_call(tc))
+
+        raw_usage = data.get("usage", {})
+        usage = ProviderUsage(
+            prompt_tokens=raw_usage.get("prompt_tokens", 0),
+            completion_tokens=raw_usage.get("completion_tokens", 0),
+            total_tokens=raw_usage.get("total_tokens", 0),
+        )
+
+        return ProviderResponse(
+            content=content,
+            tool_calls=tool_calls,
+            finish_reason=choice.get("finish_reason", "stop"),
+            usage=usage,
+        )
+
+    async def stream(
+        self,
+        messages: Sequence[Message],
+        tools: Sequence[dict[str, Any]] | None = None,
+        temperature: float = 0.7,
+        max_tokens: int | None = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[StreamChunk]:
+        url = f"{self.base_url.rstrip('/')}/chat/completions"
+        payload: dict[str, Any] = {
+            "model": self.model,
+            "messages": self._convert_messages(messages),
+            "temperature": temperature,
+            "stream": True,
+            "stream_options": {"include_usage": True},
+        }
+        if max_tokens:
+            payload["max_tokens"] = max_tokens
+        if tools:
+            payload["tools"] = tools
+
+        self.require_api_key()
+
+        # Tool calls arrive in fragments keyed by index: the name in one chunk,
+        # the arguments spread over many. They are assembled here and emitted
+        # once complete, so the agent always sees a whole call.
+        pending: dict[int, dict[str, str]] = {}
+
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            async with client.stream("POST", url, headers=self._get_headers(), json=payload) as response:
+                await self._raise_for_status(response)
+                async for line in response.aiter_lines():
+                    line = line.strip()
+                    if not line.startswith("data: "):
+                        continue
+                    data_str = line[6:]
+                    if data_str == "[DONE]":
+                        break
+                    try:
+                        chunk_dict = json.loads(data_str)
+                    except json.JSONDecodeError:
+                        continue
+
+                    usage = None
+                    if chunk_dict.get("usage"):
+                        raw = chunk_dict["usage"]
+                        usage = ProviderUsage(
+                            prompt_tokens=raw.get("prompt_tokens", 0),
+                            completion_tokens=raw.get("completion_tokens", 0),
+                            total_tokens=raw.get("total_tokens", 0),
+                        )
+
+                    choices = chunk_dict.get("choices") or []
+                    if not choices:
+                        if usage:
+                            yield StreamChunk(usage=usage)
+                        continue
+
+                    choice = choices[0]
+                    delta = choice.get("delta", {})
+                    finish_reason = choice.get("finish_reason")
+
+                    for raw_tc in delta.get("tool_calls") or []:
+                        index = raw_tc.get("index", 0)
+                        slot = pending.setdefault(index, {"id": "", "name": "", "arguments": ""})
+                        if raw_tc.get("id"):
+                            slot["id"] = raw_tc["id"]
+                        fn = raw_tc.get("function") or {}
+                        if fn.get("name"):
+                            slot["name"] = fn["name"]
+                        if fn.get("arguments"):
+                            slot["arguments"] += fn["arguments"]
+
+                    text_delta = delta.get("content") or ""
+                    if text_delta or usage:
+                        yield StreamChunk(text_delta=text_delta, usage=usage)
+
+                    if finish_reason:
+                        for slot in pending.values():
+                            yield StreamChunk(tool_call_delta=self._assemble_tool_call(slot))
+                        pending.clear()
+                        yield StreamChunk(finish_reason=finish_reason)
+
+        # A stream cut short before finish_reason still carries usable calls.
+        for slot in pending.values():
+            yield StreamChunk(tool_call_delta=self._assemble_tool_call(slot))
+
+    @staticmethod
+    def _assemble_tool_call(slot: dict[str, str]) -> ToolCall:
+        """Turn an accumulated streaming fragment into a complete ToolCall."""
+        raw_args = slot.get("arguments") or "{}"
+        try:
+            arguments = json.loads(raw_args) if raw_args.strip() else {}
+        except json.JSONDecodeError:
+            arguments = {"raw": raw_args}
+        if not isinstance(arguments, dict):
+            arguments = {"value": arguments}
+        return ToolCall(id=slot.get("id") or "", name=slot.get("name") or "", arguments=arguments)
+
+    async def embeddings(
+        self,
+        texts: list[str],
+        model: str | None = None,
+        **kwargs: Any,
+    ) -> list[list[float]]:
+        url = f"{self.base_url.rstrip('/')}/embeddings"
+        payload = {
+            "input": texts,
+            "model": model or "text-embedding-3-small",
+        }
+        self.require_api_key()
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            resp = await client.post(url, headers=self._get_headers(), json=payload)
+            await self._raise_for_status(resp)
+            data = resp.json()
+        return [item["embedding"] for item in data.get("data", [])]
+
+
+class OpenRouterProvider(OpenAIProvider):
+    """OpenRouter Provider for routing across hundreds of open/commercial models."""
+
+    DEFAULT_BASE_URL = "https://openrouter.ai/api/v1"
+    api_key_env = "OPENROUTER_API_KEY"
+
+    def __init__(
+        self,
+        model: str = "deepseek/deepseek-r1:free",
+        api_key: str | None = None,
+        base_url: str | None = None,
+        timeout: float = 60.0,
+        **kwargs: Any,
+    ):
+        resolved_key = api_key or os.getenv("OPENROUTER_API_KEY", "")
+        resolved_url = base_url or os.getenv("OPENROUTER_BASE_URL", self.DEFAULT_BASE_URL)
+        super().__init__(
+            model=model,
+            api_key=resolved_key,
+            base_url=resolved_url,
+            timeout=timeout,
+            **kwargs,
+        )
+
+    def _get_headers(self) -> dict[str, str]:
+        headers = super()._get_headers()
+        headers["HTTP-Referer"] = "https://github.com/Ajayramaswamy2005/FlowAI"
+        headers["X-Title"] = "FlowAI Agent Harness"
+        return headers

flowai/providers/registry.py

@@ -0,0 +1,50 @@
+"""Provider Registry and Dynamic Factory."""
+
+from __future__ import annotations
+
+from flowai.providers.anthropic import AnthropicProvider
+from flowai.providers.base import BaseProvider
+from flowai.providers.gemini import GeminiProvider
+from flowai.providers.nvidia import NvidiaProvider
+from flowai.providers.ollama import OllamaProvider
+from flowai.providers.openai import OpenAIProvider, OpenRouterProvider
+
+
+class ProviderRegistry:
+    """Registry maintaining active provider classes and factory instantiations."""
+
+    _registry: dict[str, type[BaseProvider]] = {
+        "nvidia": NvidiaProvider,
+        "ollama": OllamaProvider,
+        "openai": OpenAIProvider,
+        "anthropic": AnthropicProvider,
+        "gemini": GeminiProvider,
+        "openrouter": OpenRouterProvider,
+    }
+
+    @classmethod
+    def register(cls, name: str, provider_cls: type[BaseProvider]) -> None:
+        """Register a custom provider class."""
+        cls._registry[name.lower()] = provider_cls
+
+    @classmethod
+    def get(cls, name: str) -> type[BaseProvider]:
+        """Fetch provider class by name."""
+        provider_name = name.lower()
+        if provider_name not in cls._registry:
+            available = ", ".join(cls._registry.keys())
+            raise ValueError(f"Unknown provider '{name}'. Available providers: {available}")
+        return cls._registry[provider_name]
+
+    @classmethod
+    def create(cls, name: str, model: str, **kwargs) -> BaseProvider:
+        """Instantiate a provider by name."""
+        provider_cls = cls.get(name)
+        return provider_cls(model=model, **kwargs)
+
+
+def get_provider(provider_or_name: str | BaseProvider, model: str = "gpt-4o", **kwargs) -> BaseProvider:
+    """Convenience helper to resolve provider instance or name."""
+    if isinstance(provider_or_name, BaseProvider):
+        return provider_or_name
+    return ProviderRegistry.create(provider_or_name, model=model, **kwargs)

flowai/runtime/__init__.py

@@ -0,0 +1,5 @@
+"""FlowAI Runtime and Session Management."""
+
+from flowai.runtime.session import SessionStore
+
+__all__ = ["SessionStore"]

flowai/runtime/session.py

@@ -0,0 +1,76 @@
+"""Session management and persistent conversation storage on disk."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from flowai.providers.base import Message
+
+
+class SessionStore:
+    """Manages persistent conversation sessions on disk (stored in ~/.flowai/sessions/)."""
+
+    def __init__(self, storage_dir: Path | str | None = None):
+        if storage_dir is None:
+            self.storage_dir = Path.home() / ".flowai" / "sessions"
+        else:
+            self.storage_dir = Path(storage_dir)
+        self.storage_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_path(self, session_id: str) -> Path:
+        return self.storage_dir / f"{session_id}.json"
+
+    def save(self, session_id: str, messages: list[Message], metadata: dict[str, Any] | None = None) -> Path:
+        """Persist message history and metadata to disk."""
+        data = {
+            "session_id": session_id,
+            "metadata": metadata or {},
+            "messages": [m.model_dump() for m in messages],
+        }
+        path = self._get_path(session_id)
+        path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+        # Update a 'latest' pointer for instant resumption
+        latest_path = self.storage_dir / "latest.txt"
+        latest_path.write_text(session_id, encoding="utf-8")
+        return path
+
+    def load(self, session_id: str) -> list[Message]:
+        """Load messages from an existing disk session."""
+        path = self._get_path(session_id)
+        if not path.exists():
+            return []
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+            return [Message(**m) for m in raw.get("messages", [])]
+        except Exception:
+            return []
+
+    def get_latest_session_id(self) -> str | None:
+        """Retrieve ID of the most recent session."""
+        latest_path = self.storage_dir / "latest.txt"
+        if latest_path.exists():
+            sid = latest_path.read_text(encoding="utf-8").strip()
+            if self._get_path(sid).exists():
+                return sid
+        # Fallback to the newest json file in the directory
+        files = sorted(self.storage_dir.glob("*.json"), key=lambda f: f.stat().st_mtime, reverse=True)
+        return files[0].stem if files else None
+
+    def list_sessions(self) -> list[dict[str, Any]]:
+        """List all saved sessions with summary statistics."""
+        sessions = []
+        for p in self.storage_dir.glob("*.json"):
+            try:
+                data = json.loads(p.read_text(encoding="utf-8"))
+                sessions.append({
+                    "session_id": data.get("session_id", p.stem),
+                    "turns": len(data.get("messages", [])),
+                    "path": str(p),
+                    "modified": p.stat().st_mtime,
+                })
+            except Exception:
+                continue
+        return sorted(sessions, key=lambda s: s["modified"], reverse=True)

flowai/server/__init__.py

@@ -0,0 +1,5 @@
+"""FlowAI Server Package."""
+
+from flowai.server.app import create_app
+
+__all__ = ["create_app"]