pass instructions and requires_tools to /models

Author: yannbu

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "workflowai"
-version = "0.6.0.dev17"
+version = "0.6.0.dev18"
 description = ""
 authors = ["Guillaume Aquilina <[email protected]>"]
 readme = "README.md"

workflowai/core/client/_models.py

@@ -202,6 +202,11 @@ class ListModelsResponse(Page[ModelInfo]):
     """Response from the list models API endpoint."""
 
 
+class ListModelsRequest(BaseModel):
+    instructions: Optional[str] = Field(default=None, description="Used to detect internal tools")
+    requires_tools: Optional[bool] = Field(default=False, description="Whether the agent uses external tools")
+
+
 class CompletionsResponse(BaseModel):
     """Response from the completions API endpoint."""
 

workflowai/core/client/agent.py

@@ -12,6 +12,7 @@
     CompletionsResponse,
     CreateAgentRequest,
     CreateAgentResponse,
+    ListModelsRequest,
     ListModelsResponse,
     ModelInfo,
     ReplyRequest,
@@ -486,12 +487,22 @@ async def list_models(self) -> list[ModelInfo]:
         Raises:
             ValueError: If the agent has not been registered (schema_id is None).
         """
+
         if not self.schema_id:
             self.schema_id = await self.register()
 
-        response = await self.api.get(
+        data = ListModelsRequest()
+        if self.version and isinstance(self.version, VersionProperties):
+            data.instructions = self.version.instructions
+
+        if self._tools:
+            for _ in self._tools.values():
+                data.requires_tools = True
+
+        response = await self.api.post(
             # The "_" refers to the currently authenticated tenant's namespace
             f"/v1/_/agents/{self.agent_id}/schemas/{self.schema_id}/models",
+            data=data,
             returns=ListModelsResponse,
         )
         return response.items

workflowai/core/client/agent_test.py

@@ -35,6 +35,49 @@ def agent(api_client: APIClient):
     return Agent(agent_id="123", schema_id=1, input_cls=HelloTaskInput, output_cls=HelloTaskOutput, api=api_client)
 
 
+@pytest.fixture
+def agent_with_instructions(api_client: APIClient):
+    return Agent(
+        agent_id="123",
+        schema_id=1,
+        input_cls=HelloTaskInput,
+        output_cls=HelloTaskOutput,
+        api=api_client,
+        version=VersionProperties(instructions="Some instructions"),
+    )
+
+
+@pytest.fixture
+def agent_with_tools(api_client: APIClient):
+    def some_tool() -> str:
+        return "Hello, world!"
+
+    return Agent(
+        agent_id="123",
+        schema_id=1,
+        input_cls=HelloTaskInput,
+        output_cls=HelloTaskOutput,
+        api=api_client,
+        tools=[some_tool],
+    )
+
+
+@pytest.fixture
+def agent_with_tools_and_instructions(api_client: APIClient):
+    def some_tool() -> str:
+        return "Hello, world!"
+
+    return Agent(
+        agent_id="123",
+        schema_id=1,
+        input_cls=HelloTaskInput,
+        output_cls=HelloTaskOutput,
+        api=api_client,
+        version=VersionProperties(instructions="Some instructions"),
+        tools=[some_tool],
+    )
+
+
 @pytest.fixture
 def agent_not_optional(api_client: APIClient):
     return Agent(
@@ -463,7 +506,11 @@ async def test_list_models(agent: Agent[HelloTaskInput, HelloTaskOutput], httpx_
     # Verify the HTTP request was made correctly
     request = httpx_mock.get_request()
     assert request is not None, "Expected an HTTP request to be made"
+    assert request.method == "POST"
     assert request.url == "http://localhost:8000/v1/_/agents/123/schemas/1/models"
+    assert json.loads(request.content) == {
+        "requires_tools": False,
+    }
 
     # Verify we get back the full ModelInfo objects
     assert len(models) == 2
@@ -530,7 +577,11 @@ async def test_list_models_registers_if_needed(
     reqs = httpx_mock.get_requests()
     assert len(reqs) == 2
     assert reqs[0].url == "http://localhost:8000/v1/_/agents"
+    assert reqs[1].method == "POST"
     assert reqs[1].url == "http://localhost:8000/v1/_/agents/123/schemas/2/models"
+    assert json.loads(reqs[1].content) == {
+        "requires_tools": False,
+    }
 
     # Verify we get back the full ModelInfo object
     assert len(models) == 1
@@ -542,6 +593,252 @@ async def test_list_models_registers_if_needed(
     assert models[0].metadata.provider_name == "OpenAI"
 
 
+@pytest.mark.asyncio
+async def test_list_models_with_instructions(
+    agent_with_instructions: Agent[HelloTaskInput, HelloTaskOutput],
+    httpx_mock: HTTPXMock,
+):
+    """Test that list_models correctly fetches and returns available models."""
+    # Mock the HTTP response instead of the API client method
+    httpx_mock.add_response(
+        method="POST",
+        url="http://localhost:8000/v1/_/agents/123/schemas/1/models",
+        json={
+            "items": [
+                {
+                    "id": "gpt-4",
+                    "name": "GPT-4",
+                    "icon_url": "https://example.com/gpt4.png",
+                    "modes": ["chat"],
+                    "is_not_supported_reason": None,
+                    "average_cost_per_run_usd": 0.01,
+                    "is_latest": True,
+                    "metadata": {
+                        "provider_name": "OpenAI",
+                        "price_per_input_token_usd": 0.0001,
+                        "price_per_output_token_usd": 0.0002,
+                        "release_date": "2024-01-01",
+                        "context_window_tokens": 128000,
+                        "quality_index": 0.95,
+                    },
+                    "is_default": True,
+                    "providers": ["openai"],
+                },
+                {
+                    "id": "claude-3",
+                    "name": "Claude 3",
+                    "icon_url": "https://example.com/claude3.png",
+                    "modes": ["chat"],
+                    "is_not_supported_reason": None,
+                    "average_cost_per_run_usd": 0.015,
+                    "is_latest": True,
+                    "metadata": {
+                        "provider_name": "Anthropic",
+                        "price_per_input_token_usd": 0.00015,
+                        "price_per_output_token_usd": 0.00025,
+                        "release_date": "2024-03-01",
+                        "context_window_tokens": 200000,
+                        "quality_index": 0.98,
+                    },
+                    "is_default": False,
+                    "providers": ["anthropic"],
+                },
+            ],
+            "count": 2,
+        },
+    )
+
+    # Call the method
+    models = await agent_with_instructions.list_models()
+
+    # Verify the HTTP request was made correctly
+    request = httpx_mock.get_request()
+    assert request is not None, "Expected an HTTP request to be made"
+    assert request.method == "POST"
+    assert request.url == "http://localhost:8000/v1/_/agents/123/schemas/1/models"
+    assert json.loads(request.content) == {"instructions": "Some instructions", "requires_tools": False}
+
+    # Verify we get back the full ModelInfo objects
+    assert len(models) == 2
+    assert isinstance(models[0], ModelInfo)
+    assert models[0].id == "gpt-4"
+    assert models[0].name == "GPT-4"
+    assert models[0].modes == ["chat"]
+    assert models[0].metadata is not None
+    assert models[0].metadata.provider_name == "OpenAI"
+
+    assert isinstance(models[1], ModelInfo)
+    assert models[1].id == "claude-3"
+    assert models[1].name == "Claude 3"
+    assert models[1].modes == ["chat"]
+    assert models[1].metadata is not None
+    assert models[1].metadata.provider_name == "Anthropic"
+
+
+@pytest.mark.asyncio
+async def test_list_models_with_tools(
+    agent_with_tools: Agent[HelloTaskInput, HelloTaskOutput],
+    httpx_mock: HTTPXMock,
+):
+    """Test that list_models correctly fetches and returns available models."""
+    # Mock the HTTP response instead of the API client method
+    httpx_mock.add_response(
+        method="POST",
+        url="http://localhost:8000/v1/_/agents/123/schemas/1/models",
+        json={
+            "items": [
+                {
+                    "id": "gpt-4",
+                    "name": "GPT-4",
+                    "icon_url": "https://example.com/gpt4.png",
+                    "modes": ["chat"],
+                    "is_not_supported_reason": None,
+                    "average_cost_per_run_usd": 0.01,
+                    "is_latest": True,
+                    "metadata": {
+                        "provider_name": "OpenAI",
+                        "price_per_input_token_usd": 0.0001,
+                        "price_per_output_token_usd": 0.0002,
+                        "release_date": "2024-01-01",
+                        "context_window_tokens": 128000,
+                        "quality_index": 0.95,
+                    },
+                    "is_default": True,
+                    "providers": ["openai"],
+                },
+                {
+                    "id": "claude-3",
+                    "name": "Claude 3",
+                    "icon_url": "https://example.com/claude3.png",
+                    "modes": ["chat"],
+                    "is_not_supported_reason": None,
+                    "average_cost_per_run_usd": 0.015,
+                    "is_latest": True,
+                    "metadata": {
+                        "provider_name": "Anthropic",
+                        "price_per_input_token_usd": 0.00015,
+                        "price_per_output_token_usd": 0.00025,
+                        "release_date": "2024-03-01",
+                        "context_window_tokens": 200000,
+                        "quality_index": 0.98,
+                    },
+                    "is_default": False,
+                    "providers": ["anthropic"],
+                },
+            ],
+            "count": 2,
+        },
+    )
+
+    # Call the method
+    models = await agent_with_tools.list_models()
+
+    # Verify the HTTP request was made correctly
+    request = httpx_mock.get_request()
+    assert request is not None, "Expected an HTTP request to be made"
+    assert request.method == "POST"
+    assert request.url == "http://localhost:8000/v1/_/agents/123/schemas/1/models"
+    assert json.loads(request.content) == {"requires_tools": True}
+
+    # Verify we get back the full ModelInfo objects
+    assert len(models) == 2
+    assert isinstance(models[0], ModelInfo)
+    assert models[0].id == "gpt-4"
+    assert models[0].name == "GPT-4"
+    assert models[0].modes == ["chat"]
+    assert models[0].metadata is not None
+    assert models[0].metadata.provider_name == "OpenAI"
+
+    assert isinstance(models[1], ModelInfo)
+    assert models[1].id == "claude-3"
+    assert models[1].name == "Claude 3"
+    assert models[1].modes == ["chat"]
+    assert models[1].metadata is not None
+    assert models[1].metadata.provider_name == "Anthropic"
+
+
+@pytest.mark.asyncio
+async def test_list_models_with_instructions_and_tools(
+    agent_with_tools_and_instructions: Agent[HelloTaskInput, HelloTaskOutput],
+    httpx_mock: HTTPXMock,
+):
+    """Test that list_models correctly fetches and returns available models."""
+    # Mock the HTTP response instead of the API client method
+    httpx_mock.add_response(
+        method="POST",
+        url="http://localhost:8000/v1/_/agents/123/schemas/1/models",
+        json={
+            "items": [
+                {
+                    "id": "gpt-4",
+                    "name": "GPT-4",
+                    "icon_url": "https://example.com/gpt4.png",
+                    "modes": ["chat"],
+                    "is_not_supported_reason": None,
+                    "average_cost_per_run_usd": 0.01,
+                    "is_latest": True,
+                    "metadata": {
+                        "provider_name": "OpenAI",
+                        "price_per_input_token_usd": 0.0001,
+                        "price_per_output_token_usd": 0.0002,
+                        "release_date": "2024-01-01",
+                        "context_window_tokens": 128000,
+                        "quality_index": 0.95,
+                    },
+                    "is_default": True,
+                    "providers": ["openai"],
+                },
+                {
+                    "id": "claude-3",
+                    "name": "Claude 3",
+                    "icon_url": "https://example.com/claude3.png",
+                    "modes": ["chat"],
+                    "is_not_supported_reason": None,
+                    "average_cost_per_run_usd": 0.015,
+                    "is_latest": True,
+                    "metadata": {
+                        "provider_name": "Anthropic",
+                        "price_per_input_token_usd": 0.00015,
+                        "price_per_output_token_usd": 0.00025,
+                        "release_date": "2024-03-01",
+                        "context_window_tokens": 200000,
+                        "quality_index": 0.98,
+                    },
+                    "is_default": False,
+                    "providers": ["anthropic"],
+                },
+            ],
+            "count": 2,
+        },
+    )
+
+    # Call the method
+    models = await agent_with_tools_and_instructions.list_models()
+
+    # Verify the HTTP request was made correctly
+    request = httpx_mock.get_request()
+    assert request is not None, "Expected an HTTP request to be made"
+    assert request.method == "POST"
+    assert request.url == "http://localhost:8000/v1/_/agents/123/schemas/1/models"
+    assert json.loads(request.content) == {"instructions": "Some instructions", "requires_tools": True}
+
+    # Verify we get back the full ModelInfo objects
+    assert len(models) == 2
+    assert isinstance(models[0], ModelInfo)
+    assert models[0].id == "gpt-4"
+    assert models[0].name == "GPT-4"
+    assert models[0].modes == ["chat"]
+    assert models[0].metadata is not None
+    assert models[0].metadata.provider_name == "OpenAI"
+
+    assert isinstance(models[1], ModelInfo)
+    assert models[1].id == "claude-3"
+    assert models[1].name == "Claude 3"
+    assert models[1].modes == ["chat"]
+    assert models[1].metadata is not None
+    assert models[1].metadata.provider_name == "Anthropic"
+
+
 class TestFetchCompletions:
     async def test_fetch_completions(self, agent: Agent[HelloTaskInput, HelloTaskOutput], httpx_mock: HTTPXMock):
         """Test that fetch_completions correctly fetches and returns completions."""