agentified 0.0.3__tar.gz

agentified-0.0.3/.gitignore

@@ -0,0 +1,43 @@
+# Rust
+target/
+**/*.rs.bk
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Node
+node_modules/
+
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+*.egg
+dist/
+build/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+*.whl
+
+# TypeScript
+*.tsbuildinfo
+ts-packages/**/src/**/*.js
+ts-packages/**/src/**/*.js.map
+ts-packages/**/src/**/*.d.ts
+ts-packages/**/src/**/*.d.ts.map
+
+# Logs
+*.log

agentified-0.0.3/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: agentified
+Version: 0.0.3
+Summary: Python SDK for Agentified — Context Intelligence Layer for AI agents
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: pydantic<3,>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: respx>=0.22; extra == 'dev'

agentified-0.0.3/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agentified"
+version = "0.0.3"
+description = "Python SDK for Agentified — Context Intelligence Layer for AI agents"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx>=0.27,<1",
+    "pydantic>=2.0,<3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.24",
+    "respx>=0.22",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/agentified"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

agentified-0.0.3/src/agentified/__init__.py

@@ -0,0 +1,51 @@
+from .client import Agentified
+from ._sync import SyncAgentified
+from .tool import tool
+from .models import (
+    AgentifiedConfig,
+    AgentifiedEvent,
+    CaptureTurnOptions,
+    CaptureTurnResponse,
+    DiscoverCompleteEvent,
+    DiscoverResponse,
+    DiscoverStartEvent,
+    DiscoverTool,
+    DiscoverToolInput,
+    Message,
+    PrefetchCompleteEvent,
+    PrefetchOptions,
+    PrefetchSkippedEvent,
+    PrefetchStartEvent,
+    RankedTool,
+    RegisterResponse,
+    ServerTool,
+    ServerToolFields,
+    TokenUsage,
+    ToolDefinition,
+)
+
+__all__ = [
+    "Agentified",
+    "SyncAgentified",
+    "tool",
+    "AgentifiedConfig",
+    "AgentifiedEvent",
+    "CaptureTurnOptions",
+    "CaptureTurnResponse",
+    "DiscoverCompleteEvent",
+    "DiscoverResponse",
+    "DiscoverStartEvent",
+    "DiscoverTool",
+    "DiscoverToolInput",
+    "Message",
+    "PrefetchCompleteEvent",
+    "PrefetchOptions",
+    "PrefetchSkippedEvent",
+    "PrefetchStartEvent",
+    "RankedTool",
+    "RegisterResponse",
+    "ServerTool",
+    "ServerToolFields",
+    "TokenUsage",
+    "ToolDefinition",
+]

agentified-0.0.3/src/agentified/_sync.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from .client import Agentified
+from .models import (
+    AgentifiedConfig,
+    CaptureTurnResponse,
+    DiscoverTool,
+    RankedTool,
+    RegisterResponse,
+    ServerTool,
+)
+
+
+class SyncAgentified:
+    def __init__(self, config: AgentifiedConfig) -> None:
+        self._async = Agentified(config)
+
+    def register(self) -> RegisterResponse:
+        return asyncio.run(self._async.register())
+
+    def prefetch(self, **kwargs: Any) -> list[RankedTool]:
+        return asyncio.run(self._async.prefetch(**kwargs))
+
+    def capture_turn(self, **kwargs: Any) -> CaptureTurnResponse:
+        return asyncio.run(self._async.capture_turn(**kwargs))
+
+    def get_frontend_tools(self) -> list[ServerTool]:
+        return self._async.get_frontend_tools()
+
+    def get_frontend_tool_names(self) -> list[str]:
+        return self._async.get_frontend_tool_names()
+
+    def as_discover_tool(self) -> DiscoverTool:
+        return self._async.as_discover_tool()

