calfkit 0.2.2__tar.gz → 0.2.4__tar.gz

{calfkit-0.2.2 → calfkit-0.2.4}/.github/workflows/test.yml

@@ -57,7 +57,7 @@ jobs:
 
       - name: Upload coverage to Codecov
         if: matrix.python-version == '3.10'
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v6
         with:
           files: ./coverage.xml
           fail_ci_if_error: true

calfkit-0.2.4/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.2.4"
+}

{calfkit-0.2.2 → calfkit-0.2.4}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.2.4](https://github.com/calf-ai/calfkit-sdk/compare/v0.2.3...v0.2.4) (2026-04-08)
+
+
+### Features
+
+* add OpenAI Responses API support  ([#119](https://github.com/calf-ai/calfkit-sdk/issues/119)) ([fa1c1a7](https://github.com/calf-ai/calfkit-sdk/commit/fa1c1a7336014a1da3a40de0a1651fdeee722fe4))
+
+## [0.2.3](https://github.com/calf-ai/calfkit-sdk/compare/v0.2.2...v0.2.3) (2026-04-02)
+
+
+### Bug Fixes
+
+* update vendored anthropic imports and add AnthropicModelClient ([#116](https://github.com/calf-ai/calfkit-sdk/issues/116)) ([06c3cc3](https://github.com/calf-ai/calfkit-sdk/commit/06c3cc3749ee9c620ddb91a4bc3dc7d7564842fb))
+
 ## [0.2.2](https://github.com/calf-ai/calfkit-sdk/compare/v0.2.1...v0.2.2) (2026-04-01)
 
 

{calfkit-0.2.2 → calfkit-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calfkit
-Version: 0.2.2
+Version: 0.2.4
 Summary: Build AI workflows and agents as fully-distributed and event-driven microservices.
 Project-URL: Homepage, https://github.com/calf-ai/calf-sdk
 Project-URL: Repository, https://github.com/calf-ai/calf-sdk
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
-Requires-Dist: anthropic>=0.20.0
+Requires-Dist: anthropic>=0.80.0
 Requires-Dist: dishka>=1.9.1
 Requires-Dist: exceptiongroup>=1.2.2; python_version < '3.11'
 Requires-Dist: faststream[kafka]>=0.6.6
@@ -173,7 +173,7 @@ Deploy the agent as its own service. The `Agent` handles LLM chat, tool orchestr
 # agent_service.py
 import asyncio
 from calfkit.nodes import Agent
-from calfkit.providers import OpenAIModelClient
+from calfkit.providers import OpenAIResponsesModelClient
 from calfkit.client import Client
 from calfkit.worker import Worker
 from weather_tool import get_weather  # Import the tool definition (reusable)
@@ -182,7 +182,7 @@ agent = Agent(
     "weather_agent",
     system_prompt="You are a helpful assistant.",
     subscribe_topics="weather_agent.input",
-    model_client=OpenAIModelClient(model_name="gpt-5-nano"),
+    model_client=OpenAIResponsesModelClient(model_name="gpt-5.4-nano"),
     tools=[get_weather],  # Register tool definitions with the agent
 )
 
@@ -247,7 +247,7 @@ Agents can be deployed with a `final_output_type` to enforce structured output f
 ```python
 from dataclasses import dataclass
 from calfkit.nodes import Agent
-from calfkit.providers import OpenAIModelClient
+from calfkit.providers import OpenAIResponsesModelClient
 
 @dataclass
 class WeatherReport:
@@ -258,7 +258,7 @@ agent = Agent(
     "weather_agent",
     system_prompt="You are a helpful assistant.",
     subscribe_topics="weather_agent.input",
-    model_client=OpenAIModelClient(model_name="gpt-5-nano"),
+    model_client=OpenAIResponsesModelClient(model_name="gpt-5.4-nano"),
     final_output_type=WeatherReport,  # Enforce structured output
 )
 ```

{calfkit-0.2.2 → calfkit-0.2.4}/README.md

@@ -135,7 +135,7 @@ Deploy the agent as its own service. The `Agent` handles LLM chat, tool orchestr
 # agent_service.py
 import asyncio
 from calfkit.nodes import Agent
-from calfkit.providers import OpenAIModelClient
+from calfkit.providers import OpenAIResponsesModelClient
 from calfkit.client import Client
 from calfkit.worker import Worker
 from weather_tool import get_weather  # Import the tool definition (reusable)
@@ -144,7 +144,7 @@ agent = Agent(
     "weather_agent",
     system_prompt="You are a helpful assistant.",
     subscribe_topics="weather_agent.input",
-    model_client=OpenAIModelClient(model_name="gpt-5-nano"),
+    model_client=OpenAIResponsesModelClient(model_name="gpt-5.4-nano"),
     tools=[get_weather],  # Register tool definitions with the agent
 )
 
@@ -209,7 +209,7 @@ Agents can be deployed with a `final_output_type` to enforce structured output f
 ```python
 from dataclasses import dataclass
 from calfkit.nodes import Agent
-from calfkit.providers import OpenAIModelClient
+from calfkit.providers import OpenAIResponsesModelClient
 
 @dataclass
 class WeatherReport:
@@ -220,7 +220,7 @@ agent = Agent(
     "weather_agent",
     system_prompt="You are a helpful assistant.",
     subscribe_topics="weather_agent.input",
-    model_client=OpenAIModelClient(model_name="gpt-5-nano"),
+    model_client=OpenAIResponsesModelClient(model_name="gpt-5.4-nano"),
     final_output_type=WeatherReport,  # Enforce structured output
 )
 ```

{calfkit-0.2.2 → calfkit-0.2.4}/calfkit/__init__.py

@@ -3,8 +3,7 @@ from importlib.metadata import version
 from calfkit.client import Client, InvocationHandle, NodeResult
 from calfkit.models import ToolContext
 from calfkit.nodes import Agent, BaseNodeDef, NodeDef, ToolNodeDef, agent_tool
-from calfkit.providers import OpenAIModelClient
-from calfkit.stores import InMemoryMessageHistoryStore, MessageHistoryStore
+from calfkit.providers import AnthropicModelClient, OpenAIModelClient, OpenAIResponsesModelClient
 from calfkit.worker import Worker
 
 __version__ = version("calfkit")
@@ -23,10 +22,9 @@ __all__ = [
     "ToolNodeDef",
     "agent_tool",
     # providers
+    "AnthropicModelClient",
     "OpenAIModelClient",
-    # stores
-    "InMemoryMessageHistoryStore",
-    "MessageHistoryStore",
+    "OpenAIResponsesModelClient",
     # worker
     "Worker",
 ]

{calfkit-0.2.2 → calfkit-0.2.4}/calfkit/_vendor/pydantic_ai/models/anthropic.py

@@ -136,7 +136,7 @@ try:
     from anthropic.types.beta.beta_web_fetch_tool_result_block_param import (
         Content as WebFetchToolResultBlockParamContent,
     )
-    from anthropic.types.beta.beta_web_search_tool_20250305_param import UserLocation
+    from anthropic.types.beta.beta_user_location_param import BetaUserLocationParam
     from anthropic.types.model_param import ModelParam
 
 except ImportError as _import_error:
@@ -619,7 +619,7 @@ class AnthropicModel(Model):
         mcp_servers: list[BetaRequestMCPServerURLDefinitionParam] = []
         for tool in model_request_parameters.builtin_tools:
             if isinstance(tool, WebSearchTool):
-                user_location = UserLocation(type='approximate', **tool.user_location) if tool.user_location else None
+                user_location = BetaUserLocationParam(type='approximate', **tool.user_location) if tool.user_location else None
                 tools.append(
                     BetaWebSearchTool20250305Param(
                         name='web_search',

{calfkit-0.2.2 → calfkit-0.2.4}/calfkit/_vendor/vendor.txt

@@ -11,3 +11,4 @@ pydantic-ai-slim==1.47.0  https://github.com/pydantic/pydantic-ai
 #   - _run_context.py: Made model/usage optional with defaults for ToolContext construction
 #   - _function_schema.py: _is_call_ctx() recognizes RunContext subclasses
 #   - messages.py: Added `retry_prompt` classmethod to ModelRequest
+#   - models/anthropic.py: UserLocation -> BetaUserLocationParam (anthropic SDK 0.80.0 rename)

calfkit-0.2.4/calfkit/providers/__init__.py

@@ -0,0 +1,5 @@
+"""Calf LLM Provider System."""
+
+from calfkit.providers.pydantic_ai import AnthropicModelClient, OpenAIModelClient, OpenAIResponsesModelClient
+
+__all__ = ["AnthropicModelClient", "OpenAIModelClient", "OpenAIResponsesModelClient"]

calfkit-0.2.4/calfkit/providers/pydantic_ai/__init__.py

@@ -0,0 +1,4 @@
+from calfkit.providers.pydantic_ai.anthropic import AnthropicModelClient
+from calfkit.providers.pydantic_ai.openai import OpenAIModelClient, OpenAIResponsesModelClient
+
+__all__ = ["AnthropicModelClient", "OpenAIModelClient", "OpenAIResponsesModelClient"]

calfkit-0.2.4/calfkit/providers/pydantic_ai/anthropic.py

@@ -0,0 +1,51 @@
+from typing import Any, Literal
+
+from httpx import Timeout
+
+from calfkit._vendor.pydantic_ai.models.anthropic import AnthropicModel, AnthropicModelSettings
+from calfkit._vendor.pydantic_ai.providers.anthropic import AnthropicProvider
+from calfkit.providers.pydantic_ai.model_client import PydanticModelClient
+
+
+class AnthropicModelClient(AnthropicModel, PydanticModelClient):
+    def __init__(
+        self,
+        model_name: str,
+        *,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        timeout: float | Timeout | None = None,
+        parallel_tool_calls: bool | None = None,
+        anthropic_thinking: dict[str, Any] | None = None,
+        anthropic_cache_tool_definitions: bool | Literal["5m", "1h"] | None = None,
+        anthropic_cache_instructions: bool | Literal["5m", "1h"] | None = None,
+        anthropic_cache_messages: bool | Literal["5m", "1h"] | None = None,
+        **kwargs: Any,
+    ):
+        settings_kwargs: dict[str, object] = {}
+        if max_tokens is not None:
+            settings_kwargs["max_tokens"] = max_tokens
+        if temperature is not None:
+            settings_kwargs["temperature"] = temperature
+        if top_p is not None:
+            settings_kwargs["top_p"] = top_p
+        if timeout is not None:
+            settings_kwargs["timeout"] = timeout
+        if parallel_tool_calls is not None:
+            settings_kwargs["parallel_tool_calls"] = parallel_tool_calls
+        if anthropic_thinking is not None:
+            settings_kwargs["anthropic_thinking"] = anthropic_thinking
+        if anthropic_cache_tool_definitions is not None:
+            settings_kwargs["anthropic_cache_tool_definitions"] = anthropic_cache_tool_definitions
+        if anthropic_cache_instructions is not None:
+            settings_kwargs["anthropic_cache_instructions"] = anthropic_cache_instructions
+        if anthropic_cache_messages is not None:
+            settings_kwargs["anthropic_cache_messages"] = anthropic_cache_messages
+        model_settings: AnthropicModelSettings = AnthropicModelSettings(**settings_kwargs, **kwargs)  # type: ignore[typeddict-item]
+
+        anthropic_client = AnthropicProvider(api_key=api_key, base_url=base_url)
+        self.model_settings = model_settings
+        super().__init__(model_name, provider=anthropic_client, settings=model_settings)

calfkit-0.2.4/calfkit/providers/pydantic_ai/openai.py

@@ -0,0 +1,142 @@
+from typing import Any, Literal
+
+from httpx import Timeout
+
+from calfkit._vendor.pydantic_ai.models.openai import (
+    OpenAIChatModel,
+    OpenAIChatModelSettings,
+    OpenAIResponsesModel,
+    OpenAIResponsesModelSettings,
+)
+from calfkit._vendor.pydantic_ai.providers.openai import OpenAIProvider
+from calfkit.providers.pydantic_ai.model_client import PydanticModelClient
+
+
+class OpenAIModelClient(OpenAIChatModel, PydanticModelClient):
+    def __init__(
+        self,
+        model_name: str,
+        *,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        reasoning_effort: str | None = None,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        timeout: float | Timeout | None = None,
+        parallel_tool_calls: bool | None = None,
+        seed: int | None = None,
+        presence_penalty: float | None = None,
+        frequency_penalty: float | None = None,
+        logit_bias: dict[str, int] | None = None,
+        stop_sequences: list[str] | None = None,
+        extra_headers: dict[str, str] | None = None,
+        extra_body: object | None = None,
+        **kwargs: Any,
+    ):
+        settings_kwargs: dict[str, object] = {}
+        if reasoning_effort is not None:
+            settings_kwargs["openai_reasoning_effort"] = reasoning_effort
+        if max_tokens is not None:
+            settings_kwargs["max_tokens"] = max_tokens
+        if temperature is not None:
+            settings_kwargs["temperature"] = temperature
+        if top_p is not None:
+            settings_kwargs["top_p"] = top_p
+        if timeout is not None:
+            settings_kwargs["timeout"] = timeout
+        if parallel_tool_calls is not None:
+            settings_kwargs["parallel_tool_calls"] = parallel_tool_calls
+        if seed is not None:
+            settings_kwargs["seed"] = seed
+        if presence_penalty is not None:
+            settings_kwargs["presence_penalty"] = presence_penalty
+        if frequency_penalty is not None:
+            settings_kwargs["frequency_penalty"] = frequency_penalty
+        if logit_bias is not None:
+            settings_kwargs["logit_bias"] = logit_bias
+        if stop_sequences is not None:
+            settings_kwargs["stop_sequences"] = stop_sequences
+        if extra_headers is not None:
+            settings_kwargs["extra_headers"] = extra_headers
+        if extra_body is not None:
+            settings_kwargs["extra_body"] = extra_body
+        model_settings: OpenAIChatModelSettings = OpenAIChatModelSettings(**settings_kwargs, **kwargs)  # type: ignore[typeddict-item]
+
+        openai_client = OpenAIProvider(base_url=base_url, api_key=api_key)
+        self.model_settings = model_settings
+        super().__init__(model_name, provider=openai_client, settings=model_settings)
+
+
+class OpenAIResponsesModelClient(OpenAIResponsesModel, PydanticModelClient):
+    def __init__(
+        self,
+        model_name: str,
+        *,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        reasoning_effort: str | None = None,
+        reasoning_summary: Literal["detailed", "concise", "auto"] | None = None,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        timeout: float | Timeout | None = None,
+        parallel_tool_calls: bool | None = None,
+        truncation: Literal["disabled", "auto"] | None = None,
+        text_verbosity: Literal["low", "medium", "high"] | None = None,
+        previous_response_id: Literal["auto"] | str | None = None,
+        send_reasoning_ids: bool | None = None,
+        user: str | None = None,
+        service_tier: Literal["auto", "default", "flex", "priority"] | None = None,
+        logprobs: bool | None = None,
+        top_logprobs: int | None = None,
+        prompt_cache_key: str | None = None,
+        prompt_cache_retention: Literal["in-memory", "24h"] | None = None,
+        extra_headers: dict[str, str] | None = None,
+        extra_body: object | None = None,
+        **kwargs: Any,
+    ):
+        settings_kwargs: dict[str, object] = {}
+        if reasoning_effort is not None:
+            settings_kwargs["openai_reasoning_effort"] = reasoning_effort
+        if reasoning_summary is not None:
+            settings_kwargs["openai_reasoning_summary"] = reasoning_summary
+        if max_tokens is not None:
+            settings_kwargs["max_tokens"] = max_tokens
+        if temperature is not None:
+            settings_kwargs["temperature"] = temperature
+        if top_p is not None:
+            settings_kwargs["top_p"] = top_p
+        if timeout is not None:
+            settings_kwargs["timeout"] = timeout
+        if parallel_tool_calls is not None:
+            settings_kwargs["parallel_tool_calls"] = parallel_tool_calls
+        if truncation is not None:
+            settings_kwargs["openai_truncation"] = truncation
+        if text_verbosity is not None:
+            settings_kwargs["openai_text_verbosity"] = text_verbosity
+        if previous_response_id is not None:
+            settings_kwargs["openai_previous_response_id"] = previous_response_id
+        if send_reasoning_ids is not None:
+            settings_kwargs["openai_send_reasoning_ids"] = send_reasoning_ids
+        if user is not None:
+            settings_kwargs["openai_user"] = user
+        if service_tier is not None:
+            settings_kwargs["openai_service_tier"] = service_tier
+        if logprobs is not None:
+            settings_kwargs["openai_logprobs"] = logprobs
+        if top_logprobs is not None:
+            settings_kwargs["openai_top_logprobs"] = top_logprobs
+        if prompt_cache_key is not None:
+            settings_kwargs["openai_prompt_cache_key"] = prompt_cache_key
+        if prompt_cache_retention is not None:
+            settings_kwargs["openai_prompt_cache_retention"] = prompt_cache_retention
+        if extra_headers is not None:
+            settings_kwargs["extra_headers"] = extra_headers
+        if extra_body is not None:
+            settings_kwargs["extra_body"] = extra_body
+        model_settings: OpenAIResponsesModelSettings = OpenAIResponsesModelSettings(**settings_kwargs, **kwargs)  # type: ignore[typeddict-item]
+
+        openai_client = OpenAIProvider(base_url=base_url, api_key=api_key)
+        self.model_settings = model_settings
+        super().__init__(model_name, provider=openai_client, settings=model_settings)

{calfkit-0.2.2 → calfkit-0.2.4}/examples/deprecated/router_node.py

@@ -4,7 +4,6 @@ from calfkit.broker.broker import BrokerClient
 from calfkit.nodes.agent_router_node import AgentRouterNode
 from calfkit.nodes.chat_node import ChatNode
 from calfkit.runners.service import NodesService
-
 from calfkit.stores.in_memory import InMemoryMessageHistoryStore
 
 # Import tools from tool_nodes - router needs schemas for LLM and topic routing

{calfkit-0.2.2 → calfkit-0.2.4}/examples/quickstart/agent_service.py

@@ -4,14 +4,14 @@ from weather_tool import get_weather  # Import the tool definition (reusable)
 
 from calfkit.client import Client
 from calfkit.nodes import Agent
-from calfkit.providers import OpenAIModelClient
+from calfkit.providers import OpenAIResponsesModelClient
 from calfkit.worker import Worker
 
 agent = Agent(
     "weather_agent",
     system_prompt="You are a helpful assistant.",
     subscribe_topics="weather_agent.input",
-    model_client=OpenAIModelClient(model_name="gpt-5-nano"),
+    model_client=OpenAIResponsesModelClient(model_name="gpt-5.4-nano"),
     tools=[get_weather],  # Register tool definitions with the agent
 )
 

{calfkit-0.2.2 → calfkit-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "calfkit"
-version = "0.2.2"
+version = "0.2.4"
 description = "Build AI workflows and agents as fully-distributed and event-driven microservices."
 readme = "README.md"
 license = "Apache-2.0"
@@ -33,7 +33,7 @@ dependencies = [
     "exceptiongroup>=1.2.2; python_version < '3.11'",
     # Provider SDKs
     "openai>=1.0.0",
-    "anthropic>=0.20.0",
+    "anthropic>=0.80.0",
     "typing-extensions>=4.15.0",
     "dishka>=1.9.1",
 ]

{calfkit-0.2.2 → calfkit-0.2.4}/tests/conftest.py

@@ -1,18 +1,22 @@
+import os
 from collections.abc import Callable
+from typing import Any
 
 import pytest
 from dishka import make_container
+from dotenv import load_dotenv
 
 from calfkit._types import OutputT
 from calfkit._vendor.pydantic_ai.models.function import FunctionModel
 from calfkit.nodes import Agent, ToolNodeDef
-from calfkit.providers.pydantic_ai.model_client import PydanticModelClient
+from calfkit.providers.pydantic_ai.openai import OpenAIModelClient, OpenAIResponsesModelClient
 from calfkit.worker import Worker
 from tests.providers import (
     INSTRUCTIONS_TEST_SYSTEM_PROMPT,
     AgentProvider,
     ClientProvider,
     ContextualTool,
+    Response,
     SimpleAgent,
     StructuredAgent,
     WorkerProvider,
@@ -20,6 +24,8 @@ from tests.providers import (
     echo_instructions,
 )
 
+load_dotenv()
+
 
 @pytest.fixture
 def container():
@@ -29,25 +35,40 @@ def container():
 
 
 @pytest.fixture(params=["parallel", "sequential"])
-def deploy_agent(request, container) -> SimpleAgent:
+def agent_constructor_args_sequential_modes(request) -> dict[str, bool]:
     mode: str = request.param
+    return {"sequential_only_mode": mode == "sequential"}
+
+
+@pytest.fixture(params=["openai_responses", "openai_chat"])
+def agent_constructor_args_model_client(request) -> dict[str, Any]:
+    model_type: str = request.param
+    if model_type == "openai_chat":
+        model_client = OpenAIModelClient(os.environ["TEST_LLM_MODEL_NAME"], reasoning_effort=os.getenv("TEST_REASONING_EFFORT"))
+        return {"model_client": model_client}
+    elif model_type == "openai_responses":
+        model_client = OpenAIResponsesModelClient(os.environ["TEST_LLM_MODEL_NAME"], reasoning_effort=os.getenv("TEST_REASONING_EFFORT"))
+        return {"model_client": model_client}
+    else:
+        raise RuntimeError(f"Invalid model client: {model_type}")
+
+
+@pytest.fixture
+def deploy_agent(agent_constructor_args_model_client, container) -> SimpleAgent:
     worker = container.get(Worker)
-    model_client = container.get(PydanticModelClient)
     agent = SimpleAgent(
         "test_simple_agent",
         system_prompt=f"You are a helpful AI assistant. Your name is {agent_name}. Help the user with their questions as much as possible.",
         subscribe_topics="test_agent.input",
         publish_topic="test_agent.output",
-        model_client=model_client,
-        sequential_only_mode=mode == "sequential",
+        **agent_constructor_args_model_client,
     )
     worker.add_nodes(agent)
     return agent
 
 
-@pytest.fixture(params=["parallel", "sequential"])
-def deploy_function_agent(request, container) -> Agent:
-    mode: str = request.param
+@pytest.fixture
+def deploy_function_agent(agent_constructor_args_sequential_modes, container) -> Agent:
     worker = container.get(Worker)
     model = container.get(FunctionModel)
     agent = Agent(
@@ -56,25 +77,45 @@ def deploy_function_agent(request, container) -> Agent:
         subscribe_topics="test_function_agent.input",
         publish_topic="test_function_agent.output",
         model_client=model,
-        sequential_only_mode=mode == "sequential",
+        **agent_constructor_args_sequential_modes,
     )
-    print(f"\nDeployed agent with sequential_only_mode={mode == 'sequential'}")
+    print(f"\nDeployed agent with sequential_only_mode={agent_constructor_args_sequential_modes}")
     worker.add_nodes(agent)
     return agent
 
 
 @pytest.fixture
-def deploy_structured_agent(container) -> StructuredAgent:
+def deploy_structured_agent(agent_constructor_args_model_client, container) -> StructuredAgent:
     worker = container.get(Worker)
-    agent = container.get(StructuredAgent)
+    agent = StructuredAgent(
+        "test_structured_agent",
+        system_prompt=f"You are a helpful AI assistant. Your name is {agent_name}. Help the user with their questions as much as possible.",
+        subscribe_topics="test_agent.input",
+        publish_topic="test_agent.output",
+        final_output_type=Response,
+        **agent_constructor_args_model_client,
+    )
     worker.add_nodes(agent)
     return agent
 
 
 @pytest.fixture
-def deploy_structured_agent_factory(container) -> Callable[..., Agent[OutputT]]:
-    factory = container.get(Callable)
-    return factory
+def deploy_structured_agent_factory(agent_constructor_args_model_client, container) -> Callable[..., Agent[OutputT]]:
+    worker = container.get(Worker)
+
+    def agent_factory(output_type: type[OutputT]) -> Agent[OutputT]:
+        agent = Agent[output_type](
+            "test_custom_structured_agent",
+            system_prompt=f"You are a helpful AI assistant. Your name is {agent_name}. Help the user with their questions as much as possible.",
+            subscribe_topics="test_agent.input",
+            publish_topic="test_agent.output",
+            final_output_type=output_type,
+            **agent_constructor_args_model_client,
+        )
+        worker.add_nodes(agent)
+        return agent
+
+    return agent_factory
 
 
 @pytest.fixture

{calfkit-0.2.2 → calfkit-0.2.4}/tests/providers.py

@@ -1,5 +1,3 @@
-import os
-from collections.abc import Callable
 from dataclasses import dataclass
 from typing import NewType
 
@@ -7,14 +5,11 @@ from dishka import AnyOf, Provider, Scope, provide
 from dotenv import load_dotenv
 from faststream.kafka import KafkaBroker
 
-from calfkit._types import OutputT
 from calfkit._vendor.pydantic_ai.messages import ModelMessage, ModelRequest, ModelResponse, TextPart, ToolCallPart, ToolReturnPart
 from calfkit._vendor.pydantic_ai.models.function import AgentInfo, FunctionModel
 from calfkit.client import Client
 from calfkit.models.tool_context import ToolContext
 from calfkit.nodes import Agent, BaseToolNodeDef, ToolNodeDef, agent_tool
-from calfkit.providers.pydantic_ai.model_client import PydanticModelClient
-from calfkit.providers.pydantic_ai.openai import OpenAIModelClient
 from calfkit.worker import Worker
 
 load_dotenv()
@@ -120,42 +115,10 @@ ContextualTool = NewType("ContextualTool", ToolNodeDef)
 class AgentProvider(Provider):
     scope = Scope.APP
 
-    @provide
-    def get_model_client(self) -> PydanticModelClient:
-        return OpenAIModelClient(os.environ["TEST_LLM_MODEL_NAME"], reasoning_effort=os.getenv("TEST_REASONING_EFFORT"))
-
     @provide
     def get_function_model(self) -> FunctionModel:
         return FunctionModel(call_all_tools_concurrently)
 
-    @provide
-    def get_structured_agent_factory(self, model_client: PydanticModelClient, worker: Worker) -> Callable:
-        def factory(output_type: type[OutputT]) -> Agent[OutputT]:
-            agent = Agent[output_type](
-                "test_custom_structured_agent",
-                system_prompt=f"You are a helpful AI assistant. Your name is {agent_name}. Help the user with their questions as much as possible.",
-                subscribe_topics="test_agent.input",
-                publish_topic="test_agent.output",
-                model_client=model_client,
-                final_output_type=output_type,
-            )
-            worker.add_nodes(agent)
-
-            return agent
-
-        return factory
-
-    @provide
-    def get_structured_agent(self, model_client: PydanticModelClient) -> StructuredAgent:
-        return StructuredAgent(
-            "test_structured_agent",
-            system_prompt=f"You are a helpful AI assistant. Your name is {agent_name}. Help the user with their questions as much as possible.",
-            subscribe_topics="test_agent.input",
-            publish_topic="test_agent.output",
-            model_client=model_client,
-            final_output_type=Response,
-        )
-
     @provide
     def get_multiple_tools(self) -> AnyOf[list[BaseToolNodeDef], list[ToolNodeDef]]:
         return [agent_tool(get_users_name), agent_tool(weather), agent_tool(get_users_birthday)]

{calfkit-0.2.2 → calfkit-0.2.4}/tests/test_concurrent_tool_calls.py

@@ -20,7 +20,7 @@ async def test_concurrent_tool_calling(container, deploy_function_agent, deploy_
         random_str = "".join(random.choices(string.ascii_letters, k=20))  # 20 char random string
         random_city = Faker().city()
         result = await client.execute_node(
-            "Hey! Call all your tools in concurrently right now",
+            "Hey! Call all your tools concurrently right now",
             deploy_function_agent.subscribe_topics[0],
             deps={"random_number": random_num, "random_string": random_str, "random_city": random_city},
         )

calfkit-0.2.2/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.2.2"
-}

calfkit-0.2.2/calfkit/providers/__init__.py

@@ -1,5 +0,0 @@
-"""Calf LLM Provider System."""
-
-from calfkit.providers.pydantic_ai import OpenAIModelClient
-
-__all__ = ["OpenAIModelClient"]

calfkit-0.2.2/calfkit/providers/pydantic_ai/__init__.py

@@ -1,3 +0,0 @@
-from calfkit.providers.pydantic_ai.openai import OpenAIModelClient
-
-__all__ = ["OpenAIModelClient"]