pydantic-ai-slim 0.4.0__tar.gz → 0.4.2__tar.gz

{pydantic_ai_slim-0.4.0 → pydantic_ai_slim-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.4.0
+Version: 0.4.2
 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
@@ -30,11 +30,11 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.4.0
+Requires-Dist: pydantic-graph==0.4.2
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
-Requires-Dist: fasta2a==0.4.0; extra == 'a2a'
+Requires-Dist: fasta2a>=0.4.1; extra == 'a2a'
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.52.0; extra == 'anthropic'
 Provides-Extra: bedrock
@@ -48,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.4.0; extra == 'evals'
+Requires-Dist: pydantic-evals==0.4.2; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.24.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-0.4.0 → pydantic_ai_slim-0.4.2}/pydantic_ai/__init__.py

@@ -12,7 +12,7 @@ from .exceptions import (
 )
 from .format_prompt import format_as_xml
 from .messages import AudioUrl, BinaryContent, DocumentUrl, ImageUrl, VideoUrl
-from .output import NativeOutput, PromptedOutput, TextOutput, ToolOutput
+from .output import NativeOutput, PromptedOutput, StructuredDict, TextOutput, ToolOutput
 from .tools import RunContext, Tool
 
 __all__ = (
@@ -46,6 +46,7 @@ __all__ = (
     'NativeOutput',
     'PromptedOutput',
     'TextOutput',
+    'StructuredDict',
     # format_prompt
     'format_as_xml',
 )

pydantic_ai_slim-0.4.2/pydantic_ai/_a2a.py

@@ -0,0 +1,304 @@
+from __future__ import annotations, annotations as _annotations
+
+import uuid
+from collections.abc import AsyncIterator, Sequence
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from functools import partial
+from typing import Any, Generic, TypeVar
+
+from pydantic import TypeAdapter
+from typing_extensions import assert_never
+
+from pydantic_ai.messages import (
+    AudioUrl,
+    BinaryContent,
+    DocumentUrl,
+    ImageUrl,
+    ModelMessage,
+    ModelRequest,
+    ModelRequestPart,
+    ModelResponse,
+    ModelResponsePart,
+    TextPart,
+    ThinkingPart,
+    ToolCallPart,
+    UserPromptPart,
+    VideoUrl,
+)
+
+from .agent import Agent, AgentDepsT, OutputDataT
+
+# AgentWorker output type needs to be invariant for use in both parameter and return positions
+WorkerOutputT = TypeVar('WorkerOutputT')
+
+try:
+    from fasta2a.applications import FastA2A
+    from fasta2a.broker import Broker, InMemoryBroker
+    from fasta2a.schema import (
+        AgentProvider,
+        Artifact,
+        DataPart,
+        Message,
+        Part,
+        Skill,
+        TaskIdParams,
+        TaskSendParams,
+        TextPart as A2ATextPart,
+    )
+    from fasta2a.storage import InMemoryStorage, Storage
+    from fasta2a.worker import Worker
+    from starlette.middleware import Middleware
+    from starlette.routing import Route
+    from starlette.types import ExceptionHandler, Lifespan
+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: AgentProvider | 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[list[ModelMessage]], Generic[WorkerOutputT, AgentDepsT]):
+    """A worker that uses an agent to execute tasks."""
+
+    agent: Agent[AgentDepsT, WorkerOutputT]
+
+    async def run_task(self, params: TaskSendParams) -> None:
+        task = await self.storage.load_task(params['id'])
+        if task is None:
+            raise ValueError(f'Task {params["id"]} not found')  # pragma: no cover
+
+        # TODO(Marcelo): Should we lock `run_task` on the `context_id`?
+        # Ensure this task hasn't been run before
+        if task['status']['state'] != 'submitted':
+            raise ValueError(  # pragma: no cover
+                f'Task {params["id"]} has already been processed (state: {task["status"]["state"]})'
+            )
+
+        await self.storage.update_task(task['id'], state='working')
+
+        # Load context - contains pydantic-ai message history from previous tasks in this conversation
+        message_history = await self.storage.load_context(task['context_id']) or []
+        message_history.extend(self.build_message_history(task.get('history', [])))
+
+        try:
+            result = await self.agent.run(message_history=message_history)  # type: ignore
+
+            await self.storage.update_context(task['context_id'], result.all_messages())
+
+            # Convert new messages to A2A format for task history
+            a2a_messages: list[Message] = []
+
+            for message in result.new_messages():
+                if isinstance(message, ModelRequest):
+                    # Skip user prompts - they're already in task history
+                    continue
+                else:
+                    # Convert response parts to A2A format
+                    a2a_parts = self._response_parts_to_a2a(message.parts)
+                    if a2a_parts:  # Add if there are visible parts (text/thinking)
+                        a2a_messages.append(
+                            Message(role='agent', parts=a2a_parts, kind='message', message_id=str(uuid.uuid4()))
+                        )
+
+            artifacts = self.build_artifacts(result.output)
+        except Exception:
+            await self.storage.update_task(task['id'], state='failed')
+            raise
+        else:
+            await self.storage.update_task(
+                task['id'], state='completed', new_artifacts=artifacts, new_messages=a2a_messages
+            )
+
+    async def cancel_task(self, params: TaskIdParams) -> None:
+        pass
+
+    def build_artifacts(self, result: WorkerOutputT) -> list[Artifact]:
+        """Build artifacts from agent result.
+
+        All agent outputs become artifacts to mark them as durable task outputs.
+        For string results, we use TextPart. For structured data, we use DataPart.
+        Metadata is included to preserve type information.
+        """
+        artifact_id = str(uuid.uuid4())
+        part = self._convert_result_to_part(result)
+        return [Artifact(artifact_id=artifact_id, name='result', parts=[part])]
+
+    def _convert_result_to_part(self, result: WorkerOutputT) -> Part:
+        """Convert agent result to a Part (TextPart or DataPart).
+
+        For string results, returns a TextPart.
+        For structured data, returns a DataPart with properly serialized data.
+        """
+        if isinstance(result, str):
+            return A2ATextPart(kind='text', text=result)
+        else:
+            output_type = type(result)
+            type_adapter = TypeAdapter(output_type)
+            data = type_adapter.dump_python(result, mode='json')
+            json_schema = type_adapter.json_schema(mode='serialization')
+            return DataPart(kind='data', data={'result': data}, metadata={'json_schema': json_schema})
+
+    def build_message_history(self, history: list[Message]) -> list[ModelMessage]:
+        model_messages: list[ModelMessage] = []
+        for message in history:
+            if message['role'] == 'user':
+                model_messages.append(ModelRequest(parts=self._request_parts_from_a2a(message['parts'])))
+            else:
+                model_messages.append(ModelResponse(parts=self._response_parts_from_a2a(message['parts'])))
+        return model_messages
+
+    def _request_parts_from_a2a(self, parts: list[Part]) -> list[ModelRequestPart]:
+        """Convert A2A Part objects to pydantic-ai ModelRequestPart objects.
+
+        This handles the conversion from A2A protocol parts (text, file, data) to
+        pydantic-ai's internal request parts (UserPromptPart with various content types).
+
+        Args:
+            parts: List of A2A Part objects from incoming messages
+
+        Returns:
+            List of ModelRequestPart objects for the pydantic-ai agent
+        """
+        model_parts: list[ModelRequestPart] = []
+        for part in parts:
+            if part['kind'] == 'text':
+                model_parts.append(UserPromptPart(content=part['text']))
+            elif part['kind'] == 'file':
+                file_content = part['file']
+                if 'bytes' in file_content:
+                    data = file_content['bytes'].encode('utf-8')
+                    mime_type = file_content.get('mime_type', 'application/octet-stream')
+                    content = BinaryContent(data=data, media_type=mime_type)
+                    model_parts.append(UserPromptPart(content=[content]))
+                else:
+                    url = file_content['uri']
+                    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'Unsupported file type: {url}')  # pragma: no cover
+                    model_parts.append(UserPromptPart(content=[content]))
+            elif part['kind'] == 'data':
+                raise NotImplementedError('Data parts are not supported yet.')
+            else:
+                assert_never(part)
+        return model_parts
+
+    def _response_parts_from_a2a(self, parts: list[Part]) -> list[ModelResponsePart]:
+        """Convert A2A Part objects to pydantic-ai ModelResponsePart objects.
+
+        This handles the conversion from A2A protocol parts (text, file, data) to
+        pydantic-ai's internal response parts. Currently only supports text parts
+        as agent responses in A2A are expected to be text-based.
+
+        Args:
+            parts: List of A2A Part objects from stored agent messages
+
+        Returns:
+            List of ModelResponsePart objects for message history
+        """
+        model_parts: list[ModelResponsePart] = []
+        for part in parts:
+            if part['kind'] == 'text':
+                model_parts.append(TextPart(content=part['text']))
+            elif part['kind'] == 'file':  # pragma: no cover
+                raise NotImplementedError('File parts are not supported yet.')
+            elif part['kind'] == 'data':  # pragma: no cover
+                raise NotImplementedError('Data parts are not supported yet.')
+            else:  # pragma: no cover
+                assert_never(part)
+        return model_parts
+
+    def _response_parts_to_a2a(self, parts: list[ModelResponsePart]) -> list[Part]:
+        """Convert pydantic-ai ModelResponsePart objects to A2A Part objects.
+
+        This handles the conversion from pydantic-ai's internal response parts to
+        A2A protocol parts. Different part types are handled as follows:
+        - TextPart: Converted directly to A2A TextPart
+        - ThinkingPart: Converted to TextPart with metadata indicating it's thinking
+        - ToolCallPart: Skipped (internal to agent execution)
+
+        Args:
+            parts: List of ModelResponsePart objects from agent response
+
+        Returns:
+            List of A2A Part objects suitable for sending via A2A protocol
+        """
+        a2a_parts: list[Part] = []
+        for part in parts:
+            if isinstance(part, TextPart):
+                a2a_parts.append(A2ATextPart(kind='text', text=part.content))
+            elif isinstance(part, ThinkingPart):
+                # Convert thinking to text with metadata
+                a2a_parts.append(
+                    A2ATextPart(
+                        kind='text',
+                        text=part.content,
+                        metadata={'type': 'thinking', 'thinking_id': part.id, 'signature': part.signature},
+                    )
+                )
+            elif isinstance(part, ToolCallPart):
+                # Skip tool calls - they're internal to agent execution
+                pass
+        return a2a_parts