agentified-0.0.3/src/agentified/client.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import httpx
+
+from .models import (
+    AgentifiedConfig,
+    AgentifiedEvent,
+    CaptureTurnResponse,
+    DiscoverResponse,
+    DiscoverStartEvent,
+    DiscoverCompleteEvent,
+    DiscoverTool,
+    DiscoverToolInput,
+    PrefetchCompleteEvent,
+    PrefetchStartEvent,
+    RankedTool,
+    RegisterResponse,
+    Message,
+    ServerTool,
+    ToolDefinition,
+)
+
+
+class Agentified:
+    def __init__(self, config: AgentifiedConfig) -> None:
+        self._config = config
+        self._client: httpx.AsyncClient | None = None
+
+    async def __aenter__(self) -> Agentified:
+        self._client = httpx.AsyncClient()
+        return self
+
+    async def __aexit__(self, *_: Any) -> None:
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def register(self) -> RegisterResponse:
+        data = {"tools": [t.model_dump(exclude_none=True) for t in self._config.tools]}
+        resp = await self._http_client.post(
+            f"{self._config.server_url}/api/v1/tools", json=data
+        )
+        return RegisterResponse.model_validate(resp.json())
+
+    async def prefetch(
+        self,
+        *,
+        messages: list[dict[str, str]],
+        limit: int | None = None,
+        exclude: list[str] | None = None,
+        turn_id: str | None = None,
+    ) -> list[RankedTool]:
+        msg_models = [Message(**m) for m in messages]
+        self._emit(PrefetchStartEvent(messages=msg_models))
+        start = time.perf_counter()
+
+        query = "\n".join(m["content"] for m in messages)
+        tools = await self._discover(query, limit, exclude, turn_id)
+
+        duration_ms = (time.perf_counter() - start) * 1000
+        self._emit(PrefetchCompleteEvent(tools=tools, duration_ms=duration_ms))
+        return tools
+
+    async def capture_turn(
+        self, *, tools_loaded: list[str], message: str
+    ) -> CaptureTurnResponse:
+        resp = await self._http_client.post(
+            f"{self._config.server_url}/api/v1/turns",
+            json={"tools_loaded": tools_loaded, "message": message},
+        )
+        return CaptureTurnResponse.model_validate(resp.json())
+
+    def get_frontend_tools(self) -> list[ServerTool]:
+        return [
+            t
+            for t in self._config.tools
+            if t.metadata and t.metadata.get("location") == "frontend"
+        ]
+
+    def get_frontend_tool_names(self) -> list[str]:
+        return [t.name for t in self.get_frontend_tools()]
+
+    def as_discover_tool(self) -> DiscoverTool:
+        async def execute(input: dict[str, Any] | DiscoverToolInput) -> list[RankedTool]:
+            if isinstance(input, dict):
+                input = DiscoverToolInput(**input)
+            self._emit(DiscoverStartEvent(query=input.query))
+            start = time.perf_counter()
+
+            tools = await self._discover(input.query, input.limit)
+
+            duration_ms = (time.perf_counter() - start) * 1000
+            self._emit(
+                DiscoverCompleteEvent(
+                    query=input.query, tools=tools, duration_ms=duration_ms
+                )
+            )
+            return tools
+
+        return DiscoverTool(
+            definition=ToolDefinition(
+                name="agentified_discover",
+                description="Find tools relevant to the current task. Call this when you need capabilities you don't have.",
+                parameters={
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "Natural language description of what you need to do",
+                        },
+                        "limit": {
+                            "type": "number",
+                            "description": "Max number of tools to return",
+                        },
+                    },
+                    "required": ["query"],
+                },
+            ),
+            execute=execute,
+        )
+
+    # -- private --
+
+    @property
+    def _http_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient()
+        return self._client
+
+    async def _discover(
+        self,
+        query: str,
+        limit: int | None = None,
+        exclude: list[str] | None = None,
+        turn_id: str | None = None,
+    ) -> list[RankedTool]:
+        body: dict[str, Any] = {"query": query}
+        if limit is not None:
+            body["limit"] = limit
+        if exclude is not None:
+            body["exclude"] = exclude
+        if turn_id is not None:
+            body["turn_id"] = turn_id
+
+        resp = await self._http_client.post(
+            f"{self._config.server_url}/api/v1/discover", json=body
+        )
+        data = DiscoverResponse.model_validate(resp.json())
+        return data.tools
+
+    def _emit(self, event: AgentifiedEvent) -> None:
+        if self._config.on_event:
+            self._config.on_event(event)

