coco-framework 0.1.0__py3-none-any.whl

coco/messages/__init__.py

@@ -0,0 +1,73 @@
+"""Message and message content types.
+
+Includes message types for different roles (e.g., human, AI, system), as well as types
+for message content blocks (e.g., text, image, audio) and tool calls.
+"""
+
+from coco_core.messages import (
+    AIMessage,
+    AIMessageChunk,
+    Annotation,
+    AnyMessage,
+    AudioContentBlock,
+    Citation,
+    ContentBlock,
+    DataContentBlock,
+    FileContentBlock,
+    HumanMessage,
+    ImageContentBlock,
+    InputTokenDetails,
+    InvalidToolCall,
+    MessageLikeRepresentation,
+    NonStandardAnnotation,
+    NonStandardContentBlock,
+    OutputTokenDetails,
+    PlainTextContentBlock,
+    ReasoningContentBlock,
+    RemoveMessage,
+    ServerToolCall,
+    ServerToolCallChunk,
+    ServerToolResult,
+    SystemMessage,
+    TextContentBlock,
+    ToolCall,
+    ToolCallChunk,
+    ToolMessage,
+    UsageMetadata,
+    VideoContentBlock,
+    trim_messages,
+)
+
+__all__ = [
+    "AIMessage",
+    "AIMessageChunk",
+    "Annotation",
+    "AnyMessage",
+    "AudioContentBlock",
+    "Citation",
+    "ContentBlock",
+    "DataContentBlock",
+    "FileContentBlock",
+    "HumanMessage",
+    "ImageContentBlock",
+    "InputTokenDetails",
+    "InvalidToolCall",
+    "MessageLikeRepresentation",
+    "NonStandardAnnotation",
+    "NonStandardContentBlock",
+    "OutputTokenDetails",
+    "PlainTextContentBlock",
+    "ReasoningContentBlock",
+    "RemoveMessage",
+    "ServerToolCall",
+    "ServerToolCallChunk",
+    "ServerToolResult",
+    "SystemMessage",
+    "TextContentBlock",
+    "ToolCall",
+    "ToolCallChunk",
+    "ToolMessage",
+    "UsageMetadata",
+    "VideoContentBlock",
+    "trim_messages",
+]

coco/rate_limiters/__init__.py

@@ -0,0 +1,13 @@
+"""Base abstraction and in-memory implementation of rate limiters.
+
+These rate limiters can be used to limit the rate of requests to an API.
+
+The rate limiters can be used together with `BaseChatModel`.
+"""
+
+from coco_core.rate_limiters import BaseRateLimiter, InMemoryRateLimiter
+
+__all__ = [
+    "BaseRateLimiter",
+    "InMemoryRateLimiter",
+]

coco/tools/__init__.py

@@ -0,0 +1,22 @@
+"""Tools."""
+
+from coco_core.tools import (
+    BaseTool,
+    InjectedToolArg,
+    InjectedToolCallId,
+    ToolException,
+    tool,
+)
+
+from coco.tools.tool_node import InjectedState, InjectedStore, ToolRuntime
+
+__all__ = [
+    "BaseTool",
+    "InjectedState",
+    "InjectedStore",
+    "InjectedToolArg",
+    "InjectedToolCallId",
+    "ToolException",
+    "ToolRuntime",
+    "tool",
+]

coco/tools/tool_node.py

@@ -0,0 +1,20 @@
+"""Utils file included for backwards compat imports."""
+
+from coco_graph.prebuilt import InjectedState, InjectedStore, ToolRuntime
+from coco_graph.prebuilt.tool_node import (
+    ToolCallRequest,
+    ToolCallWithContext,
+    ToolCallWrapper,
+)
+from coco_graph.prebuilt.tool_node import (
+    ToolNode as _ToolNode,  # noqa: F401
+)
+
+__all__ = [
+    "InjectedState",
+    "InjectedStore",
+    "ToolCallRequest",
+    "ToolCallWithContext",
+    "ToolCallWrapper",
+    "ToolRuntime",
+]