{pydantic_ai_slim-0.4.0 → pydantic_ai_slim-0.4.2}/pydantic_ai/_output.py

@@ -264,10 +264,16 @@ class OutputSchema(BaseOutputSchema[OutputDataT], ABC):
 
                 output = output.output
 
+            description = description or default_description
+            if strict is None:
+                strict = default_strict
+
+            processor = ObjectOutputProcessor(output=output, description=description, strict=strict)
+
             if name is None:
                 name = default_name
                 if multiple:
-                    name += f'_{output.__name__}'
+                    name += f'_{processor.object_def.name}'
 
             i = 1
             original_name = name
@@ -275,11 +281,6 @@ class OutputSchema(BaseOutputSchema[OutputDataT], ABC):
                 i += 1
                 name = f'{original_name}_{i}'
 
-            description = description or default_description
-            if strict is None:
-                strict = default_strict
-
-            processor = ObjectOutputProcessor(output=output, description=description, strict=strict)
             tools[name] = OutputTool(name=name, processor=processor, multiple=multiple)
 
         return tools
@@ -616,6 +617,9 @@ class ObjectOutputProcessor(BaseOutputProcessor[OutputDataT]):
                 # including `response_data_typed_dict` as a title here doesn't add anything and could confuse the LLM
                 json_schema.pop('title')
 
