monkeybot 2.1.1__py3-none-any.whl

monkeybot/providers/ollama.py

@@ -0,0 +1,152 @@
+"""Ollama provider via the OpenAI-compatible Chat Completions API.
+
+Runs against a local (or remote) Ollama server — no API key required. Ollama
+exposes an OpenAI-compatible endpoint at ``/v1`` on top of its native API, so
+this adapter reuses the same request/response plumbing as ``OpenAIProvider``
+and ``HuggingFaceProvider``.
+
+Configuration (environment variables or ``monkeybot.yaml``):
+
+- ``OLLAMA_BASE_URL`` — OpenAI-compat base host (default: ``http://localhost:11434``;
+  ``/v1`` is appended when missing)
+- ``OLLAMA_API_KEY`` — optional; Ollama ignores the value but the OpenAI SDK
+  requires a non-empty string. Set this only if a reverse proxy enforces auth.
+- ``MODEL_NAME`` — model id passed to the API (e.g. ``llama3.1``, ``qwen2.5``).
+  Must already be pulled on the Ollama server (``ollama pull <model>``).
+- ``MODEL_TEMPERATURE`` — sampling temperature (default: ``0.7``; set via ``monkeybot.yaml`` / constructor)
+- ``MODEL_MAX_TOKENS`` — max output tokens (default: ``60000``; set via ``monkeybot.yaml`` / constructor)
+- ``MODEL_THINKING_BUDGET`` — thinking control for reasoning models (e.g. Gemma 4):
+  ``-1`` = Ollama default (thinking on when supported), ``0`` = off via
+  ``reasoning_effort: none``, ``N > 0`` = on (no token budget on Ollama).
+
+Install the required extra::
+
+    uv sync --extra ollama
+    # or: pip install "monkeybot[ollama]"
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import AsyncIterator, Sequence
+
+from monkeybot.core.llm.provider import (
+    Message,
+    ProviderEvent,
+)
+from monkeybot.core.types.types_tools import ToolDef
+from monkeybot.providers._openai_compat import (
+    count_input_tokens_tiktoken,
+    stream_chat_completions_with_tool_fallback,
+)
+from monkeybot.providers.sampling import resolve_model_sampling
+
+_DEFAULT_BASE_URL = "http://localhost:11434"
+_DUMMY_API_KEY = "ollama"
+
+
+def reasoning_effort_for_thinking_budget(budget: int) -> str | None:
+    """Map monkeybot ``thinking_budget`` to Ollama OpenAI-compat ``reasoning_effort``.
+
+    Returns ``None`` when the field should be omitted (server default).
+    """
+    if budget == 0:
+        return "none"
+    return None
+
+
+def _resolve_thinking_budget(
+    configured: int | None,
+    *,
+    override: int | None,
+) -> int:
+    if override is not None:
+        return override
+    if configured is not None:
+        return configured
+    return int(os.environ.get("MODEL_THINKING_BUDGET", "-1"))
+
+
+class OllamaProvider:
+    """Local (or self-hosted) models via Ollama's OpenAI-compatible endpoint.
+
+    Requires ``monkeybot[ollama]`` (``openai`` + ``tiktoken``) and a reachable
+    Ollama server with the configured model already pulled. No API key is
+    required by default.
+    """
+
+    @property
+    def name(self) -> str:
+        return "ollama"
+
+    @property
+    def supports_streaming(self) -> bool:
+        return True
+
+    def __init__(
+        self,
+        *,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        thinking_budget: int | None = None,
+    ) -> None:
+        self._base_url = (os.environ.get("OLLAMA_BASE_URL") or _DEFAULT_BASE_URL).rstrip("/")
+        self._api_key = os.environ.get("OLLAMA_API_KEY") or _DUMMY_API_KEY
+        sampling = resolve_model_sampling(temperature=temperature, max_tokens=max_tokens)
+        self._temperature = sampling.temperature
+        self._max_tokens = sampling.max_tokens
+        self._thinking_budget = (
+            thinking_budget
+            if thinking_budget is not None
+            else int(os.environ.get("MODEL_THINKING_BUDGET", "-1"))
+        )
+
+    def _resolve_base_url(self, model: str) -> str:
+        """Return the OpenAI-compat base URL for ``model``.
+
+        ``OLLAMA_BASE_URL`` is used as-is when it already ends in ``/v1``;
+        otherwise ``/v1`` is appended. Defaults to a local Ollama server.
+        """
+        del model  # model id is passed per request; base URL is env-driven
+        host = self._base_url
+        if host.endswith("/v1"):
+            return host
+        return f"{host}/v1"
+
+    async def count_input_tokens(
+        self,
+        messages: Sequence[Message],
+        tools: Sequence[ToolDef],
+        *,
+        model: str,
+        thinking_budget: int | None = None,
+    ) -> int:
+        return await count_input_tokens_tiktoken(
+            messages, tools, model=model, thinking_budget=thinking_budget
+        )
+
+    async def stream(
+        self,
+        messages: Sequence[Message],
+        tools: Sequence[ToolDef],
+        *,
+        model: str,
+        thinking_budget: int | None = None,
+    ) -> AsyncIterator[ProviderEvent]:
+        budget = _resolve_thinking_budget(self._thinking_budget, override=thinking_budget)
+        reasoning_effort = reasoning_effort_for_thinking_budget(budget)
+        effort_kw = (
+            {"reasoning_effort": reasoning_effort} if reasoning_effort is not None else {}
+        )
+        async for event in stream_chat_completions_with_tool_fallback(
+            base_url=self._resolve_base_url(model),
+            api_key=self._api_key,
+            provider="ollama",
+            messages=messages,
+            tools=tools,
+            model=model,
+            temperature=self._temperature,
+            max_tokens=self._max_tokens,
+            **effort_kw,
+        ):
+            yield event

monkeybot/providers/openai.py

@@ -0,0 +1,127 @@
+"""OpenAI Chat Completions provider (direct ``openai`` SDK, async streaming)."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import AsyncIterator, Sequence
+from typing import Any
+
+from monkeybot.core.llm.provider import (
+    Message,
+    ProviderCallHints,
+    ProviderEvent,
+)
+from monkeybot.core.types.types_tools import ToolDef
+from monkeybot.providers._openai_compat import (
+    count_openai_compat_input_tokens,
+    iter_openai_compat_stream,
+    messages_to_openai,
+    openai_messages_token_count,
+    openai_tools,
+    openai_tools_token_count,
+)
+from monkeybot.providers.sampling import resolve_model_sampling
+
+# Re-export private names that existing tests import directly from this module.
+_messages_to_openai = messages_to_openai
+_openai_tools = openai_tools
+_openai_messages_token_count = openai_messages_token_count
+_openai_tools_token_count = openai_tools_token_count
+
+__all__ = [
+    "OpenAIProvider",
+    # legacy private names kept for tests
+    "_messages_to_openai",
+    "_openai_tools",
+    "_openai_messages_token_count",
+    "_openai_tools_token_count",
+]
+
+
+class OpenAIProvider:
+    """OpenAI chat models using the official ``openai`` async client."""
+
+    @property
+    def name(self) -> str:
+        return "openai"
+
+    @property
+    def supports_streaming(self) -> bool:
+        return True
+
+    def __init__(
+        self,
+        *,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+    ) -> None:
+        if not os.environ.get("OPENAI_API_KEY"):
+            raise ValueError("OPENAI_API_KEY is not set")
+        sampling = resolve_model_sampling(temperature=temperature, max_tokens=max_tokens)
+        self._temperature = sampling.temperature
+        self._max_tokens = sampling.max_tokens
+
+    async def count_input_tokens(
+        self,
+        messages: Sequence[Message],
+        tools: Sequence[ToolDef],
+        *,
+        model: str,
+        thinking_budget: int | None = None,
+        hints: ProviderCallHints | None = None,
+    ) -> int:
+        del thinking_budget, hints
+        import tiktoken  # noqa: PLC0415
+
+        msgs = list(messages)
+        try:
+            enc = tiktoken.encoding_for_model(model)
+        except KeyError:
+            enc = tiktoken.get_encoding("cl100k_base")
+        return count_openai_compat_input_tokens(enc, msgs, tools)
+
+    async def stream(
+        self,
+        messages: Sequence[Message],
+        tools: Sequence[ToolDef],
+        *,
+        model: str,
+        thinking_budget: int | None = None,
+        hints: ProviderCallHints | None = None,
+    ) -> AsyncIterator[ProviderEvent]:
+        del thinking_budget
+        from openai import AsyncOpenAI  # noqa: PLC0415
+
+        msgs = list(messages)
+
+        system, oai_messages = messages_to_openai(msgs)
+        if system:
+            oai_messages = [{"role": "system", "content": system}, *oai_messages]
+
+        retention = hints.cache_retention if hints is not None else "short"
+        session_id = hints.session_id if hints is not None else None
+        client_kwargs: dict[str, Any] = {}
+        if session_id and retention != "none":
+            client_kwargs["default_headers"] = {"x-session-affinity": session_id}
+        client = AsyncOpenAI(**client_kwargs)
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": oai_messages,
+            "stream": True,
+            "temperature": self._temperature,
+            "max_tokens": self._max_tokens,
+        }
+        if tools:
+            kwargs["tools"] = openai_tools(tools)
+            kwargs["parallel_" + "tool" + "_calls"] = True
+        if retention == "long":
+            kwargs["prompt_cache_retention"] = "24h"
+
+        async for event in iter_openai_compat_stream(
+            client,
+            kwargs,
+            provider="openai",
+            n_messages=len(messages),
+            n_tools=len(tools),
+        ):
+            yield event