coco_anthropic/__init__.py

@@ -0,0 +1,15 @@
+"""Claude (Anthropic) partner package for Coco."""
+
+from coco_anthropic._version import __version__
+from coco_anthropic.chat_models import (
+    ChatAnthropic,
+    convert_to_anthropic_tool,
+)
+from coco_anthropic.llms import AnthropicLLM
+
+__all__ = [
+    "AnthropicLLM",
+    "ChatAnthropic",
+    "__version__",
+    "convert_to_anthropic_tool",
+]

coco_anthropic/_client_utils.py

@@ -0,0 +1,81 @@
+"""Helpers for creating Anthropic API clients.
+
+This module allows for the caching of httpx clients to avoid creating new instances
+for each instance of ChatAnthropic.
+
+Logic is largely replicated from anthropic._base_client.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from functools import lru_cache
+from typing import Any
+
+import anthropic
+
+_NOT_GIVEN: Any = object()
+
+
+class _SyncHttpxClientWrapper(anthropic.DefaultHttpxClient):
+    """Borrowed from anthropic._base_client."""
+
+    def __del__(self) -> None:
+        try:
+            if self.is_closed:
+                return
+            self.close()
+        except Exception:  # noqa: S110
+            pass
+
+
+class _AsyncHttpxClientWrapper(anthropic.DefaultAsyncHttpxClient):
+    """Borrowed from anthropic._base_client."""
+
+    def __del__(self) -> None:
+        try:
+            if self.is_closed:
+                return
+            # TODO(someday): support non asyncio runtimes here
+            asyncio.get_running_loop().create_task(self.aclose())
+        except Exception:  # noqa: S110
+            pass
+
+
+@lru_cache
+def _get_default_httpx_client(
+    *,
+    base_url: str | None,
+    timeout: Any = _NOT_GIVEN,
+    anthropic_proxy: str | None = None,
+) -> _SyncHttpxClientWrapper:
+    kwargs: dict[str, Any] = {
+        "base_url": base_url
+        or os.environ.get("ANTHROPIC_BASE_URL")
+        or "https://api.anthropic.com",
+    }
+    if timeout is not _NOT_GIVEN:
+        kwargs["timeout"] = timeout
+    if anthropic_proxy is not None:
+        kwargs["proxy"] = anthropic_proxy
+    return _SyncHttpxClientWrapper(**kwargs)
+
+
+@lru_cache
+def _get_default_async_httpx_client(
+    *,
+    base_url: str | None,
+    timeout: Any = _NOT_GIVEN,
+    anthropic_proxy: str | None = None,
+) -> _AsyncHttpxClientWrapper:
+    kwargs: dict[str, Any] = {
+        "base_url": base_url
+        or os.environ.get("ANTHROPIC_BASE_URL")
+        or "https://api.anthropic.com",
+    }
+    if timeout is not _NOT_GIVEN:
+        kwargs["timeout"] = timeout
+    if anthropic_proxy is not None:
+        kwargs["proxy"] = anthropic_proxy
+    return _AsyncHttpxClientWrapper(**kwargs)

coco_anthropic/_compat.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import json
+from typing import Any, cast
+
+from coco_core.messages import content as types
+
+
+def _unwrap_non_standard(block: dict) -> dict:
+    """Unwrap a provider-native dictionary from a standard content block."""
+    if block.get("type") == "non_standard" and isinstance(
+        value := block.get("value"),
+        dict,
+    ):
+        return value
+    return block
+
+
+def _convert_annotation_from_v1(annotation: types.Annotation) -> dict[str, Any]:
+    """Convert Coco annotation format to Anthropic's native citation format."""
+    if annotation["type"] == "non_standard_annotation":
+        return annotation["value"]
+
+    if annotation["type"] == "citation":
+        if "url" in annotation:
+            # web_search_result_location
+            out: dict[str, Any] = {}
+            if cited_text := annotation.get("cited_text"):
+                out["cited_text"] = cited_text
+            if "encrypted_index" in annotation.get("extras", {}):
+                out["encrypted_index"] = annotation.get("extras", {})["encrypted_index"]
+            if "title" in annotation:
+                out["title"] = annotation["title"]
+            out["type"] = "web_search_result_location"
+            out["url"] = annotation.get("url")
+
+            for key, value in annotation.get("extras", {}).items():
+                if key not in out:
+                    out[key] = value
+
+            return out
+
+        if "start_char_index" in annotation.get("extras", {}):
+            # char_location
+            out = {"type": "char_location"}
+            for field in ["cited_text"]:
+                if value := annotation.get(field):
+                    out[field] = value
+            if title := annotation.get("title"):
+                out["document_title"] = title
+
+            for key, value in annotation.get("extras", {}).items():
+                out[key] = value
+            out = {k: out[k] for k in sorted(out)}
+
+            return out
+
+        if "search_result_index" in annotation.get("extras", {}):
+            # search_result_location
+            out = {"type": "search_result_location"}
+            for field in ["cited_text", "title"]:
+                if value := annotation.get(field):
+                    out[field] = value
+
+            for key, value in annotation.get("extras", {}).items():
+                out[key] = value
+
+            return out
+
+        if "start_block_index" in annotation.get("extras", {}):
+            # content_block_location
+            out = {}
+            if cited_text := annotation.get("cited_text"):
+                out["cited_text"] = cited_text
+            if "document_index" in annotation.get("extras", {}):
+                out["document_index"] = annotation.get("extras", {})["document_index"]
+            if "title" in annotation:
+                out["document_title"] = annotation["title"]
+
+            for key, value in annotation.get("extras", {}).items():
+                if key not in out:
+                    out[key] = value
+
+            out["type"] = "content_block_location"
+            return out
+
+        if "start_page_number" in annotation.get("extras", {}):
+            # page_location
+            out = {"type": "page_location"}
+            for field in ["cited_text"]:
+                if value := annotation.get(field):
+                    out[field] = value
+            if title := annotation.get("title"):
+                out["document_title"] = title
+
+            for key, value in annotation.get("extras", {}).items():
+                out[key] = value
+
+            return out
+
+        return cast(dict[str, Any], annotation)
+
+    return cast(dict[str, Any], annotation)
+
+
+def _convert_from_v1_to_anthropic(
+    content: list[types.ContentBlock],
+    tool_calls: list[types.ToolCall],
+    model_provider: str | None,
+) -> list[dict[str, Any]]:
+    new_content: list = []
+    for block in content:
+        if block["type"] == "text":
+            if model_provider == "anthropic" and "annotations" in block:
+                new_block: dict[str, Any] = {"type": "text"}
+                new_block["citations"] = [
+                    _convert_annotation_from_v1(a) for a in block["annotations"]
+                ]
+                if "text" in block:
+                    new_block["text"] = block["text"]
+            else:
+                new_block = {"text": block.get("text", ""), "type": "text"}
+            new_content.append(new_block)
+
+        elif block["type"] == "tool_call":
+            tool_use_block = {
+                "type": "tool_use",
+                "name": block.get("name", ""),
+                "input": block.get("args", {}),
+                "id": block.get("id", ""),
+            }
+            if "caller" in block.get("extras", {}):
+                tool_use_block["caller"] = block["extras"]["caller"]
+            new_content.append(tool_use_block)
+
+        elif block["type"] == "tool_call_chunk":
+            if isinstance(block["args"], str):
+                try:
+                    input_ = json.loads(block["args"] or "{}")
+                except json.JSONDecodeError:
+                    input_ = {}
+            else:
+                input_ = block.get("args") or {}
+            new_content.append(
+                {
+                    "type": "tool_use",
+                    "name": block.get("name", ""),
+                    "input": input_,
+                    "id": block.get("id", ""),
+                }
+            )
+
+        elif block["type"] == "invalid_tool_call":
+            tool_call_id = block.get("id")
+            tool_name = block.get("name")
+            if (
+                model_provider == "anthropic"
+                and isinstance(tool_call_id, str)
+                and tool_call_id
+                and isinstance(tool_name, str)
+                and tool_name
+            ):
+                new_content.append(
+                    {
+                        "type": "tool_use",
+                        "name": tool_name,
+                        "input": {},
+                        "id": tool_call_id,
+                    }
+                )
+
+        elif block["type"] == "reasoning" and model_provider == "anthropic":
+            new_block = {}
+            if "reasoning" in block:
+                new_block["thinking"] = block["reasoning"]
+            new_block["type"] = "thinking"
+            if signature := block.get("extras", {}).get("signature"):
+                new_block["signature"] = signature
+
+            new_content.append(new_block)
+
+        elif block["type"] == "server_tool_call" and model_provider == "anthropic":
+            new_block = {}
+            if "id" in block:
+                new_block["id"] = block["id"]
+            new_block["input"] = block.get("args", {})
+            if partial_json := block.get("extras", {}).get("partial_json"):
+                new_block["input"] = {}
+                new_block["partial_json"] = partial_json
+            else:
+                pass
+            if block.get("name") == "code_interpreter":
+                new_block["name"] = "code_execution"
+            elif block.get("name") == "remote_mcp":
+                if "tool_name" in block.get("extras", {}):
+                    new_block["name"] = block["extras"]["tool_name"]
+                if "server_name" in block.get("extras", {}):
+                    new_block["server_name"] = block["extras"]["server_name"]
+            else:
+                new_block["name"] = block.get("name", "")
+            if block.get("name") == "remote_mcp":
+                new_block["type"] = "mcp_tool_use"
+            else:
+                new_block["type"] = "server_tool_use"
+            new_content.append(new_block)
+
+        elif block["type"] == "server_tool_result" and model_provider == "anthropic":
+            new_block = {}
+            if "output" in block:
+                new_block["content"] = block["output"]
+            server_tool_result_type = block.get("extras", {}).get("block_type", "")
+            if server_tool_result_type == "mcp_tool_result":
+                new_block["is_error"] = block.get("status") == "error"
+            if "tool_call_id" in block:
+                new_block["tool_use_id"] = block["tool_call_id"]
+            new_block["type"] = server_tool_result_type
+            new_content.append(new_block)
+
+        elif (
+            block["type"] == "non_standard"
+            and "value" in block
+            and model_provider == "anthropic"
+        ):
+            new_content.append(block["value"])
+        else:
+            new_content.append(block)
+
+    return new_content