agentified-0.0.3/src/agentified/models.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Literal, Union
+
+from pydantic import BaseModel
+
+
+# Wire-format models (match Rust server snake_case JSON)
+
+class ServerToolFields(BaseModel):
+    name: str
+    description: str
+    input_schema: str | None = None
+    output_schema: str | None = None
+
+
+class ServerTool(BaseModel):
+    name: str
+    description: str
+    parameters: dict[str, Any]
+    metadata: dict[str, Any] | None = None
+    fields: ServerToolFields | None = None
+
+
+class RankedTool(ServerTool):
+    score: float
+    graph_expanded: bool | None = None
+
+
+class ToolDefinition(BaseModel):
+    name: str
+    description: str
+    parameters: dict[str, Any]
+    metadata: dict[str, Any] | None = None
+
+
+class RegisterResponse(BaseModel):
+    registered: int
+
+
+class DiscoverResponse(BaseModel):
+    tools: list[RankedTool]
+
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+
+class PrefetchOptions(BaseModel):
+    messages: list[Message]
+    limit: int | None = None
+    exclude: list[str] | None = None
+    turn_id: str | None = None
+
+
+class CaptureTurnOptions(BaseModel):
+    tools_loaded: list[str]
+    message: str
+
+
+class CaptureTurnResponse(BaseModel):
+    turn_id: str
+
+
+class DiscoverToolInput(BaseModel):
+    query: str
+    limit: int | None = None
+
+
+class TokenUsage(BaseModel):
+    input: int
+    output: int
+    cached: int
+    reasoning: int
+
+
+# Event types
+
+class PrefetchStartEvent(BaseModel):
+    type: Literal["agentified:prefetch:start"] = "agentified:prefetch:start"
+    messages: list[Message]
+
+
+class PrefetchCompleteEvent(BaseModel):
+    type: Literal["agentified:prefetch:complete"] = "agentified:prefetch:complete"
+    tools: list[RankedTool]
+    duration_ms: float
+    token_usage: TokenUsage | None = None
+
+
+class PrefetchSkippedEvent(BaseModel):
+    type: Literal["agentified:prefetch:skipped"] = "agentified:prefetch:skipped"
+    tools: list[RankedTool]
+    duration_ms: float
+
+
+class DiscoverStartEvent(BaseModel):
+    type: Literal["agentified:discover:start"] = "agentified:discover:start"
+    query: str
+
+
+class DiscoverCompleteEvent(BaseModel):
+    type: Literal["agentified:discover:complete"] = "agentified:discover:complete"
+    query: str
+    tools: list[RankedTool]
+    duration_ms: float
+    token_usage: TokenUsage | None = None
+
+
+AgentifiedEvent = Union[
+    PrefetchStartEvent,
+    PrefetchCompleteEvent,
+    PrefetchSkippedEvent,
+    DiscoverStartEvent,
+    DiscoverCompleteEvent,
+]
+
+
+# Non-serializable containers (use dataclasses for callables)
+
+@dataclass
+class DiscoverTool:
+    definition: ToolDefinition
+    execute: Callable[[DiscoverToolInput], Awaitable[list[RankedTool]]]
+
+
+@dataclass
+class AgentifiedConfig:
+    server_url: str
+    tools: list[ServerTool]
+    on_event: Callable[[AgentifiedEvent], None] | None = field(default=None)

agentified-0.0.3/src/agentified/tool.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .models import ServerTool, ServerToolFields
+
+
+def tool(
+    *,
+    name: str,
+    description: str,
+    parameters: dict[str, Any],
+    metadata: dict[str, Any] | None = None,
+) -> ServerTool:
+    return ServerTool(
+        name=name,
+        description=description,
+        parameters=parameters,
+        **({"metadata": metadata} if metadata else {}),
+        fields=ServerToolFields(
+            name=name,
+            description=description,
+            input_schema=json.dumps(parameters),
+        ),
+    )

agentified-0.0.3/tests/conftest.py

@@ -0,0 +1,14 @@
+from agentified.models import RankedTool, ServerTool
+
+TEST_URL = "http://localhost:9119"
+
+TEST_TOOL = ServerTool(
+    name="get_weather",
+    description="Get weather for a city",
+    parameters={"type": "object", "properties": {"city": {"type": "string"}}},
+)
+
+RANKED_TOOL = RankedTool(
+    **TEST_TOOL.model_dump(),
+    score=0.95,
+)