+        if name is None and (json_schema_title := json_schema.get('title', None)):
+            name = json_schema_title
+
         if json_schema_description := json_schema.pop('description', None):
             if description is None:
                 description = json_schema_description

{pydantic_ai_slim-0.4.0 → pydantic_ai_slim-0.4.2}/pydantic_ai/_utils.py

@@ -60,7 +60,12 @@ def is_model_like(type_: Any) -> bool:
     return (
         isinstance(type_, type)
         and not isinstance(type_, GenericAlias)
-        and (issubclass(type_, BaseModel) or is_dataclass(type_) or is_typeddict(type_))  # pyright: ignore[reportUnknownArgumentType]
+        and (
+            issubclass(type_, BaseModel)
+            or is_dataclass(type_)  # pyright: ignore[reportUnknownArgumentType]
+            or is_typeddict(type_)  # pyright: ignore[reportUnknownArgumentType]
+            or getattr(type_, '__is_model_like__', False)  # pyright: ignore[reportUnknownArgumentType]
+        )
     )
 
 

{pydantic_ai_slim-0.4.0 → pydantic_ai_slim-0.4.2}/pydantic_ai/agent.py

@@ -57,14 +57,14 @@ ModelRequestNode = _agent_graph.ModelRequestNode
 UserPromptNode = _agent_graph.UserPromptNode
 
 if TYPE_CHECKING:
+    from fasta2a.applications import FastA2A
+    from fasta2a.broker import Broker
+    from fasta2a.schema import AgentProvider, Skill
+    from fasta2a.storage import Storage
     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
 
 
@@ -500,7 +500,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
     @overload
     def iter(
         self,
-        user_prompt: str | Sequence[_messages.UserContent] | None,
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         output_type: None = None,
         message_history: list[_messages.ModelMessage] | None = None,
@@ -516,7 +516,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
     @overload
     def iter(
         self,
-        user_prompt: str | Sequence[_messages.UserContent] | None,
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         output_type: OutputSpec[RunOutputDataT],
         message_history: list[_messages.ModelMessage] | None = None,
@@ -533,7 +533,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
     @deprecated('`result_type` is deprecated, use `output_type` instead.')
     def iter(
         self,
-        user_prompt: str | Sequence[_messages.UserContent] | None,
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
         result_type: type[RunOutputDataT],
         message_history: list[_messages.ModelMessage] | None = None,
@@ -674,12 +674,14 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         # typecast reasonable, even though it is possible to violate it with otherwise-type-checked code.
         output_validators = cast(list[_output.OutputValidator[AgentDepsT, RunOutputDataT]], self._output_validators)
 
-        model_settings = merge_model_settings(self.model_settings, model_settings)
+        # Merge model settings in order of precedence: run > agent > model
+        merged_settings = merge_model_settings(model_used.settings, self.model_settings)
+        model_settings = merge_model_settings(merged_settings, model_settings)
         usage_limits = usage_limits or _usage.UsageLimits()
 
         if isinstance(model_used, InstrumentedModel):
-            instrumentation_settings = model_used.settings
-            tracer = model_used.settings.tracer
+            instrumentation_settings = model_used.instrumentation_settings
+            tracer = model_used.instrumentation_settings.tracer
         else:
             instrumentation_settings = None
             tracer = NoOpTracer()
@@ -1764,7 +1766,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         url: str = 'http://localhost:8000',
         version: str = '1.0.0',
         description: str | None = None,
-        provider: Provider | None = None,
+        provider: AgentProvider | None = None,
         skills: list[Skill] | None = None,
         # Starlette
         debug: bool = False,

{pydantic_ai_slim-0.4.0 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/__init__.py

@@ -321,6 +321,27 @@ class Model(ABC):
     """Abstract class for a model."""
 
     _profile: ModelProfileSpec | None = None
+    _settings: ModelSettings | None = None
+
+    def __init__(
+        self,
+        *,
+        settings: ModelSettings | None = None,
+        profile: ModelProfileSpec | None = None,
+    ) -> None:
+        """Initialize the model with optional settings and profile.
+
+        Args:
+            settings: Model-specific settings that will be used as defaults for this model.
+            profile: The model profile to use.
+        """
+        self._settings = settings
+        self._profile = profile
+
+    @property
+    def settings(self) -> ModelSettings | None:
+        """Get the model settings."""
+        return self._settings
 
     @abstractmethod
     async def request(

{pydantic_ai_slim-0.4.0 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/anthropic.py

@@ -127,6 +127,7 @@ class AnthropicModel(Model):
         *,
         provider: Literal['anthropic'] | Provider[AsyncAnthropic] = 'anthropic',
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize an Anthropic model.
 
@@ -136,13 +137,15 @@ class AnthropicModel(Model):
             provider: The provider to use for the Anthropic API. Can be either the string 'anthropic' or an
                 instance of `Provider[AsyncAnthropic]`. If not provided, the other parameters will be used.
             profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
+            settings: Default model settings for this model instance.
         """
         self._model_name = model_name
 
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
-        self._profile = profile or provider.model_profile
+
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
 
     @property
     def base_url(self) -> str:

{pydantic_ai_slim-0.4.0 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/bedrock.py

@@ -202,6 +202,7 @@ class BedrockConverseModel(Model):
         *,
         provider: Literal['bedrock'] | Provider[BaseClient] = 'bedrock',
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize a Bedrock model.
 
@@ -213,13 +214,15 @@ class BedrockConverseModel(Model):
                 'bedrock' or an instance of `Provider[BaseClient]`. If not provided, a new provider will be
                 created using the other parameters.
             profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
+            settings: Model-specific settings that will be used as defaults for this model.
         """
         self._model_name = model_name
 
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = cast('BedrockRuntimeClient', provider.client)
-        self._profile = profile or provider.model_profile
+
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[ToolTypeDef]:
         tools = [self._map_tool_definition(r) for r in model_request_parameters.function_tools]

{pydantic_ai_slim-0.4.0 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/cohere.py

@@ -111,6 +111,7 @@ class CohereModel(Model):
         *,
         provider: Literal['cohere'] | Provider[AsyncClientV2] = 'cohere',
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize an Cohere model.
 
@@ -121,13 +122,15 @@ class CohereModel(Model):
                 'cohere' or an instance of `Provider[AsyncClientV2]`. If not provided, a new provider will be
                 created using the other parameters.
             profile: The model profile to use. Defaults to a profile picked by the provider based on the model name.
+            settings: Model-specific settings that will be used as defaults for this model.
         """
         self._model_name = model_name
 
         if isinstance(provider, str):
             provider = infer_provider(provider)
         self.client = provider.client
-        self._profile = profile or provider.model_profile
+
+        super().__init__(settings=settings, profile=profile or provider.model_profile)
 
     @property
     def base_url(self) -> str:

{pydantic_ai_slim-0.4.0 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/fallback.py

@@ -42,6 +42,7 @@ class FallbackModel(Model):
             fallback_models: The names or instances of the fallback models to use upon failure.
             fallback_on: A callable or tuple of exceptions that should trigger a fallback.
         """
+        super().__init__()
         self.models = [infer_model(default_model), *[infer_model(m) for m in fallback_models]]
 
         if isinstance(fallback_on, tuple):

{pydantic_ai_slim-0.4.0 → pydantic_ai_slim-0.4.2}/pydantic_ai/models/function.py

@@ -52,7 +52,12 @@ class FunctionModel(Model):
 
     @overload
     def __init__(
-        self, function: FunctionDef, *, model_name: str | None = None, profile: ModelProfileSpec | None = None
+        self,
+        function: FunctionDef,
+        *,
+        model_name: str | None = None,
+        profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ) -> None: ...
 
     @overload
@@ -62,6 +67,7 @@ class FunctionModel(Model):
         stream_function: StreamFunctionDef,
         model_name: str | None = None,
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ) -> None: ...
 
     @overload
@@ -72,6 +78,7 @@ class FunctionModel(Model):
         stream_function: StreamFunctionDef,
         model_name: str | None = None,
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ) -> None: ...
 
     def __init__(
@@ -81,6 +88,7 @@ class FunctionModel(Model):
         stream_function: StreamFunctionDef | None = None,
         model_name: str | None = None,
         profile: ModelProfileSpec | None = None,
+        settings: ModelSettings | None = None,
     ):
         """Initialize a `FunctionModel`.
 
@@ -91,16 +99,19 @@ class FunctionModel(Model):
             stream_function: The function to call for streamed requests.
             model_name: The name of the model. If not provided, a name is generated from the function names.
             profile: The model profile to use.
+            settings: Model-specific settings that will be used as defaults for this model.
         """
         if function is None and stream_function is None:
             raise TypeError('Either `function` or `stream_function` must be provided')
+
         self.function = function
         self.stream_function = stream_function
 
         function_name = self.function.__name__ if self.function is not None else ''
         stream_function_name = self.stream_function.__name__ if self.stream_function is not None else ''
         self._model_name = model_name or f'function:{function_name}:{stream_function_name}'
-        self._profile = profile
+
+        super().__init__(settings=settings, profile=profile)
 
     async def request(
         self,