monkeybot/providers/pricing.py

@@ -0,0 +1,60 @@
+"""Model pricing lookup and cost estimation."""
+
+from __future__ import annotations
+
+import logging
+
+_log = logging.getLogger(__name__)
+
+# USD per 1M tokens: (input, output, cache_write, cache_read)
+# TODO: add Bedrock model entries — aws_bedrock users get cost_usd 0.0 until then.
+# Gemini-on-Vertex uses the same gemini-* keys when the model id matches.
+MODEL_PRICING: dict[str, tuple[float, float, float, float]] = {
+    "claude-sonnet-4": (3.00, 15.00, 3.75, 0.30),
+    "claude-haiku-4-5": (1.00, 5.00, 1.25, 0.10),
+    "gpt-5": (1.25, 10.00, 0.00, 0.125),
+    "gemini-2.5-flash": (0.30, 2.50, 0.00, 0.075),
+    "gemini-3-flash-preview": (0.30, 2.50, 0.00, 0.075),
+}
+
+__all__ = ["MODEL_PRICING", "estimate_cost", "pricing_for"]
+
+
+def pricing_for(model: str) -> tuple[float, float, float, float]:
+    """Return (input, output, cache_write, cache_read) $/M for ``model``.
+
+    Exact match first, then longest known-prefix match, else zeros.
+    Never raises on unknown models.
+    """
+    exact = MODEL_PRICING.get(model)
+    if exact is not None:
+        return exact
+
+    best_key: str | None = None
+    for key in MODEL_PRICING:
+        if model.startswith(key) and (best_key is None or len(key) > len(best_key)):
+            best_key = key
+
+    if best_key is not None:
+        return MODEL_PRICING[best_key]
+
+    _log.warning("unknown model for pricing lookup: %s", model)
+    return (0.0, 0.0, 0.0, 0.0)
+
+
+def estimate_cost(
+    model: str,
+    input_tokens: int,
+    output_tokens: int,
+    *,
+    cache_read_tokens: int = 0,
+    cache_creation_tokens: int = 0,
+) -> float:
+    """Return estimated USD cost using :func:`pricing_for`. Unknown model → 0.0."""
+    rin, rout, rcw, rcr = pricing_for(model)
+    return (
+        input_tokens * rin
+        + output_tokens * rout
+        + cache_creation_tokens * rcw
+        + cache_read_tokens * rcr
+    ) / 1_000_000