agentified-0.0.3/tests/test_client.py

@@ -0,0 +1,293 @@
+import httpx
+import pytest
+import respx
+
+from agentified.client import Agentified
+from agentified.models import (
+    AgentifiedConfig,
+    AgentifiedEvent,
+    RankedTool,
+    ServerTool,
+)
+
+TEST_URL = "http://localhost:9119"
+
+TEST_TOOL = ServerTool(
+    name="get_weather",
+    description="Get weather for a city",
+    parameters={"type": "object", "properties": {"city": {"type": "string"}}},
+)
+
+RANKED_TOOL = RankedTool(**TEST_TOOL.model_dump(), score=0.95)
+
+
+class TestRegister:
+    @respx.mock
+    async def test_posts_tools_and_returns_registered_count(self):
+        route = respx.post(f"{TEST_URL}/api/v1/tools").mock(
+            return_value=httpx.Response(200, json={"registered": 1})
+        )
+
+        async with Agentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        ) as agent:
+            result = await agent.register()
+
+        assert result.registered == 1
+        assert route.called
+        body = route.calls[0].request.content
+        assert b'"tools"' in body
+
+
+class TestPrefetch:
+    @respx.mock
+    async def test_posts_discover_from_messages_and_returns_ranked_tools(self):
+        respx.post(f"{TEST_URL}/api/v1/discover").mock(
+            return_value=httpx.Response(
+                200, json={"tools": [RANKED_TOOL.model_dump()]}
+            )
+        )
+
+        async with Agentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        ) as agent:
+            result = await agent.prefetch(
+                messages=[{"role": "user", "content": "What is the weather in Paris?"}],
+                limit=5,
+            )
+
+        assert len(result) == 1
+        assert result[0].name == "get_weather"
+        assert result[0].score == 0.95
+
+    @respx.mock
+    async def test_emits_start_and_complete_events_with_timing(self):
+        respx.post(f"{TEST_URL}/api/v1/discover").mock(
+            return_value=httpx.Response(
+                200, json={"tools": [RANKED_TOOL.model_dump()]}
+            )
+        )
+
+        events: list[AgentifiedEvent] = []
+        messages = [{"role": "user", "content": "weather in Paris"}]
+
+        async with Agentified(
+            AgentifiedConfig(
+                server_url=TEST_URL,
+                tools=[TEST_TOOL],
+                on_event=lambda e: events.append(e),
+            )
+        ) as agent:
+            await agent.prefetch(messages=messages)
+
+        assert len(events) == 2
+        assert events[0].type == "agentified:prefetch:start"
+        assert events[1].type == "agentified:prefetch:complete"
+        assert events[1].duration_ms >= 0
+
+    @respx.mock
+    async def test_passes_exclude_to_discover_body(self):
+        route = respx.post(f"{TEST_URL}/api/v1/discover").mock(
+            return_value=httpx.Response(
+                200, json={"tools": [RANKED_TOOL.model_dump()]}
+            )
+        )
+
+        async with Agentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        ) as agent:
+            await agent.prefetch(
+                messages=[{"role": "user", "content": "test"}],
+                exclude=["frontendTool"],
+            )
+
+        import json
+
+        body = json.loads(route.calls[0].request.content)
+        assert body["exclude"] == ["frontendTool"]
+
+    @respx.mock
+    async def test_omits_exclude_when_not_provided(self):
+        route = respx.post(f"{TEST_URL}/api/v1/discover").mock(
+            return_value=httpx.Response(200, json={"tools": []})
+        )
+
+        async with Agentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        ) as agent:
+            await agent.prefetch(messages=[{"role": "user", "content": "test"}])
+
+        import json
+
+        body = json.loads(route.calls[0].request.content)
+        assert "exclude" not in body
+
+    @respx.mock
+    async def test_passes_turn_id_to_discover_body(self):
+        route = respx.post(f"{TEST_URL}/api/v1/discover").mock(
+            return_value=httpx.Response(
+                200, json={"tools": [RANKED_TOOL.model_dump()]}
+            )
+        )
+
+        async with Agentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        ) as agent:
+            await agent.prefetch(
+                messages=[{"role": "user", "content": "test"}],
+                limit=5,
+                turn_id="turn-xyz",
+            )
+
+        import json
+
+        body = json.loads(route.calls[0].request.content)
+        assert body["turn_id"] == "turn-xyz"
+
+    @respx.mock
+    async def test_omits_turn_id_when_not_provided(self):
+        route = respx.post(f"{TEST_URL}/api/v1/discover").mock(
+            return_value=httpx.Response(200, json={"tools": []})
+        )
+
+        async with Agentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        ) as agent:
+            await agent.prefetch(messages=[{"role": "user", "content": "test"}])
+
+        import json
+
+        body = json.loads(route.calls[0].request.content)
+        assert "turn_id" not in body
+
+
+class TestAsDiscoverTool:
+    @respx.mock
+    async def test_returns_definition_and_calls_discover(self):
+        respx.post(f"{TEST_URL}/api/v1/discover").mock(
+            return_value=httpx.Response(
+                200, json={"tools": [RANKED_TOOL.model_dump()]}
+            )
+        )
+
+        async with Agentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        ) as agent:
+            discover_tool = agent.as_discover_tool()
+
+        assert discover_tool.definition.name == "agentified_discover"
+        assert "query" in discover_tool.definition.parameters["properties"]
+
+        result = await discover_tool.execute({"query": "weather tools", "limit": 3})
+        assert len(result) == 1
+        assert result[0].name == "get_weather"
+
+    @respx.mock
+    async def test_emits_start_and_complete_events(self):
+        respx.post(f"{TEST_URL}/api/v1/discover").mock(
+            return_value=httpx.Response(
+                200, json={"tools": [RANKED_TOOL.model_dump()]}
+            )
+        )
+
+        events: list[AgentifiedEvent] = []
+
+        async with Agentified(
+            AgentifiedConfig(
+                server_url=TEST_URL,
+                tools=[TEST_TOOL],
+                on_event=lambda e: events.append(e),
+            )
+        ) as agent:
+            await agent.as_discover_tool().execute({"query": "weather"})
+
+        assert len(events) == 2
+        assert events[0].type == "agentified:discover:start"
+        assert events[0].query == "weather"
+        assert events[1].type == "agentified:discover:complete"
+        assert events[1].duration_ms >= 0
+
+
+class TestGetFrontendTools:
+    def test_returns_tools_with_frontend_location(self):
+        frontend_tool = ServerTool(
+            name="confirm_action",
+            description="Confirm an action",
+            parameters={},
+            metadata={"location": "frontend"},
+        )
+        server_tool = ServerTool(
+            name="get_data",
+            description="Get data",
+            parameters={},
+        )
+
+        agent = Agentified(
+            AgentifiedConfig(
+                server_url=TEST_URL, tools=[frontend_tool, server_tool]
+            )
+        )
+        assert agent.get_frontend_tools() == [frontend_tool]
+
+    def test_returns_empty_when_no_frontend_tools(self):
+        agent = Agentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        )
+        assert agent.get_frontend_tools() == []
+
+
+class TestGetFrontendToolNames:
+    def test_returns_names_of_frontend_tools(self):
+        frontend_tool = ServerTool(
+            name="confirm_action",
+            description="Confirm",
+            parameters={},
+            metadata={"location": "frontend"},
+        )
+
+        agent = Agentified(
+            AgentifiedConfig(
+                server_url=TEST_URL, tools=[frontend_tool, TEST_TOOL]
+            )
+        )
+        assert agent.get_frontend_tool_names() == ["confirm_action"]
+
+
+class TestCaptureTurn:
+    @respx.mock
+    async def test_posts_turn_data_and_returns_turn_id(self):
+        route = respx.post(f"{TEST_URL}/api/v1/turns").mock(
+            return_value=httpx.Response(201, json={"turn_id": "abc-123"})
+        )
+
+        async with Agentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        ) as agent:
+            result = await agent.capture_turn(
+                tools_loaded=["get_weather"],
+                message="What is the weather?",
+            )
+
+        assert result.turn_id == "abc-123"
+        assert route.called
+
+
+class TestOnEventOptional:
+    @respx.mock
+    async def test_does_not_crash_when_on_event_not_provided(self):
+        respx.post(f"{TEST_URL}/api/v1/discover").mock(
+            return_value=httpx.Response(
+                200, json={"tools": [RANKED_TOOL.model_dump()]}
+            )
+        )
+
+        async with Agentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        ) as agent:
+            result = await agent.prefetch(
+                messages=[{"role": "user", "content": "test"}]
+            )
+            assert len(result) == 1
+
+            result2 = await agent.as_discover_tool().execute({"query": "test"})
+            assert len(result2) == 1