coco_anthropic/_sdk_compat.py

@@ -0,0 +1,124 @@
+"""Adapt to the installed `anthropic` SDK major version.
+
+`trustcoco-anthropic` supports `anthropic` 0.x and 1.x. Two differences between
+them reach this package, and each is resolved here by reading the answer off the
+installed SDK rather than off its version string:
+
+- **Sampling parameters.** `anthropic>=1` dropped `temperature`, `top_p` and
+  `top_k` from its message-creation methods, since current models do not use
+  them. The API still honors them for older models, so they are relocated to
+  `extra_body`, which the SDK merges into the request JSON as-is. The wire
+  payload is identical on both majors.
+
+- **Raw responses.** `.with_raw_response` on the async client returns
+  `AsyncAPIResponse`, whose `parse()` is a coroutine; `anthropic<1` returned
+  `LegacyAPIResponse` with a synchronous `parse()`.
+
+`anthropic>=1` also moved its HTTP layer from `httpx` to
+[`httpx2`](https://github.com/pydantic/httpx2), but that does not surface here:
+this package hands the SDK only primitives (a `base_url` string, a float
+`timeout`, a `proxy` URL string) and subclasses `anthropic.DefaultHttpxClient`,
+which already points at the right library, so no `httpx` type crosses the
+boundary. Only the unit tests inject `httpx` objects, and they resolve the
+matching library themselves in `tests/unit_tests/_httpx_compat.py`.
+"""
+
+from __future__ import annotations
+
+import inspect
+import logging
+import re
+from collections.abc import Mapping
+from functools import lru_cache
+from typing import Any
+
+import anthropic
+
+logger = logging.getLogger(__name__)
+
+# Sampling parameters `anthropic>=1` no longer accepts as named arguments.
+_SAMPLING_PARAMS = ("temperature", "top_p", "top_k")
+
+
+def _sdk_major_version() -> int | None:
+    """Major version of the installed `anthropic` SDK, or `None` if unreadable.
+
+    Tolerates tag-derived strings such as `v1.0.0`, which build tooling
+    sometimes leaves unstripped, by reading the first integer run.
+    """
+    match = re.match(r"\D*(\d+)", str(getattr(anthropic, "__version__", "")))
+    return int(match.group(1)) if match else None
+
+
+@lru_cache(maxsize=1)
+def _unsupported_sampling_params() -> frozenset[str]:
+    """Sampling parameters the installed SDK's message methods no longer accept.
+
+    Derived from the signature of `Messages.create`, which `beta.messages` and
+    the async resources track. No client is instantiated, so this is safe to
+    call during payload construction without resolved credentials.
+    """
+    try:
+        from anthropic.resources.messages import Messages
+
+        accepted = inspect.signature(Messages.create).parameters
+    except (ImportError, AttributeError, TypeError, ValueError):
+        # The SDK moved the resource or the signature is unreadable. Guess from
+        # the major version rather than failing: a wrong guess costs a TypeError
+        # on the first request, an exception here breaks every import.
+        major = _sdk_major_version()
+        logger.warning(
+            "Could not introspect the anthropic SDK's `Messages.create` "
+            "signature; falling back to its major version (%r) to decide "
+            "whether `temperature`/`top_p`/`top_k` are still accepted.",
+            major,
+        )
+        if major is not None and major >= 1:
+            return frozenset(_SAMPLING_PARAMS)
+        return frozenset()
+
+    return frozenset(p for p in _SAMPLING_PARAMS if p not in accepted)
+
+
+def _route_unsupported_sampling_params(payload: dict[str, Any]) -> dict[str, Any]:
+    """Move sampling params the installed SDK rejects into `extra_body`.
+
+    A no-op on `anthropic<1`, where the message methods still accept them as
+    named arguments. Values the caller already set in `extra_body` win, since
+    that is the SDK's documented escape hatch and a deliberate choice.
+
+    Args:
+        payload: Request payload, modified in place.
+
+    Returns:
+        The same payload.
+    """
+    unsupported = _unsupported_sampling_params()
+    if not unsupported:
+        return payload
+
+    extra_body = payload.get("extra_body")
+    if extra_body is not None and not isinstance(extra_body, Mapping):
+        # A value the SDK would reject anyway. Leave the payload untouched
+        # rather than relocating params into something that cannot hold them.
+        return payload
+
+    relocated = {k: payload.pop(k) for k in unsupported if k in payload}
+    if not relocated:
+        return payload
+
+    payload["extra_body"] = {**relocated, **(extra_body or {})}
+    return payload
+
+
+async def _aparse(raw_response: Any) -> Any:
+    """Parse a raw SDK response from the async client.
+
+    `anthropic>=1` returns `AsyncAPIResponse`, whose `parse()` is a coroutine;
+    `anthropic<1` returned `LegacyAPIResponse`, whose `parse()` was
+    synchronous.
+    """
+    parsed = raw_response.parse()
+    if inspect.isawaitable(parsed):
+        return await parsed
+    return parsed

coco_anthropic/_version.py

@@ -0,0 +1,3 @@
+"""Version information for `trustcoco-anthropic`."""
+
+__version__ = "1.7.4"