monkeybot/providers/sampling.py

@@ -0,0 +1,44 @@
+"""Unified model sampling parameters (temperature, max output tokens).
+
+All providers resolve sampling once at construction via :func:`resolve_model_sampling`.
+:func:`~monkeybot.core.config.settings.get_provider_config` is the primary entry point;
+direct provider construction falls back to ``MODEL_TEMPERATURE`` / ``MODEL_MAX_TOKENS``.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+DEFAULT_MODEL_TEMPERATURE = 0.7
+DEFAULT_MODEL_MAX_TOKENS = 60_000
+
+
+@dataclass(frozen=True, slots=True)
+class ModelSamplingConfig:
+    """Resolved sampling knobs for a single provider instance."""
+
+    temperature: float
+    max_tokens: int
+
+
+def resolve_model_sampling(
+    *,
+    temperature: float | None = None,
+    max_tokens: int | None = None,
+) -> ModelSamplingConfig:
+    """Resolve temperature and max output tokens from explicit args or environment."""
+    resolved_temperature = (
+        float(temperature)
+        if temperature is not None
+        else float(os.getenv("MODEL_TEMPERATURE", str(DEFAULT_MODEL_TEMPERATURE)))
+    )
+    resolved_max_tokens = (
+        int(max_tokens)
+        if max_tokens is not None
+        else int(os.getenv("MODEL_MAX_TOKENS", str(DEFAULT_MODEL_MAX_TOKENS)))
+    )
+    return ModelSamplingConfig(
+        temperature=resolved_temperature,
+        max_tokens=resolved_max_tokens,
+    )

monkeybot/providers/vertex_claude.py

@@ -0,0 +1,148 @@
+"""Anthropic Claude on Vertex AI (ADC)."""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import AsyncIterator, Sequence
+from typing import Any, cast
+
+from monkeybot.core.llm.provider import Message, ProviderCallHints, ProviderEvent
+from monkeybot.core.logging_utils import kv
+from monkeybot.core.types.types_tools import ToolDef
+from monkeybot.providers._utils import (
+    anthropic_tool_defs,
+    build_anthropic_messages,
+    build_cached_system_blocks,
+    count_anthropic_input_tokens,
+    estimate_anthropic_input_tokens,
+    iter_anthropic_sdk_stream,
+    mark_last_tool_cached,
+    split_leading_system,
+)
+from monkeybot.providers.sampling import resolve_model_sampling
+
+_log = logging.getLogger(__name__)
+
+
+class VertexClaudeProvider:
+    """Claude on Vertex AI — ADC, no ``ANTHROPIC_API_KEY``."""
+
+    @property
+    def name(self) -> str:
+        return "vertex-claude"
+
+    @property
+    def supports_streaming(self) -> bool:
+        return True
+
+    def __init__(
+        self,
+        *,
+        project_id: str | None = None,
+        region: str | None = None,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+    ) -> None:
+        self._project_id = (
+            (project_id or "").strip()
+            or os.environ.get("ANTHROPIC_VERTEX_PROJECT_ID", "").strip()
+        )
+        self._region = (
+            (region or "").strip()
+            or os.environ.get("ANTHROPIC_VERTEX_REGION", "").strip()
+            or "global"
+        )
+        if not self._project_id:
+            raise ValueError("ANTHROPIC_VERTEX_PROJECT_ID is not set (or pass project_id=)")
+        sampling = resolve_model_sampling(temperature=temperature, max_tokens=max_tokens)
+        self._temperature = sampling.temperature
+        self._max_tokens = sampling.max_tokens
+
+    async def count_input_tokens(
+        self,
+        messages: Sequence[Message],
+        tools: Sequence[ToolDef],
+        *,
+        model: str,
+        thinking_budget: int | None = None,
+        hints: ProviderCallHints | None = None,
+    ) -> int:
+        del thinking_budget, hints
+        import anthropic  # noqa: PLC0415
+        from anthropic import AsyncAnthropicVertex  # noqa: PLC0415
+
+        system, msgs = split_leading_system(messages)
+        converted_messages = build_anthropic_messages(msgs)
+        client = AsyncAnthropicVertex(project_id=self._project_id, region=self._region)
+        converted_tools = anthropic_tool_defs(tools) if tools else None
+        try:
+            return await count_anthropic_input_tokens(
+                client,
+                anthropic_module=anthropic,
+                model=model,
+                system=system,
+                messages=cast(Any, converted_messages),
+                tools=cast(Any, converted_tools),
+            )
+        except Exception as exc:
+            msg = str(exc).lower()
+            if "token counting" in msg or "not supported" in msg:
+                _log.warning(
+                    "Vertex Claude count_tokens unavailable, using estimate %s",
+                    kv(provider="vertex_claude", model=model),
+                    exc_info=True,
+                )
+                return estimate_anthropic_input_tokens(
+                    system=system,
+                    messages=converted_messages,
+                    tools=converted_tools,
+                )
+            raise
+
+    async def stream(
+        self,
+        messages: Sequence[Message],
+        tools: Sequence[ToolDef],
+        *,
+        model: str,
+        thinking_budget: int | None = None,
+        hints: ProviderCallHints | None = None,
+    ) -> AsyncIterator[ProviderEvent]:
+        del thinking_budget
+        import anthropic  # noqa: PLC0415
+        from anthropic import AsyncAnthropicVertex  # noqa: PLC0415
+
+        retention = hints.cache_retention if hints is not None else "short"
+        system, msgs = split_leading_system(messages)
+        converted_messages = build_anthropic_messages(msgs)
+        client = AsyncAnthropicVertex(project_id=self._project_id, region=self._region)
+        converted = anthropic_tool_defs(tools) if tools else None
+        system_param: Any = (
+            build_cached_system_blocks(system, cache_retention=retention)
+            if system
+            else anthropic.NOT_GIVEN
+        )
+        tools_param: Any = (
+            mark_last_tool_cached(converted, cache_retention=retention)
+            if converted
+            else anthropic.NOT_GIVEN
+        )
+
+        stream_kwargs: dict[str, Any] = {
+            "model": model,
+            "system": system_param,
+            "messages": cast(Any, converted_messages),
+            "tools": tools_param,
+            "max_tokens": self._max_tokens,
+            "temperature": self._temperature,
+        }
+        async for event in iter_anthropic_sdk_stream(
+            client,
+            stream_kwargs,
+            provider="vertex_claude",
+            error_message="Vertex Claude stream error: %s",
+            n_messages=len(messages),
+            n_tools=len(tools),
+        ):
+            yield event

monkeybot/scaffold/__init__.py

@@ -0,0 +1,33 @@
+"""Compatibility shim — scaffolding lives in ``monkeybot_cli.scaffold``.
+
+Docker images and older imports still use ``monkeybot.scaffold.run_new``. Prefer
+``from monkeybot_cli.scaffold import run_new`` in new code.
+"""
+
+from __future__ import annotations
+
+try:
+    from monkeybot_cli.scaffold import (  # noqa: F401
+        ensure_memory,
+        ensure_workspace,
+        install_config_bundle,
+        install_env_example,
+        install_setup_script,
+        run_new,
+        write_active_config,
+    )
+except ImportError as exc:  # pragma: no cover - clearer error when CLI not installed
+    raise ImportError(
+        "Scaffolding moved to the monkeybot-cli package. "
+        "Install monkeybot-cli (e.g. `uv tool install monkeybot-cli` or `pip install ./cli`)."
+    ) from exc
+
+__all__ = [
+    "ensure_memory",
+    "ensure_workspace",
+    "install_config_bundle",
+    "install_env_example",
+    "install_setup_script",
+    "run_new",
+    "write_active_config",
+]

monkeybot/scheduler/__init__.py

@@ -0,0 +1,13 @@
+"""Scheduled-loop worker package."""
+
+from monkeybot.scheduler.engine import (
+    scheduler_enabled_from_env,
+    scheduler_settings,
+    start_scheduler_background,
+)
+
+__all__ = [
+    "scheduler_enabled_from_env",
+    "scheduler_settings",
+    "start_scheduler_background",
+]

monkeybot/scheduler/__main__.py

@@ -0,0 +1,4 @@
+from monkeybot.scheduler.worker import main
+
+if __name__ == "__main__":
+    main()