agentified-0.0.3/tests/test_sync.py

@@ -0,0 +1,72 @@
+import httpx
+import respx
+
+from agentified._sync import SyncAgentified
+from agentified.models import AgentifiedConfig, RankedTool, ServerTool
+
+TEST_URL = "http://localhost:9119"
+
+TEST_TOOL = ServerTool(
+    name="get_weather",
+    description="Get weather for a city",
+    parameters={"type": "object", "properties": {"city": {"type": "string"}}},
+)
+
+RANKED_TOOL = RankedTool(**TEST_TOOL.model_dump(), score=0.95)
+
+
+class TestSyncAgentified:
+    @respx.mock
+    def test_register_sync(self):
+        respx.post(f"{TEST_URL}/api/v1/tools").mock(
+            return_value=httpx.Response(200, json={"registered": 1})
+        )
+
+        client = SyncAgentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        )
+        result = client.register()
+        assert result.registered == 1
+
+    @respx.mock
+    def test_prefetch_sync(self):
+        respx.post(f"{TEST_URL}/api/v1/discover").mock(
+            return_value=httpx.Response(
+                200, json={"tools": [RANKED_TOOL.model_dump()]}
+            )
+        )
+
+        client = SyncAgentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        )
+        result = client.prefetch(
+            messages=[{"role": "user", "content": "weather"}]
+        )
+        assert len(result) == 1
+        assert result[0].score == 0.95
+
+    @respx.mock
+    def test_capture_turn_sync(self):
+        respx.post(f"{TEST_URL}/api/v1/turns").mock(
+            return_value=httpx.Response(201, json={"turn_id": "abc-123"})
+        )
+
+        client = SyncAgentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[TEST_TOOL])
+        )
+        result = client.capture_turn(
+            tools_loaded=["get_weather"], message="What is the weather?"
+        )
+        assert result.turn_id == "abc-123"
+
+    def test_get_frontend_tools_sync(self):
+        frontend_tool = ServerTool(
+            name="confirm",
+            description="Confirm",
+            parameters={},
+            metadata={"location": "frontend"},
+        )
+        client = SyncAgentified(
+            AgentifiedConfig(server_url=TEST_URL, tools=[frontend_tool, TEST_TOOL])
+        )
+        assert client.get_frontend_tool_names() == ["confirm"]

agentified-0.0.3/tests/test_tool.py

@@ -0,0 +1,39 @@
+import json
+
+from agentified.tool import tool
+
+
+def test_converts_definition_to_server_tool_with_fields():
+    result = tool(
+        name="get_weather",
+        description="Get weather for a city",
+        parameters={
+            "type": "object",
+            "properties": {"city": {"type": "string"}},
+        },
+    )
+
+    assert result.name == "get_weather"
+    assert result.description == "Get weather for a city"
+    assert result.parameters == {
+        "type": "object",
+        "properties": {"city": {"type": "string"}},
+    }
+    assert result.metadata is None
+    assert result.fields is not None
+    assert result.fields.name == "get_weather"
+    assert result.fields.description == "Get weather for a city"
+    assert result.fields.input_schema == json.dumps(
+        {"type": "object", "properties": {"city": {"type": "string"}}}
+    )
+
+
+def test_preserves_metadata_when_provided():
+    result = tool(
+        name="confirm",
+        description="Confirm action",
+        parameters={},
+        metadata={"location": "frontend"},
+    )
+
+    assert result.metadata == {"location": "frontend"}