pydantic-ai-slim 0.2.1__tar.gz → 0.2.3__tar.gz

{pydantic_ai_slim-0.2.1 → pydantic_ai_slim-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.2.1
+Version: 0.2.3
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>, Marcelo Trylesinski <marcelotryle@gmail.com>, David Montague <david@pydantic.dev>, Alex Hall <alex@pydantic.dev>
 License-Expression: MIT
@@ -26,12 +26,15 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Requires-Dist: eval-type-backport>=0.2.0
 Requires-Dist: exceptiongroup; python_version < '3.11'
+Requires-Dist: fasta2a==0.2.3
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.2.1
+Requires-Dist: pydantic-graph==0.2.3
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
+Provides-Extra: a2a
+Requires-Dist: fasta2a==0.2.3; extra == 'a2a'
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.49.0; extra == 'anthropic'
 Provides-Extra: bedrock
@@ -45,7 +48,7 @@ Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == '
 Provides-Extra: duckduckgo
 Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.2.1; extra == 'evals'
+Requires-Dist: pydantic-evals==0.2.3; extra == 'evals'
 Provides-Extra: groq
 Requires-Dist: groq>=0.15.0; extra == 'groq'
 Provides-Extra: logfire

pydantic_ai_slim-0.2.3/pydantic_ai/_a2a.py

@@ -0,0 +1,191 @@
+from __future__ import annotations, annotations as _annotations
+
+from collections.abc import AsyncIterator, Sequence
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from functools import partial
+from typing import Any, Generic
+
+from typing_extensions import assert_never
+
+from pydantic_ai.messages import (
+    AudioUrl,
+    BinaryContent,
+    DocumentUrl,
+    ImageUrl,
+    ModelMessage,
+    ModelRequest,
+    ModelRequestPart,
+    ModelResponse,
+    ModelResponsePart,
+    TextPart,
+    UserPromptPart,
+    VideoUrl,
+)
+
+from .agent import Agent, AgentDepsT, OutputDataT
+
+try:
+    from starlette.middleware import Middleware
+    from starlette.routing import Route
+    from starlette.types import ExceptionHandler, Lifespan
+
+    from fasta2a.applications import FastA2A
+    from fasta2a.broker import Broker, InMemoryBroker
+    from fasta2a.schema import (
+        Artifact,
+        Message,
+        Part,
+        Provider,
+        Skill,
+        TaskIdParams,
+        TaskSendParams,
+        TextPart as A2ATextPart,
+    )
+    from fasta2a.storage import InMemoryStorage, Storage
+    from fasta2a.worker import Worker
+except ImportError as _import_error:
+    raise ImportError(
+        'Please install the `fasta2a` package to use `Agent.to_a2a()` method, '
+        'you can use the `a2a` optional group — `pip install "pydantic-ai-slim[a2a]"`'
+    ) from _import_error
+
+
+@asynccontextmanager
+async def worker_lifespan(app: FastA2A, worker: Worker) -> AsyncIterator[None]:
+    """Custom lifespan that runs the worker during application startup.
+
+    This ensures the worker is started and ready to process tasks as soon as the application starts.
+    """
+    async with app.task_manager:
+        async with worker.run():
+            yield
+
+
+def agent_to_a2a(
+    agent: Agent[AgentDepsT, OutputDataT],
+    *,
+    storage: Storage | None = None,
+    broker: Broker | None = None,
+    # Agent card
+    name: str | None = None,
+    url: str = 'http://localhost:8000',
+    version: str = '1.0.0',
+    description: str | None = None,
+    provider: Provider | None = None,
+    skills: list[Skill] | None = None,
+    # Starlette
+    debug: bool = False,
+    routes: Sequence[Route] | None = None,
+    middleware: Sequence[Middleware] | None = None,
+    exception_handlers: dict[Any, ExceptionHandler] | None = None,
+    lifespan: Lifespan[FastA2A] | None = None,
+) -> FastA2A:
+    """Create a FastA2A server from an agent."""
+    storage = storage or InMemoryStorage()
+    broker = broker or InMemoryBroker()
+    worker = AgentWorker(agent=agent, broker=broker, storage=storage)
+
+    lifespan = lifespan or partial(worker_lifespan, worker=worker)
+
+    return FastA2A(
+        storage=storage,
+        broker=broker,
+        name=name or agent.name,
+        url=url,
+        version=version,
+        description=description,
+        provider=provider,
+        skills=skills,
+        debug=debug,
+        routes=routes,
+        middleware=middleware,
+        exception_handlers=exception_handlers,
+        lifespan=lifespan,
+    )
+
+
+@dataclass
+class AgentWorker(Worker, Generic[AgentDepsT, OutputDataT]):
+    """A worker that uses an agent to execute tasks."""
+
+    agent: Agent[AgentDepsT, OutputDataT]
+
+    async def run_task(self, params: TaskSendParams) -> None:
+        task = await self.storage.load_task(params['id'], history_length=params.get('history_length'))
+        assert task is not None, f'Task {params["id"]} not found'
+        assert 'session_id' in task, 'Task must have a session_id'
+
+        await self.storage.update_task(task['id'], state='working')
+
+        # TODO(Marcelo): We need to have a way to communicate when the task is set to `input-required`. Maybe
+        # a custom `output_type` with a `more_info_required` field, or something like that.
+
+        task_history = task.get('history', [])
+        message_history = self.build_message_history(task_history=task_history)
+
+        # TODO(Marcelo): We need to make this more customizable e.g. pass deps.
+        result = await self.agent.run(message_history=message_history)  # type: ignore
+
+        artifacts = self.build_artifacts(result.output)
+        await self.storage.update_task(task['id'], state='completed', artifacts=artifacts)
+
+    async def cancel_task(self, params: TaskIdParams) -> None:
+        pass
+
+    def build_artifacts(self, result: Any) -> list[Artifact]:
+        # TODO(Marcelo): We need to send the json schema of the result on the metadata of the message.
+        return [Artifact(name='result', index=0, parts=[A2ATextPart(type='text', text=str(result))])]
+
+    def build_message_history(self, task_history: list[Message]) -> list[ModelMessage]:
+        model_messages: list[ModelMessage] = []
+        for message in task_history:
+            if message['role'] == 'user':
+                model_messages.append(ModelRequest(parts=self._map_request_parts(message['parts'])))
+            else:
+                model_messages.append(ModelResponse(parts=self._map_response_parts(message['parts'])))
+        return model_messages
+
+    def _map_request_parts(self, parts: list[Part]) -> list[ModelRequestPart]:
+        model_parts: list[ModelRequestPart] = []
+        for part in parts:
+            if part['type'] == 'text':
+                model_parts.append(UserPromptPart(content=part['text']))
+            elif part['type'] == 'file':
+                file = part['file']
+                if 'data' in file:
+                    data = file['data'].encode('utf-8')
+                    content = BinaryContent(data=data, media_type=file['mime_type'])
+                    model_parts.append(UserPromptPart(content=[content]))
+                else:
+                    url = file['url']
+                    for url_cls in (DocumentUrl, AudioUrl, ImageUrl, VideoUrl):
+                        content = url_cls(url=url)
+                        try:
+                            content.media_type
+                        except ValueError:  # pragma: no cover
+                            continue
+                        else:
+                            break
+                    else:
+                        raise ValueError(f'Unknown file type: {file["mime_type"]}')  # pragma: no cover
+                    model_parts.append(UserPromptPart(content=[content]))
+            elif part['type'] == 'data':
+                # TODO(Marcelo): Maybe we should use this for `ToolReturnPart`, and `RetryPromptPart`.
+                raise NotImplementedError('Data parts are not supported yet.')
+            else:
+                assert_never(part)
+        return model_parts
+
+    def _map_response_parts(self, parts: list[Part]) -> list[ModelResponsePart]:
+        model_parts: list[ModelResponsePart] = []
+        for part in parts:
+            if part['type'] == 'text':
+                model_parts.append(TextPart(content=part['text']))
+            elif part['type'] == 'file':  # pragma: no cover
+                raise NotImplementedError('File parts are not supported yet.')
+            elif part['type'] == 'data':  # pragma: no cover
+                raise NotImplementedError('Data parts are not supported yet.')
+            else:  # pragma: no cover
+                assert_never(part)
+        return model_parts

{pydantic_ai_slim-0.2.1 → pydantic_ai_slim-0.2.3}/pydantic_ai/_cli.py

@@ -2,6 +2,8 @@ from __future__ import annotations as _annotations
 
 import argparse
 import asyncio
+import importlib
+import os
 import sys
 from asyncio import CancelledError
 from collections.abc import Sequence
@@ -12,6 +14,9 @@ from typing import Any, cast
 
 from typing_inspection.introspection import get_literal_values
 
+from pydantic_ai.result import OutputDataT
+from pydantic_ai.tools import AgentDepsT
+
 from . import __version__
 from .agent import Agent
 from .exceptions import UserError
@@ -123,6 +128,11 @@ Special prompts:
     # e.g. we want to show `openai:gpt-4o` but not `gpt-4o`
     qualified_model_names = [n for n in get_literal_values(KnownModelName.__value__) if ':' in n]
     arg.completer = argcomplete.ChoicesCompleter(qualified_model_names)  # type: ignore[reportPrivateUsage]
+    parser.add_argument(
+        '-a',
+        '--agent',
+        help='Custom Agent to use, in format "module:variable", e.g. "mymodule.submodule:my_agent"',
+    )
     parser.add_argument(
         '-l',
         '--list-models',
@@ -155,8 +165,25 @@ Special prompts:
             console.print(f'  {model}', highlight=False)
         return 0
 
+    agent: Agent[None, str] = cli_agent
+    if args.agent:
+        try:
+            current_path = os.getcwd()
+            sys.path.append(current_path)
+
+            module_path, variable_name = args.agent.split(':')
+            module = importlib.import_module(module_path)
+            agent = getattr(module, variable_name)
+            if not isinstance(agent, Agent):
+                console.print(f'[red]Error: {args.agent} is not an Agent instance[/red]')
+                return 1
+            console.print(f'[green]Using custom agent:[/green] [magenta]{args.agent}[/magenta]', highlight=False)
+        except ValueError:
+            console.print('[red]Error: Agent must be specified in "module:variable" format[/red]')
+            return 1
+
     try:
-        cli_agent.model = infer_model(args.model)
+        agent.model = infer_model(args.model)
     except UserError as e:
         console.print(f'Error initializing [magenta]{args.model}[/magenta]:\n[red]{e}[/red]')
         return 1
@@ -171,21 +198,31 @@ Special prompts:
 
     if prompt := cast(str, args.prompt):
         try:
-            asyncio.run(ask_agent(cli_agent, prompt, stream, console, code_theme))
+            asyncio.run(ask_agent(agent, prompt, stream, console, code_theme))
         except KeyboardInterrupt:
             pass
         return 0
 
+    # Ensure the history directory and file exist
+    PROMPT_HISTORY_PATH.parent.mkdir(parents=True, exist_ok=True)
+    PROMPT_HISTORY_PATH.touch(exist_ok=True)
+
     # doing this instead of `PromptSession[Any](history=` allows mocking of PromptSession in tests
     session: PromptSession[Any] = PromptSession(history=FileHistory(str(PROMPT_HISTORY_PATH)))
     try:
-        return asyncio.run(run_chat(session, stream, cli_agent, console, code_theme, prog_name))
+        return asyncio.run(run_chat(session, stream, agent, console, code_theme, prog_name))
     except KeyboardInterrupt:  # pragma: no cover
         return 0
 
 
 async def run_chat(
-    session: PromptSession[Any], stream: bool, agent: Agent, console: Console, code_theme: str, prog_name: str
+    session: PromptSession[Any],
+    stream: bool,
+    agent: Agent[AgentDepsT, OutputDataT],
+    console: Console,
+    code_theme: str,
+    prog_name: str,
+    deps: AgentDepsT = None,
 ) -> int:
     multiline = False
     messages: list[ModelMessage] = []
@@ -207,30 +244,31 @@ async def run_chat(
                 return exit_value
         else:
             try:
-                messages = await ask_agent(agent, text, stream, console, code_theme, messages)
+                messages = await ask_agent(agent, text, stream, console, code_theme, deps, messages)
             except CancelledError:  # pragma: no cover
                 console.print('[dim]Interrupted[/dim]')
 
 
 async def ask_agent(
-    agent: Agent,
+    agent: Agent[AgentDepsT, OutputDataT],
     prompt: str,
     stream: bool,
     console: Console,
     code_theme: str,
+    deps: AgentDepsT = None,
     messages: list[ModelMessage] | None = None,
 ) -> list[ModelMessage]:
     status = Status('[dim]Working on it…[/dim]', console=console)
 
     if not stream:
         with status:
-            result = await agent.run(prompt, message_history=messages)
-        content = result.output
+            result = await agent.run(prompt, message_history=messages, deps=deps)
+        content = str(result.output)
         console.print(Markdown(content, code_theme=code_theme))
         return result.all_messages()
 
     with status, ExitStack() as stack:
-        async with agent.iter(prompt, message_history=messages) as agent_run:
+        async with agent.iter(prompt, message_history=messages, deps=deps) as agent_run:
             live = Live('', refresh_per_second=15, console=console, vertical_overflow='ellipsis')
             async for node in agent_run:
                 if Agent.is_model_request_node(node):

{pydantic_ai_slim-0.2.1 → pydantic_ai_slim-0.2.3}/pydantic_ai/agent.py

@@ -12,7 +12,7 @@ from typing import TYPE_CHECKING, Any, Callable, ClassVar, Generic, cast, final,
 
 from opentelemetry.trace import NoOpTracer, use_span
 from pydantic.json_schema import GenerateJsonSchema
-from typing_extensions import Literal, Never, TypeIs, TypeVar, deprecated
+from typing_extensions import Literal, Never, Self, TypeIs, TypeVar, deprecated
 
 from pydantic_graph import End, Graph, GraphRun, GraphRunContext
 from pydantic_graph._utils import get_event_loop
@@ -28,7 +28,7 @@ from . import (
     result,
     usage as _usage,
 )
-from .models.instrumented import InstrumentationSettings, InstrumentedModel
+from .models.instrumented import InstrumentationSettings, InstrumentedModel, instrument_model
 from .result import FinalResult, OutputDataT, StreamedRunResult, ToolOutput
 from .settings import ModelSettings, merge_model_settings
 from .tools import (
@@ -52,6 +52,14 @@ ModelRequestNode = _agent_graph.ModelRequestNode
 UserPromptNode = _agent_graph.UserPromptNode
 
 if TYPE_CHECKING:
+    from starlette.middleware import Middleware
+    from starlette.routing import Route
+    from starlette.types import ExceptionHandler, Lifespan
+
+    from fasta2a.applications import FastA2A
+    from fasta2a.broker import Broker
+    from fasta2a.schema import Provider, Skill
+    from fasta2a.storage import Storage
     from pydantic_ai.mcp import MCPServer
 
 
@@ -100,7 +108,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
     model: models.Model | models.KnownModelName | str | None
     """The default model configured for this agent.
 
-    We allow str here since the actual list of allowed models changes frequently.
+    We allow `str` here since the actual list of allowed models changes frequently.
     """
 
     name: str | None
@@ -225,7 +233,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
 
         Args:
             model: The default model to use for this agent, if not provide,
-                you must provide the model when calling it. We allow str here since the actual list of allowed models changes frequently.
+                you must provide the model when calling it. We allow `str` here since the actual list of allowed models changes frequently.
             output_type: The type of the output data, used to validate the data returned by the model,
                 defaults to `str`.
             instructions: Instructions to use for this agent, you can also register instructions via a function with
@@ -1574,13 +1582,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         if instrument is None:
             instrument = self._instrument_default
 
-        if instrument and not isinstance(model_, InstrumentedModel):
-            if instrument is True:
-                instrument = InstrumentationSettings()
-
-            model_ = InstrumentedModel(model_, instrument)
-
-        return model_
+        return instrument_model(model_, instrument)
 
     def _get_deps(self: Agent[T, OutputDataT], deps: T) -> T:
         """Get deps for a run.
@@ -1688,6 +1690,107 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         finally:
             await exit_stack.aclose()
 
+    def to_a2a(
+        self,
+        *,
+        storage: Storage | None = None,
+        broker: Broker | None = None,
+        # Agent card
+        name: str | None = None,
+        url: str = 'http://localhost:8000',
+        version: str = '1.0.0',
+        description: str | None = None,
+        provider: Provider | None = None,
+        skills: list[Skill] | None = None,
+        # Starlette
+        debug: bool = False,
+        routes: Sequence[Route] | None = None,
+        middleware: Sequence[Middleware] | None = None,
+        exception_handlers: dict[Any, ExceptionHandler] | None = None,
+        lifespan: Lifespan[FastA2A] | None = None,
+    ) -> FastA2A:
+        """Convert the agent to a FastA2A application.
+
+        Example:
+        ```python
+        from pydantic_ai import Agent
+
+        agent = Agent('openai:gpt-4o')
+        app = agent.to_a2a()
+        ```
+
+        The `app` is an ASGI application that can be used with any ASGI server.
+
+        To run the application, you can use the following command:
+
+        ```bash
+        uvicorn app:app --host 0.0.0.0 --port 8000
+        ```
+        """
+        from ._a2a import agent_to_a2a
+
+        return agent_to_a2a(
+            self,
+            storage=storage,
+            broker=broker,
+            name=name,
+            url=url,
+            version=version,
+            description=description,
+            provider=provider,
+            skills=skills,
+            debug=debug,
+            routes=routes,
+            middleware=middleware,
+            exception_handlers=exception_handlers,
+            lifespan=lifespan,
+        )
+
+    async def to_cli(self: Self, deps: AgentDepsT = None) -> None:
+        """Run the agent in a CLI chat interface.
+
+        Example:
+        ```python {title="agent_to_cli.py" test="skip"}
+        from pydantic_ai import Agent
+
+        agent = Agent('openai:gpt-4o', instructions='You always respond in Italian.')
+
+        async def main():
+            await agent.to_cli()
+        ```
+        """
+        from prompt_toolkit import PromptSession
+        from prompt_toolkit.history import FileHistory
+        from rich.console import Console
+
+        from pydantic_ai._cli import PROMPT_HISTORY_PATH, run_chat
+
+        # TODO(Marcelo): We need to refactor the CLI code to be able to be able to just pass `agent`, `deps` and
+        # `prog_name` from here.
+
+        session: PromptSession[Any] = PromptSession(history=FileHistory(str(PROMPT_HISTORY_PATH)))
+        await run_chat(
+            session=session,
+            stream=True,
+            agent=self,
+            deps=deps,
+            console=Console(),
+            code_theme='monokai',
+            prog_name='pydantic-ai',
+        )
+
+    def to_cli_sync(self: Self, deps: AgentDepsT = None) -> None:
+        """Run the agent in a CLI chat interface with the non-async interface.
+
+        ```python {title="agent_to_cli_sync.py" test="skip"}
+        from pydantic_ai import Agent
+
+        agent = Agent('openai:gpt-4o', instructions='You always respond in Italian.')
+        agent.to_cli_sync()
+        ```
+        """
+        return get_event_loop().run_until_complete(self.to_cli(deps=deps))
+
 
 @dataclasses.dataclass(repr=False)
 class AgentRun(Generic[AgentDepsT, OutputDataT]):

pydantic_ai_slim-0.2.3/pydantic_ai/direct.py

@@ -0,0 +1,215 @@
+"""Methods for making imperative requests to language models with minimal abstraction.
+
+These methods allow you to make requests to LLMs where the only abstraction is input and output schema
+translation so you can use all models with the same API.
+
+These methods are thin wrappers around [`Model`][pydantic_ai.models.Model] implementations.
+"""
+
+from __future__ import annotations as _annotations
+
+from contextlib import AbstractAsyncContextManager
+
+from pydantic_graph._utils import get_event_loop as _get_event_loop
+
+from . import agent, messages, models, settings
+from .models import instrumented as instrumented_models
+
+__all__ = 'model_request', 'model_request_sync', 'model_request_stream'
+
+
+async def model_request(
+    model: models.Model | models.KnownModelName | str,
+    messages: list[messages.ModelMessage],
+    *,
+    model_settings: settings.ModelSettings | None = None,
+    model_request_parameters: models.ModelRequestParameters | None = None,
+    instrument: instrumented_models.InstrumentationSettings | bool | None = None,
+) -> messages.ModelResponse:
+    """Make a non-streamed request to a model.
+
+    ```py title="model_request_example.py"
+    from pydantic_ai.direct import model_request
+    from pydantic_ai.messages import ModelRequest
+
+
+    async def main():
+        model_response = await model_request(
+            'anthropic:claude-3-5-haiku-latest',
+            [ModelRequest.user_text_prompt('What is the capital of France?')]  # (1)!
+        )
+        print(model_response)
+        '''
+        ModelResponse(
+            parts=[TextPart(content='Paris', part_kind='text')],
+            usage=Usage(
+                requests=1,
+                request_tokens=56,
+                response_tokens=1,
+                total_tokens=57,
+                details=None,
+            ),
+            model_name='claude-3-5-haiku-latest',
+            timestamp=datetime.datetime(...),
+            kind='response',
+        )
+        '''
+    ```
+
+    1. See [`ModelRequest.user_text_prompt`][pydantic_ai.messages.ModelRequest.user_text_prompt] for details.
+
+    Args:
+        model: The model to make a request to. We allow `str` here since the actual list of allowed models changes frequently.
+        messages: Messages to send to the model
+        model_settings: optional model settings
+        model_request_parameters: optional model request parameters
+        instrument: Whether to instrument the request with OpenTelemetry/Logfire, if `None` the value from
+            [`logfire.instrument_pydantic_ai`][logfire.Logfire.instrument_pydantic_ai] is used.
+
+    Returns:
+        The model response and token usage associated with the request.
+    """
+    model_instance = _prepare_model(model, instrument)
+    return await model_instance.request(
+        messages,
+        model_settings,
+        model_instance.customize_request_parameters(model_request_parameters or models.ModelRequestParameters()),
+    )
+
+
+def model_request_sync(
+    model: models.Model | models.KnownModelName | str,
+    messages: list[messages.ModelMessage],
+    *,
+    model_settings: settings.ModelSettings | None = None,
+    model_request_parameters: models.ModelRequestParameters | None = None,
+    instrument: instrumented_models.InstrumentationSettings | bool | None = None,
+) -> messages.ModelResponse:
+    """Make a Synchronous, non-streamed request to a model.
+
+    This is a convenience method that wraps [`model_request`][pydantic_ai.direct.model_request] with
+    `loop.run_until_complete(...)`. You therefore can't use this method inside async code or if there's an active event loop.
+
+    ```py title="model_request_sync_example.py"
+    from pydantic_ai.direct import model_request_sync
+    from pydantic_ai.messages import ModelRequest
+
+    model_response = model_request_sync(
+        'anthropic:claude-3-5-haiku-latest',
+        [ModelRequest.user_text_prompt('What is the capital of France?')]  # (1)!
+    )
+    print(model_response)
+    '''
+    ModelResponse(
+        parts=[TextPart(content='Paris', part_kind='text')],
+        usage=Usage(
+            requests=1, request_tokens=56, response_tokens=1, total_tokens=57, details=None
+        ),
+        model_name='claude-3-5-haiku-latest',
+        timestamp=datetime.datetime(...),
+        kind='response',
+    )
+    '''
+    ```
+
+    1. See [`ModelRequest.user_text_prompt`][pydantic_ai.messages.ModelRequest.user_text_prompt] for details.
+
+    Args:
+        model: The model to make a request to. We allow `str` here since the actual list of allowed models changes frequently.
+        messages: Messages to send to the model
+        model_settings: optional model settings
+        model_request_parameters: optional model request parameters
+        instrument: Whether to instrument the request with OpenTelemetry/Logfire, if `None` the value from
+            [`logfire.instrument_pydantic_ai`][logfire.Logfire.instrument_pydantic_ai] is used.
+
+    Returns:
+        The model response and token usage associated with the request.
+    """
+    return _get_event_loop().run_until_complete(
+        model_request(
+            model,
+            messages,
+            model_settings=model_settings,
+            model_request_parameters=model_request_parameters,
+            instrument=instrument,
+        )
+    )
+
+
+def model_request_stream(
+    model: models.Model | models.KnownModelName | str,
+    messages: list[messages.ModelMessage],
+    *,
+    model_settings: settings.ModelSettings | None = None,
+    model_request_parameters: models.ModelRequestParameters | None = None,
+    instrument: instrumented_models.InstrumentationSettings | bool | None = None,
+) -> AbstractAsyncContextManager[models.StreamedResponse]:
+    """Make a streamed async request to a model.
+
+    ```py {title="model_request_stream_example.py"}
+
+    from pydantic_ai.direct import model_request_stream
+    from pydantic_ai.messages import ModelRequest
+
+
+    async def main():
+        messages = [ModelRequest.user_text_prompt('Who was Albert Einstein?')]  # (1)!
+        async with model_request_stream( 'openai:gpt-4.1-mini', messages) as stream:
+            chunks = []
+            async for chunk in stream:
+                chunks.append(chunk)
+            print(chunks)
+            '''
+            [
+                PartStartEvent(
+                    index=0,
+                    part=TextPart(content='Albert Einstein was ', part_kind='text'),
+                    event_kind='part_start',
+                ),
+                PartDeltaEvent(
+                    index=0,
+                    delta=TextPartDelta(
+                        content_delta='a German-born theoretical ', part_delta_kind='text'
+                    ),
+                    event_kind='part_delta',
+                ),
+                PartDeltaEvent(
+                    index=0,
+                    delta=TextPartDelta(content_delta='physicist.', part_delta_kind='text'),
+                    event_kind='part_delta',
+                ),
+            ]
+            '''
+    ```
+
+    1. See [`ModelRequest.user_text_prompt`][pydantic_ai.messages.ModelRequest.user_text_prompt] for details.
+
+    Args:
+        model: The model to make a request to. We allow `str` here since the actual list of allowed models changes frequently.
+        messages: Messages to send to the model
+        model_settings: optional model settings
+        model_request_parameters: optional model request parameters
+        instrument: Whether to instrument the request with OpenTelemetry/Logfire, if `None` the value from
+            [`logfire.instrument_pydantic_ai`][logfire.Logfire.instrument_pydantic_ai] is used.
+
+    Returns:
+        A [stream response][pydantic_ai.models.StreamedResponse] async context manager.
+    """
+    model_instance = _prepare_model(model, instrument)
+    return model_instance.request_stream(
+        messages,
+        model_settings,
+        model_instance.customize_request_parameters(model_request_parameters or models.ModelRequestParameters()),
+    )
+
+
+def _prepare_model(
+    model: models.Model | models.KnownModelName | str,
+    instrument: instrumented_models.InstrumentationSettings | bool | None,
+) -> models.Model:
+    model_instance = models.infer_model(model)
+
+    if instrument is None:
+        instrument = agent.Agent._instrument_default  # pyright: ignore[reportPrivateUsage]
+
+    return instrumented_models.instrument_model(model_instance, instrument)

{pydantic_ai_slim-0.2.1 → pydantic_ai_slim-0.2.3}/pydantic_ai/messages.py

@@ -83,7 +83,7 @@ class VideoUrl:
     """Type identifier, this is available on all parts as a discriminator."""
 
     @property
-    def media_type(self) -> VideoMediaType:  # pragma: lax no cover
+    def media_type(self) -> VideoMediaType:
         """Return the media type of the video, based on the url."""
         if self.url.endswith('.mkv'):
             return 'video/x-matroska'
@@ -110,7 +110,7 @@ class VideoUrl:
 
         The choice of supported formats were based on the Bedrock Converse API. Other APIs don't require to use a format.
         """
-        return _video_format(self.media_type)
+        return _video_format_lookup[self.media_type]
 
 
 @dataclass
@@ -133,6 +133,11 @@ class AudioUrl:
         else:
             raise ValueError(f'Unknown audio file extension: {self.url}')
 
+    @property
+    def format(self) -> AudioFormat:
+        """The file format of the audio file."""
+        return _audio_format_lookup[self.media_type]
+
 
 @dataclass
 class ImageUrl:
@@ -164,7 +169,7 @@ class ImageUrl:
 
         The choice of supported formats were based on the Bedrock Converse API. Other APIs don't require to use a format.
         """
-        return _image_format(self.media_type)
+        return _image_format_lookup[self.media_type]
 
 
 @dataclass
@@ -182,7 +187,7 @@ class DocumentUrl:
         """Return the media type of the document, based on the url."""
         type_, _ = guess_type(self.url)
         if type_ is None:
-            raise RuntimeError(f'Unknown document file extension: {self.url}')
+            raise ValueError(f'Unknown document file extension: {self.url}')
         return type_
 
     @property
@@ -191,7 +196,11 @@ class DocumentUrl:
 
         The choice of supported formats were based on the Bedrock Converse API. Other APIs don't require to use a format.
         """
-        return _document_format(self.media_type)
+        media_type = self.media_type
+        try:
+            return _document_format_lookup[media_type]
+        except KeyError as e:
+            raise ValueError(f'Unknown document media type: {media_type}') from e
 
 
 @dataclass
@@ -225,93 +234,58 @@ class BinaryContent:
     @property
     def is_document(self) -> bool:
         """Return `True` if the media type is a document type."""
-        return self.media_type in {
-            'application/pdf',
-            'text/plain',
-            'text/csv',
-            'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-            'text/html',
-            'text/markdown',
-            'application/vnd.ms-excel',
-        }
+        return self.media_type in _document_format_lookup
 
     @property
     def format(self) -> str:
         """The file format of the binary content."""
-        if self.is_audio:
-            if self.media_type == 'audio/mpeg':
-                return 'mp3'
-            elif self.media_type == 'audio/wav':
-                return 'wav'
-        elif self.is_image:
-            return _image_format(self.media_type)
-        elif self.is_document:
-            return _document_format(self.media_type)
-        elif self.is_video:
-            return _video_format(self.media_type)
-        raise ValueError(f'Unknown media type: {self.media_type}')
+        try:
+            if self.is_audio:
+                return _audio_format_lookup[self.media_type]
+            elif self.is_image:
+                return _image_format_lookup[self.media_type]
+            elif self.is_video:
+                return _video_format_lookup[self.media_type]
+            else:
+                return _document_format_lookup[self.media_type]
+        except KeyError as e:
+            raise ValueError(f'Unknown media type: {self.media_type}') from e
 
 
 UserContent: TypeAlias = 'str | ImageUrl | AudioUrl | DocumentUrl | VideoUrl | BinaryContent'
 
 # Ideally this would be a Union of types, but Python 3.9 requires it to be a string, and strings don't work with `isinstance``.
 MultiModalContentTypes = (ImageUrl, AudioUrl, DocumentUrl, VideoUrl, BinaryContent)
-
-
-def _document_format(media_type: str) -> DocumentFormat:
-    if media_type == 'application/pdf':
-        return 'pdf'
-    elif media_type == 'text/plain':
-        return 'txt'
-    elif media_type == 'text/csv':
-        return 'csv'
-    elif media_type == 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
-        return 'docx'
-    elif media_type == 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet':
-        return 'xlsx'
-    elif media_type == 'text/html':
-        return 'html'
-    elif media_type == 'text/markdown':
-        return 'md'
-    elif media_type == 'application/vnd.ms-excel':
-        return 'xls'
-    else:
-        raise ValueError(f'Unknown document media type: {media_type}')
-
-
-def _image_format(media_type: str) -> ImageFormat:
-    if media_type == 'image/jpeg':
-        return 'jpeg'
-    elif media_type == 'image/png':
-        return 'png'
-    elif media_type == 'image/gif':
-        return 'gif'
-    elif media_type == 'image/webp':
-        return 'webp'
-    else:
-        raise ValueError(f'Unknown image media type: {media_type}')
-
-
-def _video_format(media_type: str) -> VideoFormat:
-    if media_type == 'video/x-matroska':
-        return 'mkv'
-    elif media_type == 'video/quicktime':
-        return 'mov'
-    elif media_type == 'video/mp4':
-        return 'mp4'
-    elif media_type == 'video/webm':
-        return 'webm'
-    elif media_type == 'video/x-flv':
-        return 'flv'
-    elif media_type == 'video/mpeg':
-        return 'mpeg'
-    elif media_type == 'video/x-ms-wmv':
-        return 'wmv'
-    elif media_type == 'video/3gpp':
-        return 'three_gp'
-    else:  # pragma: no cover
-        raise ValueError(f'Unknown video media type: {media_type}')
+_document_format_lookup: dict[str, DocumentFormat] = {
+    'application/pdf': 'pdf',
+    'text/plain': 'txt',
+    'text/csv': 'csv',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
+    'text/html': 'html',
+    'text/markdown': 'md',
+    'application/vnd.ms-excel': 'xls',
+}
+_audio_format_lookup: dict[str, AudioFormat] = {
+    'audio/mpeg': 'mp3',
+    'audio/wav': 'wav',
+}
+_image_format_lookup: dict[str, ImageFormat] = {
+    'image/jpeg': 'jpeg',
+    'image/png': 'png',
+    'image/gif': 'gif',
+    'image/webp': 'webp',
+}
+_video_format_lookup: dict[str, VideoFormat] = {
+    'video/x-matroska': 'mkv',
+    'video/quicktime': 'mov',
+    'video/mp4': 'mp4',
+    'video/webm': 'webm',
+    'video/x-flv': 'flv',
+    'video/mpeg': 'mpeg',
+    'video/x-ms-wmv': 'wmv',
+    'video/3gpp': 'three_gp',
+}
 
 
 @dataclass
@@ -478,6 +452,11 @@ class ModelRequest:
     kind: Literal['request'] = 'request'
     """Message type identifier, this is available on all parts as a discriminator."""
 
+    @classmethod
+    def user_text_prompt(cls, user_prompt: str, *, instructions: str | None = None) -> ModelRequest:
+        """Create a `ModelRequest` with a single user prompt as text."""
+        return cls(parts=[UserPromptPart(user_prompt)], instructions=instructions)
+
 
 @dataclass
 class TextPart:

{pydantic_ai_slim-0.2.1 → pydantic_ai_slim-0.2.3}/pydantic_ai/models/__init__.py

@@ -260,9 +260,9 @@ KnownModelName = TypeAliasType(
 class ModelRequestParameters:
     """Configuration for an agent's request to a model, specifically related to tools and output handling."""
 
-    function_tools: list[ToolDefinition]
-    allow_text_output: bool
-    output_tools: list[ToolDefinition]
+    function_tools: list[ToolDefinition] = field(default_factory=list)
+    allow_text_output: bool = True
+    output_tools: list[ToolDefinition] = field(default_factory=list)
 
 
 class Model(ABC):

{pydantic_ai_slim-0.2.1 → pydantic_ai_slim-0.2.3}/pydantic_ai/models/instrumented.py

@@ -26,6 +26,8 @@ from ..settings import ModelSettings
 from . import KnownModelName, Model, ModelRequestParameters, StreamedResponse
 from .wrapper import WrapperModel
 
+__all__ = 'instrument_model', 'InstrumentationSettings', 'InstrumentedModel'
+
 MODEL_SETTING_ATTRIBUTES: tuple[
     Literal[
         'max_tokens',
@@ -48,6 +50,17 @@ MODEL_SETTING_ATTRIBUTES: tuple[
 ANY_ADAPTER = TypeAdapter[Any](Any)
 
 
+def instrument_model(model: Model, instrument: InstrumentationSettings | bool) -> Model:
+    """Instrument a model with OpenTelemetry/logfire."""
+    if instrument and not isinstance(model, InstrumentedModel):
+        if instrument is True:
+            instrument = InstrumentationSettings()
+
+        model = InstrumentedModel(model, instrument)
+
+    return model
+
+
 @dataclass(init=False)
 class InstrumentationSettings:
     """Options for instrumenting models and agents with OpenTelemetry.

{pydantic_ai_slim-0.2.1 → pydantic_ai_slim-0.2.3}/pydantic_ai/models/test.py

@@ -150,7 +150,7 @@ class TestModel(Model):
         elif model_request_parameters.output_tools:
             return _WrappedToolOutput(None)
         else:
-            return _WrappedTextOutput(None)  # pragma: no cover
+            return _WrappedTextOutput(None)
 
     def _request(
         self,

{pydantic_ai_slim-0.2.1 → pydantic_ai_slim-0.2.3}/pyproject.toml

@@ -50,6 +50,7 @@ dependencies = [
     "eval-type-backport>=0.2.0",
     "griffe>=1.3.2",
     "httpx>=0.27",
+    "fasta2a=={{ version }}",
     "pydantic>=2.10",
     "pydantic-graph=={{ version }}",
     "exceptiongroup; python_version < '3.11'",
@@ -77,10 +78,13 @@ cli = ["rich>=13", "prompt-toolkit>=3", "argcomplete>=3.5.0"]
 mcp = ["mcp>=1.6.0; python_version >= '3.10'"]
 # Evals
 evals = ["pydantic-evals=={{ version }}"]
+# A2A
+a2a = ["fasta2a=={{ version }}"]
 
 [dependency-groups]
 dev = [
     "anyio>=4.5.0",
+    "asgi-lifespan>=2.1.0",
     "devtools>=0.12.2",
     "coverage[toml]>=7.6.2",
     "dirty-equals>=0.9.0",