pyagentic-core 2.10.1.dev2__py3-none-any.whl → 2.11.1.dev1__py3-none-any.whl

pyagentic/__init__.py

@@ -30,6 +30,7 @@ Main Components:
     - tool: Decorator for marking methods as LLM-callable tools
     - State: Type annotation for persistent state fields
     - Link: Type annotation for linking agents together
+    - Depends: Type annotation for dependency-injected agent fields
     - spec: Configuration factory for state, params, and agent links
     - ref: Dynamic state reference system for tool parameters
     - AgentExtension: Base class for creating reusable agent mixins
@@ -42,6 +43,17 @@ from pyagentic._base._mcp import MCPLink
 from pyagentic._base._tool import tool
 
 from pyagentic._base._state import State
+from pyagentic._base._depends import Depends
 from pyagentic._base._ref import ref
 
-__all__ = ["BaseAgent", "AgentExtension", "tool", "spec", "State", "Link", "MCPLink", "ref"]
+__all__ = [
+    "BaseAgent",
+    "AgentExtension",
+    "tool",
+    "spec",
+    "State",
+    "Link",
+    "Depends",
+    "MCPLink",
+    "ref",
+]

pyagentic/_base/_agent/_agent.py

@@ -163,6 +163,7 @@ class BaseAgent(metaclass=AgentMeta):
     __state_defs__: ClassVar[dict[str, _StateDefinition]]  # State field definitions
     __linked_agents__: ClassVar[dict[str, "_LinkedAgentDefinition"]]  # Linked agent definitions
     __mcp_defs__: ClassVar[dict[str, "_MCPDefinition"]]  # MCP server definitions
+    __dependencies__: ClassVar[dict[str, type]]  # Depends[T] field -> dependency type
 
     # User-set Class Attributes (defined in subclass)
     __system_message__: ClassVar[str]  # Required: system prompt for the agent
@@ -173,6 +174,7 @@ class BaseAgent(metaclass=AgentMeta):
 
     # Generated Class Attributes (built by metaclass)
     __request_model__: ClassVar[Type[BaseModel]] = None  # Pydantic request model from __call__
+    __construct_model__: ClassVar[Type[BaseModel]] = None  # Recursive constructor model
     __response_model__: ClassVar[Type[AgentResponse]] = None  # Pydantic response model
     __stream_event_model__: ClassVar[Type[BaseModel]] = None  # Typed SSE stream event union
     __state_class__: ClassVar[Type[_AgentState]] = None  # Generated state class

pyagentic/_base/_depends.py

@@ -0,0 +1,59 @@
+from typing import TypeVar, Generic
+
+T = TypeVar("T")
+
+
+class Depends(Generic[T]):
+    """
+    Type annotation for declaring a dependency-injected agent field.
+
+    ``Depends`` marks a field as a server-supplied dependency rather than
+    serializable per-session state. Use it in an agent's class body wherever you
+    would otherwise use :class:`State`, for resources that cannot (or should not)
+    travel over the wire — database handles, HTTP clients, pre-configured
+    providers, and similar.
+
+    Unlike ``State`` and ``Link``, a ``Depends`` field is **excluded** from the
+    agent's generated construct model: clients never provide it. Instead it is
+    supplied once by the developer at :func:`pyagentic.api.create_router` /
+    :func:`pyagentic.api.create_app` via the ``dependencies`` argument, and
+    resolved by type across the (possibly nested) agent tree.
+
+    Args:
+        T: The dependency type. Used both as the field's type hint and as the key
+            for by-type resolution at serve time.
+
+    Example:
+        ```python
+        from pyagentic import BaseAgent, State, Depends
+
+        class ResearchAgent(BaseAgent):
+            __system_message__ = "You research topics"
+
+            topic: State[TopicState]      # client-provided per session
+            db:    Depends[Database]      # injected by the developer, by type
+
+            @tool("Look up a record")
+            def lookup(self, key: str) -> str:
+                return self.db.get(key)
+        ```
+    """
+
+    def __class_getitem__(cls, item):
+        """
+        Creates a generic Depends type marker for a given dependency class.
+
+        Args:
+            item: The dependency class this field requires.
+
+        Returns:
+            type: Special marker type that the metaclass detects and records in
+                ``__dependencies__`` (and excludes from the construct model).
+        """
+        # Return a special marker type that the metaclass can detect, mirroring
+        # the State[T] / Link[T] markers.
+        return type(
+            f"Depends[{item.__name__}]",
+            (),
+            {"__origin__": Depends, "__args__": (item,), "__dependency_type__": item},
+        )

pyagentic/_base/_metaclasses.py

@@ -15,6 +15,7 @@ from pyagentic._base._agent._agent_state import _AgentState
 from pyagentic._base._tool import _ToolDefinition, tool
 from pyagentic._base._state import State, StateInfo, _StateDefinition
 from pyagentic._base._agent._agent_linking import Link, _LinkedAgentDefinition
+from pyagentic._base._depends import Depends
 from pyagentic._base._mcp import MCPLink, _MCPDefinition
 
 from pyagentic.models.response import AgentResponse, ToolResponse
@@ -323,6 +324,92 @@ class AgentMeta(type):
 
         return MappingProxyType(mcp_defs)
 
+    @staticmethod
+    def _extract_dependencies(annotations, namespace) -> Mapping[str, type]:
+        """Extracts dependency-injected fields declared with ``Depends[T]``.
+
+        Looks for annotations whose marker has ``__origin__ is Depends`` and
+        records the wrapped dependency type. These fields are injected at serve
+        time (by type) rather than supplied by clients, so they are excluded from
+        the generated construct model.
+
+        Args:
+            annotations (dict): Combined annotations from the class hierarchy.
+            namespace (dict): The class namespace.
+
+        Returns:
+            Mapping[str, type]: Immutable mapping of field name to dependency type.
+        """
+        dependencies: dict[str, type] = {}
+
+        for attr_name, attr_type in annotations.items():
+            if getattr(attr_type, "__origin__", None) is Depends:
+                dependencies[attr_name] = attr_type.__dependency_type__
+
+        return MappingProxyType(dependencies)
+
+    @staticmethod
+    def _build_construct_model(cls) -> Type[BaseModel]:
+        """Build a recursive Pydantic model mirroring the agent's constructor.
+
+        The construct model is the serializable construction contract for the
+        agent: it carries the data a client must supply to instantiate one, in a
+        way that mirrors writing the construction in Python.
+
+          - State fields → the raw per-field model, required when the StateInfo
+            has no default/default_factory, otherwise optional.
+          - Linked agents → that agent's own ``__construct_model__`` (nested),
+            optional when the AgentLink provides a default, otherwise required.
+          - ``model`` / ``api_key`` → optional scalars for provider selection.
+
+        ``Depends`` and MCP fields are excluded — they are injected/configured
+        server-side, not provided by clients.
+
+        Args:
+            cls: The agent class whose constructor to mirror.
+
+        Returns:
+            Type[BaseModel]: A dynamically created Pydantic model.
+        """
+        from typing import Optional
+        from pydantic import ConfigDict
+
+        fields: dict[str, Any] = {}
+
+        # State fields: type is the raw per-field model (e.g. UserProfile).
+        # Check for a default's *existence* without invoking factories.
+        for name, state_def in cls.__state_defs__.items():
+            info = state_def.info
+            if info.default_factory is not None:
+                fields[name] = (state_def.model, Field(default_factory=info.default_factory))
+            elif info.default is not None:
+                fields[name] = (state_def.model, Field(default=info.default))
+            else:
+                fields[name] = (state_def.model, Field(...))
+
+        # Linked agents: nest each child's construct model. A link is optional
+        # when its AgentLink declares any default (don't call the factory here).
+        for name, linked_def in cls.__linked_agents__.items():
+            child_model = linked_def.agent.__construct_model__
+            info = linked_def.info
+            has_default = info is not None and (
+                info.default is not None or info.default_factory is not None
+            )
+            if has_default:
+                fields[name] = (Optional[child_model], Field(default=None))
+            else:
+                fields[name] = (child_model, Field(...))
+
+        # Provider selection scalars.
+        fields["model"] = (Optional[str], Field(default=None))
+        fields["api_key"] = (Optional[str], Field(default=None))
+
+        return create_model(
+            f"{cls.__name__}Construct",
+            __config__=ConfigDict(arbitrary_types_allowed=True),
+            **fields,
+        )
+
     @staticmethod
     def _build_request_model(cls) -> Type[BaseModel]:
         """Build a Pydantic request model from the agent's __call__ signature.
@@ -458,6 +545,16 @@ class AgentMeta(type):
             # MCP fields are config-only, not constructor args
             elif field_name in agent_cls.__mcp_defs__:
                 continue
+            # Dependency-injected fields are optional (default None); they are
+            # supplied at serve time or passed explicitly for direct/test use.
+            elif field_name in agent_cls.__dependencies__:
+                param = inspect.Parameter(
+                    field_name,
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                    default=None,
+                    annotation=field_type,
+                )
+                optional.append(param)
             # Other annotated fields (like model, api_key, tracer, etc.)
             else:
                 default = getattr(agent_cls, field_name, inspect._empty)
@@ -611,12 +708,14 @@ class AgentMeta(type):
             annotations, inherited_namespace | namespace, mcs.__BaseAgent__
         )
         mcp_defs = mcs._extract_mcp_defs(annotations, inherited_namespace | namespace)
+        dependencies = mcs._extract_dependencies(annotations, inherited_namespace | namespace)
         with mcs._lock:
             cls.__tool_defs__ = tool_defs
             cls.__annotations__ = annotations
             cls.__state_defs__ = state_defs
             cls.__linked_agents__ = linked_agents
             cls.__mcp_defs__ = mcp_defs
+            cls.__dependencies__ = dependencies
 
         # Create response models at class declaration time, giving the agent a predetermined
         # output structure. This allows developers to know exactly what the output of the
@@ -668,10 +767,16 @@ class AgentMeta(type):
             ResponseModel=ResponseModel,
         )
 
+        # Build the recursive construct model mirroring the agent's constructor.
+        # Linked agents' construct models already exist because their classes are
+        # defined before this one (same guarantee relied on for __response_model__).
+        ConstructModel = mcs._build_construct_model(cls)
+
         with mcs._lock:
             cls.__tool_response_models__ = MappingProxyType(tool_response_models)
             cls.__response_model__ = ResponseModel
             cls.__request_model__ = RequestModel
+            cls.__construct_model__ = ConstructModel
             cls.__stream_event_model__ = StreamEventModel
             cls.__state_class__ = StateClass
 

pyagentic/api/__init__.py

@@ -11,7 +11,9 @@ Configuration lives in ``agents.toml`` beside your ``pyproject.toml`` (see
 :class:`AgentsConfig`).
 """
 
+from pyagentic._base._depends import Depends
 from pyagentic.api._app import create_app, create_router
+from pyagentic.api._build import build_agent, validate_dependencies
 from pyagentic.api._config import (
     AgentsConfig,
     AppConfig,
@@ -25,7 +27,6 @@ from pyagentic.api._models import (
     AgentInfo,
     AppAgentEntry,
     AppIndex,
-    CreateSessionRequest,
     CreateSessionResponse,
     DeleteSessionResponse,
     HealthResponse,
@@ -38,6 +39,9 @@ __all__ = [
     "create_app",
     "create_router",
     "mount_mcp",
+    "Depends",
+    "build_agent",
+    "validate_dependencies",
     "generate_dockerfile",
     "write_dockerfile",
     "AgentsConfig",
@@ -50,7 +54,6 @@ __all__ = [
     "AgentInfo",
     "AppAgentEntry",
     "AppIndex",
-    "CreateSessionRequest",
     "CreateSessionResponse",
     "DeleteSessionResponse",
     "HealthResponse",

pyagentic/api/_app.py

@@ -23,17 +23,19 @@ from typing import Optional, Union
 
 from dotenv import load_dotenv
 from fastapi import APIRouter, FastAPI, HTTPException
+from fastapi.exceptions import RequestValidationError
 from fastapi.responses import StreamingResponse
+from pydantic import ValidationError
 
 from pyagentic._base._agent._agent import BaseAgent
 from pyagentic.models.llm import LLMResponse
 from pyagentic.models.response import AgentResponse, ToolResponse
+from pyagentic.api._build import validate_dependencies
 from pyagentic.api._config import AgentsConfig, JobsConfig, load_config
 from pyagentic.api._models import (
     AgentInfo,
     AppAgentEntry,
     AppIndex,
-    CreateSessionRequest,
     CreateSessionResponse,
     DeleteSessionResponse,
     HealthResponse,
@@ -49,12 +51,14 @@ AgentsArg = Union[type[BaseAgent], list[type[BaseAgent]], dict[str, type[BaseAge
 
 _REQUIRED_AGENT_ATTRS = (
     "__request_model__",
+    "__construct_model__",
     "__response_model__",
     "__stream_event_model__",
     "__state_class__",
     "__tool_defs__",
     "__state_defs__",
     "__linked_agents__",
+    "__dependencies__",
 )
 
 
@@ -140,6 +144,26 @@ def _normalize_agents(agents: AgentsArg) -> dict[str, type[BaseAgent]]:
     return mapping
 
 
+def _deps_for(
+    prefix: str,
+    agent_class: type[BaseAgent],
+    dependencies: Optional[Union[list, dict]],
+) -> Optional[list]:
+    """Resolve the dependency list for one mounted agent.
+
+    A flat list applies to every agent; a dict is scoped by mount prefix (with or
+    without a leading slash) or by agent class.
+    """
+    if dependencies is None:
+        return None
+    if isinstance(dependencies, dict):
+        for key in (prefix, prefix.strip("/"), "/" + prefix.strip("/"), agent_class):
+            if key in dependencies:
+                return dependencies[key]
+        return None
+    return dependencies
+
+
 def create_router(
     agent_class: type[BaseAgent],
     *,
@@ -147,6 +171,7 @@ def create_router(
     name: Optional[str] = None,
     version: str = "0.1.0",
     tags: Optional[list[str]] = None,
+    dependencies: Optional[list] = None,
     sessions: bool = True,
     jobs: bool = False,
     jobs_config: Optional["JobsConfig"] = None,
@@ -185,6 +210,9 @@ def create_router(
         version (str): Version string for the info route.
         tags (Optional[list[str]]): OpenAPI tags applied to every route on the
             router (groups them in the docs). ``None`` leaves routes untagged.
+        dependencies (Optional[list]): Instances or factories satisfying the
+            agent tree's ``Depends[T]`` fields, resolved by type. Validated up
+            front so a missing dependency fails fast at router-build time.
         sessions (bool): If True, mount the session-based routes (create/list/
             delete sessions plus synchronous chat, streaming chat, and state).
             If False, those routes are omitted — interaction happens only via
@@ -203,18 +231,23 @@ def create_router(
 
     Raises:
         TypeError: If agent_class is missing required metaclass attributes.
+        ValueError: If a ``Depends[T]`` field in the agent tree has no provider.
     """
     _validate_agent_class(agent_class)
+    validate_dependencies(agent_class, dependencies)
 
     name = name or agent_class.__name__
     slug = _slugify(name)
     RequestModel = agent_class.__request_model__
+    ConstructModel = agent_class.__construct_model__
     ResponseModel = agent_class.__response_model__
     StreamEventModel = agent_class.__stream_event_model__
     StateModel = agent_class.__state_class__
 
     router = APIRouter(tags=tags)
-    session_manager = SessionManager(agent_class, default_model=model)
+    session_manager = SessionManager(
+        agent_class, default_model=model, dependencies=dependencies
+    )
 
     # ---- info routes ----
 
@@ -228,6 +261,7 @@ def create_router(
             tools=list(agent_class.__tool_defs__.keys()),
             state_fields=list(agent_class.__state_defs__.keys()),
             linked_agents=list(agent_class.__linked_agents__.keys()),
+            dependencies=list(agent_class.__dependencies__.keys()),
         )
 
     @router.get("/health", response_model=HealthResponse, name=f"{slug}_health")
@@ -237,8 +271,9 @@ def create_router(
 
     @router.get("/schema", response_model=SchemaResponse, name=f"{slug}_schema")
     async def schema() -> SchemaResponse:
-        """Return JSON schemas for request, response, stream event, and state models."""
+        """Return JSON schemas for construct, request, response, stream, and state models."""
         return SchemaResponse(
+            construct_schema=ConstructModel.model_json_schema(),
             request=RequestModel.model_json_schema(),
             response=ResponseModel.model_json_schema(),
             stream_event=StreamEventModel.model_json_schema(),
@@ -250,6 +285,7 @@ def create_router(
             router,
             slug,
             session_manager,
+            ConstructModel,
             RequestModel,
             ResponseModel,
             StreamEventModel,
@@ -268,6 +304,7 @@ def create_router(
             jobs_config or JobsConfig(),
             model,
             tags,
+            dependencies,
         )
     router.orchestrator = orchestrator
 
@@ -281,6 +318,7 @@ def _mount_jobs_router(
     jobs_config: "JobsConfig",
     default_model: Optional[str],
     tags: Optional[list[str]],
+    dependencies: Optional[list] = None,
 ) -> "JobOrchestrator":
     """Build a job orchestrator and include its /jobs router; return the orchestrator."""
     from pyagentic.api.jobs import JobOrchestrator, build_backend, build_store
@@ -292,6 +330,7 @@ def _mount_jobs_router(
         sessions,
         max_concurrency=jobs_config.max_concurrency,
         default_model=default_model,
+        dependencies=dependencies,
     )
     orchestrator = JobOrchestrator(store, backend, jobs_config, sessions)
     router.include_router(
@@ -304,6 +343,7 @@ def _register_session_routes(
     router: APIRouter,
     slug: str,
     sessions: SessionManager,
+    ConstructModel: type,
     RequestModel: type,
     ResponseModel: type,
     StreamEventModel: type,
@@ -320,12 +360,23 @@ def _register_session_routes(
         name=f"{slug}_create_session",
     )
     async def create_session(
-        req: Optional[CreateSessionRequest] = None,
+        req: Optional[ConstructModel] = None,  # type: ignore[valid-type]
     ) -> CreateSessionResponse:
-        """Create a new agent session."""
-        model = req.model if req else None
-        api_key = req.api_key if req else None
-        session_id = sessions.create(model=model, api_key=api_key)
+        """Create a new agent session.
+
+        The body is the agent's construct model — the serializable construction
+        data (state, nested linked-agent state, model/api_key). Required state
+        and linked agents (those without defaults) must be supplied here, exactly
+        as when constructing the agent in code. The body may be omitted only when
+        the agent has no required construction fields.
+        """
+        if req is None:
+            # No body: valid only when nothing is required; otherwise 422.
+            try:
+                req = ConstructModel()
+            except ValidationError as exc:
+                raise RequestValidationError(exc.errors())
+        session_id = sessions.create(construct_data=req)
         return CreateSessionResponse(session_id=session_id)
 
     @router.get(
@@ -483,6 +534,7 @@ def create_app(
     version: Optional[str] = None,
     description: Optional[str] = None,
     model: Optional[str] = None,
+    dependencies: Optional[Union[list, dict]] = None,
     mcp: bool = False,
     sessions: bool = True,
     jobs: bool = False,
@@ -512,6 +564,10 @@ def create_app(
         description (Optional[str]): App description. Overrides config.
         model (Optional[str]): Default model for all agents' sessions. Overrides
             config.
+        dependencies (Optional[Union[list, dict]]): Providers for the agents'
+            ``Depends[T]`` fields (instances or factories, resolved by type). A
+            flat list is applied to every mounted agent; a dict keyed by mount
+            prefix (or agent class) scopes providers per agent.
         mcp (bool): If True, mount an MCP endpoint per agent at ``<prefix>/mcp``.
         sessions (bool): If True (default), mount the session-based routes
             (sessions CRUD plus synchronous/streaming chat and state) for each
@@ -563,6 +619,7 @@ def create_app(
             model=model,
             name=agent_name,
             version=version,
+            dependencies=_deps_for(prefix, agent_class, dependencies),
             sessions=sessions,
             jobs=jobs_enabled,
             jobs_config=jobs_cfg,

pyagentic/api/_build.py

@@ -0,0 +1,205 @@
+"""
+Construct agents from a (recursive) construct-model payload plus developer-supplied
+dependencies.
+
+The metaclass generates ``agent_class.__construct_model__`` — a recursive Pydantic
+model mirroring the constructor (state fields, nested linked-agent construct models,
+and ``model``/``api_key``). ``build_agent`` turns an instance of that model into a
+live agent, recursing into linked agents and injecting ``Depends[T]`` fields by type
+from a flat ``dependencies`` list.
+
+Dependencies are passed as bare values:
+  - an **instance** of the dependency type, or
+  - a zero-arg **factory** whose return annotation is (a subclass of) the type.
+
+Resolution is by type. An instance match wins over a factory; factories are called
+fresh for each agent built (so each session/job gets its own).
+"""
+
+import inspect
+from typing import Any, Optional
+
+from pyagentic._base._agent._agent import BaseAgent
+
+
+def _as_field_dict(construct_data: Any) -> dict:
+    """Normalize a construct payload (Pydantic model or dict) to a field dict.
+
+    Nested values (linked-agent construct models) are preserved as-is so the
+    recursion can descend into them.
+    """
+    if construct_data is None:
+        return {}
+    if isinstance(construct_data, dict):
+        return dict(construct_data)
+    # Pydantic model: iterate declared fields, keeping nested model instances.
+    model_fields = getattr(type(construct_data), "model_fields", None)
+    if model_fields is not None:
+        return {name: getattr(construct_data, name) for name in model_fields}
+    raise TypeError(f"Unsupported construct payload type: {type(construct_data)!r}")
+
+
+def _matches_factory(value: Any, dep_type: type) -> bool:
+    """Return whether *value* is a zero-arg factory producing *dep_type*."""
+    if not callable(value) or isinstance(value, type):
+        # Plain classes are treated as instances/values, not factories — a
+        # factory is expected to be an annotated callable.
+        return False
+    try:
+        ret = inspect.signature(value).return_annotation
+    except (TypeError, ValueError):
+        return False
+    return isinstance(ret, type) and issubclass(ret, dep_type)
+
+
+def _resolve_dependency(name: str, dep_type: type, dependencies: list) -> Any:
+    """Resolve a single ``Depends[T]`` slot from the dependency list.
+
+    Args:
+        name (str): The field name (used only for error messages).
+        dep_type (type): The declared dependency type ``T``.
+        dependencies (list): Provided instances/factories.
+
+    Returns:
+        Any: The resolved dependency instance.
+
+    Raises:
+        LookupError: If no provided value satisfies the slot.
+    """
+    # Instance match wins.
+    for value in dependencies:
+        if isinstance(value, dep_type):
+            return value
+    # Otherwise a factory whose return type matches; called fresh.
+    for value in dependencies:
+        if _matches_factory(value, dep_type):
+            return value()
+    raise LookupError(
+        f"No dependency provided for '{name}': {dep_type.__name__}. "
+        f"Pass an instance of {dep_type.__name__} or a factory returning it "
+        f"in create_router(..., dependencies=[...])."
+    )
+
+
+def build_agent(
+    agent_class: type[BaseAgent],
+    construct_data: Any,
+    dependencies: Optional[list] = None,
+    *,
+    default_model: Optional[str] = None,
+    default_api_key: Optional[str] = None,
+) -> BaseAgent:
+    """Instantiate an agent from a construct-model payload and injected dependencies.
+
+    Linked agents are built first (depth-first) from their nested construct
+    submodels, then ``Depends[T]`` fields are resolved by type, and finally the
+    agent is constructed with state, ``model``/``api_key``, the built linked
+    agents, and the resolved dependencies. The ``default_model``/``default_api_key``
+    propagate down the whole tree, filling in any agent whose payload omits them.
+
+    Args:
+        agent_class (type[BaseAgent]): The agent class to instantiate.
+        construct_data (Any): An instance of ``agent_class.__construct_model__``
+            (or a dict with the same shape).
+        dependencies (Optional[list]): Instances or factories used to satisfy
+            ``Depends[T]`` fields across the agent tree. Defaults to ``[]``.
+        default_model (Optional[str]): Model applied to any agent in the tree that
+            does not specify its own ``model``.
+        default_api_key (Optional[str]): API key applied alongside ``default_model``
+            for any agent that does not specify its own.
+
+    Returns:
+        BaseAgent: The fully constructed agent instance.
+
+    Raises:
+        LookupError: If a required dependency cannot be resolved.
+    """
+    dependencies = dependencies or []
+    # A raw dict (e.g. a persisted job payload) is parsed through the construct
+    # model so nested state and linked-agent submodels are coerced to typed
+    # instances before construction.
+    if isinstance(construct_data, dict):
+        construct_data = agent_class.__construct_model__(**construct_data)
+    fields = _as_field_dict(construct_data)
+    kwargs: dict[str, Any] = {}
+
+    # Build nested linked agents first (defaults propagate down the tree).
+    for name, linked_def in agent_class.__linked_agents__.items():
+        child_data = fields.get(name)
+        if child_data is None:
+            # Omitted optional link: let __init__ apply the AgentLink default.
+            continue
+        kwargs[name] = build_agent(
+            linked_def.agent,
+            child_data,
+            dependencies,
+            default_model=default_model,
+            default_api_key=default_api_key,
+        )
+
+    # State fields supplied by the client.
+    for name in agent_class.__state_defs__:
+        if name in fields and fields[name] is not None:
+            kwargs[name] = fields[name]
+
+    # Provider selection scalars, falling back to the propagated defaults.
+    model = fields.get("model") or default_model
+    api_key = fields.get("api_key") or default_api_key
+    if model is not None:
+        kwargs["model"] = model
+    if api_key is not None:
+        kwargs["api_key"] = api_key
+
+    # Inject dependencies by type.
+    for name, dep_type in agent_class.__dependencies__.items():
+        kwargs[name] = _resolve_dependency(name, dep_type, dependencies)
+
+    return agent_class(**kwargs)
+
+
+def _collect_dependency_slots(
+    agent_class: type[BaseAgent],
+    _seen: Optional[set] = None,
+) -> list[tuple[str, type]]:
+    """Walk the linked-agent tree collecting every ``Depends[T]`` slot."""
+    _seen = _seen if _seen is not None else set()
+    if agent_class in _seen:
+        return []
+    _seen.add(agent_class)
+
+    slots: list[tuple[str, type]] = list(agent_class.__dependencies__.items())
+    for linked_def in agent_class.__linked_agents__.values():
+        slots.extend(_collect_dependency_slots(linked_def.agent, _seen))
+    return slots
+
+
+def validate_dependencies(
+    agent_class: type[BaseAgent],
+    dependencies: Optional[list] = None,
+) -> None:
+    """Verify every ``Depends[T]`` slot in the agent tree is satisfiable.
+
+    Intended to run once at ``create_router``/``create_app`` time so misconfigured
+    dependencies fail fast rather than per request. Factories are not invoked —
+    only their presence/return type is checked.
+
+    Args:
+        agent_class (type[BaseAgent]): The root agent class.
+        dependencies (Optional[list]): Provided instances/factories.
+
+    Raises:
+        ValueError: If any dependency slot has no matching provider.
+    """
+    dependencies = dependencies or []
+    missing: list[str] = []
+    for name, dep_type in _collect_dependency_slots(agent_class):
+        satisfiable = any(isinstance(v, dep_type) for v in dependencies) or any(
+            _matches_factory(v, dep_type) for v in dependencies
+        )
+        if not satisfiable:
+            missing.append(f"'{name}': {dep_type.__name__}")
+    if missing:
+        raise ValueError(
+            f"{agent_class.__name__} has unsatisfied dependencies: {', '.join(missing)}. "
+            f"Provide them via dependencies=[...] (an instance or a factory returning the type)."
+        )

pyagentic/api/_models.py

@@ -8,22 +8,7 @@ endpoints are typed directly from each agent's metaclass-generated models
 ``__state_class__``), so they are not duplicated here.
 """
 
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-class CreateSessionRequest(BaseModel):
-    """Request body for creating a new agent session.
-
-    Attributes:
-        model (Optional[str]): LLM model string override
-            (e.g. ``'openai::gpt-4o'``).
-        api_key (Optional[str]): API key for the model provider.
-    """
-
-    model: Optional[str] = None
-    api_key: Optional[str] = None
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class CreateSessionResponse(BaseModel):
@@ -76,6 +61,7 @@ class AgentInfo(BaseModel):
         tools (list[str]): Names of the tools the agent exposes.
         state_fields (list[str]): Names of the agent's state fields.
         linked_agents (list[str]): Names of agents linked to this one.
+        dependencies (list[str]): Names of the agent's ``Depends[T]`` fields.
     """
 
     name: str
@@ -84,18 +70,26 @@ class AgentInfo(BaseModel):
     tools: list[str] = Field(default_factory=list)
     state_fields: list[str] = Field(default_factory=list)
     linked_agents: list[str] = Field(default_factory=list)
+    dependencies: list[str] = Field(default_factory=list)
 
 
 class SchemaResponse(BaseModel):
-    """JSON schemas for an agent's request/response/stream/state models.
+    """JSON schemas for an agent's construct/request/response/stream/state models.
 
     Attributes:
+        construct (dict): JSON schema of the agent's construct model (the body
+            for creating a session / a sessionless job).
         request (dict): JSON schema of the agent's request model.
         response (dict): JSON schema of the agent's response model.
         stream_event (dict): JSON schema of the agent's stream event model.
         state (dict): JSON schema of the agent's state model.
     """
 
+    # Serialized as ``construct``; the Python attribute avoids shadowing the
+    # deprecated ``BaseModel.construct`` method (which pydantic warns about).
+    model_config = ConfigDict(populate_by_name=True)
+
+    construct_schema: dict = Field(serialization_alias="construct", validation_alias="construct")
     request: dict
     response: dict
     stream_event: dict

pyagentic/api/_sessions.py

@@ -4,24 +4,28 @@ independent state and conversation history.
 """
 
 import uuid
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Any, Optional
+
+from pyagentic.api._build import build_agent
 
 if TYPE_CHECKING:
     from pyagentic._base._agent._agent import BaseAgent
-    from pyagentic.llm._provider import LLMProvider
 
 
 class SessionManager:
     """Manages agent sessions keyed by session ID.
 
     Each session holds its own agent instance, so state and conversation
-    history are isolated per session.
+    history are isolated per session. Agents are constructed from a
+    construct-model payload (mirroring the constructor) plus developer-supplied
+    dependencies, via :func:`pyagentic.api._build.build_agent`.
     """
 
     def __init__(
         self,
         agent_class: "type[BaseAgent]",
         default_model: Optional[str] = None,
+        dependencies: Optional[list] = None,
     ) -> None:
         """Initialize the session manager.
 
@@ -29,42 +33,36 @@ class SessionManager:
             agent_class (type[BaseAgent]): The agent class to instantiate for
                 each session.
             default_model (Optional[str]): Model string used when a session is
-                created without one. ``None`` falls back to the agent class's
-                own default model.
+                created without one in its construct payload. ``None`` falls
+                back to the agent class's own default model.
+            dependencies (Optional[list]): Instances or factories used to satisfy
+                the agent tree's ``Depends[T]`` fields (resolved by type).
         """
         self._agent_class = agent_class
         self._default_model = default_model
+        self._dependencies = dependencies or []
         self._sessions: dict[str, "BaseAgent"] = {}
 
-    def create(
-        self,
-        *,
-        model: Optional[str] = None,
-        api_key: Optional[str] = None,
-        provider: Optional["LLMProvider"] = None,
-    ) -> str:
+    def create(self, *, construct_data: Any = None) -> str:
         """Create a new session with a fresh agent instance.
 
         Args:
-            model (Optional[str]): LLM model string (e.g. 'openai::gpt-4o').
-                Falls back to the manager's ``default_model``.
-            api_key (Optional[str]): API key for the model provider.
-            provider (Optional[LLMProvider]): Pre-configured LLMProvider
-                instance. Overrides model/api_key.
+            construct_data (Any): An instance of the agent's
+                ``__construct_model__`` (or a dict of the same shape) carrying
+                the serializable construction data (state, nested linked-agent
+                state, ``model``/``api_key``). ``None`` builds with defaults.
 
         Returns:
             str: The new session ID.
         """
         session_id = uuid.uuid4().hex[:12]
 
-        if provider is not None:
-            agent = self._agent_class(provider=provider)
-        else:
-            kwargs: dict = {"api_key": api_key}
-            resolved_model = model or self._default_model
-            if resolved_model is not None:
-                kwargs["model"] = resolved_model
-            agent = self._agent_class(**kwargs)
+        agent = build_agent(
+            self._agent_class,
+            construct_data,
+            self._dependencies,
+            default_model=self._default_model,
+        )
 
         self._sessions[session_id] = agent
         return session_id

pyagentic/api/jobs/_models.py

@@ -37,6 +37,9 @@ class JobRecord(BaseModel):
         session_id (Optional[str]): Session the job belongs to, if any.
         status (JobStatus): Current lifecycle state.
         request (dict): The submitted agent input kwargs.
+        construct_payload (Optional[dict]): Construct-model payload for a
+            sessionless job, used to build a fresh agent (and survive recovery).
+            ``None`` for session-bound jobs (which reuse the session's live agent).
         result_json (Optional[str]): Final agent response as a raw JSON
             string, set when the job succeeds.
         error (Optional[str]): Failure description, set when the job fails.
@@ -49,6 +52,7 @@ class JobRecord(BaseModel):
     session_id: Optional[str] = None
     status: JobStatus = JobStatus.QUEUED
     request: dict = Field(default_factory=dict)
+    construct_payload: Optional[dict] = None
     result_json: Optional[str] = None
     error: Optional[str] = None
     created_at: float = Field(default_factory=time.time)

pyagentic/api/jobs/_orchestrator.py

@@ -138,7 +138,10 @@ class JobOrchestrator:
     # ---- submission & execution ----
 
     async def submit(
-        self, request: dict, session_id: Optional[str] = None
+        self,
+        request: dict,
+        session_id: Optional[str] = None,
+        construct: Optional[dict] = None,
     ) -> JobRecord:
         """Create a durable job record and route it for execution.
 
@@ -150,6 +153,8 @@ class JobOrchestrator:
         Args:
             request (dict): Agent input kwargs.
             session_id (Optional[str]): Session to bind the job to.
+            construct (Optional[dict]): Construct-model payload for building a
+                fresh agent (sessionless jobs only). Persisted for recovery.
 
         Returns:
             JobRecord: The persisted record in its initial queued state.
@@ -160,6 +165,7 @@ class JobOrchestrator:
             session_id=session_id,
             status=JobStatus.QUEUED,
             request=request,
+            construct_payload=construct,
         )
         await self.store.create_job(job)
         self._next_seq[job.job_id] = 0

pyagentic/api/jobs/_routes.py

@@ -10,7 +10,7 @@ from typing import Optional
 
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
-from pydantic import create_model
+from pydantic import ConfigDict, Field, create_model
 
 from pyagentic._base._agent._agent import BaseAgent
 from pyagentic.api._sessions import SessionManager
@@ -138,12 +138,17 @@ def build_jobs_router(
     """
     router = APIRouter()
     RequestModel = agent_class.__request_model__
+    ConstructModel = agent_class.__construct_model__
     ResponseModel = agent_class.__response_model__
 
+    # ``construct`` is the wire field name; the Python attribute is suffixed to
+    # avoid shadowing the deprecated ``BaseModel.construct`` method.
     SubmitModel = create_model(
         f"{agent_class.__name__}JobSubmitRequest",
+        __config__=ConfigDict(populate_by_name=True),
         input=(RequestModel, ...),
         session_id=(Optional[str], None),
+        construct_payload=(Optional[ConstructModel], Field(None, alias="construct")),
     )
 
     # Narrow the loosely-typed JobSnapshot.result to this agent's response model
@@ -156,14 +161,25 @@ def build_jobs_router(
 
     @router.post("/jobs", status_code=202, response_model=JobSubmitResponse)
     async def submit_job(req: SubmitModel) -> dict:  # type: ignore[valid-type]
-        """Submit an agent run as an async job."""
+        """Submit an agent run as an async job.
+
+        A session-bound job (``session_id`` set) runs on that session's live
+        agent. A sessionless job builds a fresh agent from the optional
+        ``construct`` payload (the agent's construct model) plus the server's
+        injected dependencies.
+        """
         await orchestrator.ensure_started()
         if req.session_id is not None and not sessions.exists(req.session_id):
             raise HTTPException(status_code=404, detail="Session not found")
         request = {
             field: getattr(req.input, field) for field in type(req.input).model_fields
         }
-        job = await orchestrator.submit(request, session_id=req.session_id)
+        construct = None
+        if req.session_id is None and req.construct_payload is not None:
+            construct = req.construct_payload.model_dump()
+        job = await orchestrator.submit(
+            request, session_id=req.session_id, construct=construct
+        )
         return {"job_id": job.job_id, "status": job.status.value}
 
     @router.get("/jobs", response_model=JobListResponse)

pyagentic/api/jobs/backends/__init__.py

@@ -23,6 +23,7 @@ def build_backend(
     *,
     max_concurrency: int = 8,
     default_model: Optional[str] = None,
+    dependencies: Optional[list] = None,
 ) -> ExecutionBackend:
     """Build the in-process ExecutionBackend.
 
@@ -31,6 +32,8 @@ def build_backend(
         sessions (SessionManager): Live session registry.
         max_concurrency (int): Max concurrent agent runs.
         default_model (Optional[str]): Model for sessionless agents.
+        dependencies (Optional[list]): Providers for ``Depends[T]`` fields used
+            when building a fresh agent for a sessionless job.
 
     Returns:
         ExecutionBackend: A configured :class:`InProcessBackend`.
@@ -40,4 +43,5 @@ def build_backend(
         sessions,
         max_concurrency=max_concurrency,
         default_model=default_model,
+        dependencies=dependencies,
     )

pyagentic/api/jobs/backends/_in_process.py

@@ -17,6 +17,7 @@ from pyagentic.api.jobs._models import (
     _build_prompt,
 )
 from pyagentic.api.jobs.backends._base import EmitFn, LocalExecutionBackend
+from pyagentic.api._build import build_agent
 
 if TYPE_CHECKING:
     from pyagentic.api._sessions import SessionManager
@@ -37,6 +38,7 @@ class InProcessBackend(LocalExecutionBackend):
         *,
         max_concurrency: int = 8,
         default_model: Optional[str] = None,
+        dependencies: Optional[list] = None,
     ) -> None:
         """Create the backend.
 
@@ -46,11 +48,14 @@ class InProcessBackend(LocalExecutionBackend):
             sessions (SessionManager): Live session registry for session-bound jobs.
             max_concurrency (int): Max concurrent agent runs.
             default_model (Optional[str]): Model for sessionless agents.
+            dependencies (Optional[list]): Providers for the agent's ``Depends[T]``
+                fields when building a fresh agent for a sessionless job.
         """
         super().__init__()
         self._agent_class = agent_class
         self._sessions = sessions
         self._default_model = default_model
+        self._dependencies = dependencies or []
         self._max_concurrency = max_concurrency
         self._sem = asyncio.Semaphore(max_concurrency)
 
@@ -72,10 +77,12 @@ class InProcessBackend(LocalExecutionBackend):
             agent = self._sessions.get(session_id)
             own_agent = False
         else:
-            kwargs = {}
-            if self._default_model is not None:
-                kwargs["model"] = self._default_model
-            agent = self._agent_class(**kwargs)
+            agent = build_agent(
+                self._agent_class,
+                job.construct_payload,
+                self._dependencies,
+                default_model=self._default_model,
+            )
             own_agent = True
 
         prompt = _build_prompt(job.request)

pyagentic/api/jobs/store/_sqlite.py

@@ -23,15 +23,16 @@ from pyagentic.api.jobs.store._base import JobStore
 
 _SCHEMA = """
 CREATE TABLE IF NOT EXISTS jobs (
-    job_id       TEXT PRIMARY KEY,
-    session_id   TEXT,
-    status       TEXT NOT NULL,
-    request_json TEXT NOT NULL,
-    result_json  TEXT,
-    error        TEXT,
-    created_at   REAL NOT NULL,
-    started_at   REAL,
-    finished_at  REAL
+    job_id        TEXT PRIMARY KEY,
+    session_id    TEXT,
+    status        TEXT NOT NULL,
+    request_json  TEXT NOT NULL,
+    construct_json TEXT,
+    result_json   TEXT,
+    error         TEXT,
+    created_at    REAL NOT NULL,
+    started_at    REAL,
+    finished_at   REAL
 );
 CREATE INDEX IF NOT EXISTS idx_jobs_session ON jobs(session_id);
 CREATE INDEX IF NOT EXISTS idx_jobs_status  ON jobs(status);
@@ -54,6 +55,9 @@ def _row_to_record(row: sqlite3.Row) -> JobRecord:
         session_id=row["session_id"],
         status=JobStatus(row["status"]),
         request=json.loads(row["request_json"]),
+        construct_payload=(
+            json.loads(row["construct_json"]) if row["construct_json"] else None
+        ),
         result_json=row["result_json"],
         error=row["error"],
         created_at=row["created_at"],
@@ -128,13 +132,18 @@ class SQLiteJobStore(JobStore):
         def _insert(conn: sqlite3.Connection) -> None:
             conn.execute(
                 "INSERT INTO jobs (job_id, session_id, status, request_json, "
-                "result_json, error, created_at, started_at, finished_at) "
-                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                "construct_json, result_json, error, created_at, started_at, finished_at) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
                 (
                     job.job_id,
                     job.session_id,
                     job.status.value,
                     json.dumps(job.request, default=str),
+                    (
+                        json.dumps(job.construct_payload, default=str)
+                        if job.construct_payload is not None
+                        else None
+                    ),
                     job.result_json,
                     job.error,
                     job.created_at,

{pyagentic_core-2.10.1.dev2.dist-info → pyagentic_core-2.11.1.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyagentic-core
-Version: 2.10.1.dev2
+Version: 2.11.1.dev1
 Summary: Build LLM Agents in a Pythonic way
 Author-email: Ryan Mikulec <rmikulec.dev@gmail.com>
 License: MIT

{pyagentic_core-2.10.1.dev2.dist-info → pyagentic_core-2.11.1.dev1.dist-info}/RECORD

@@ -1,40 +1,42 @@
-pyagentic/__init__.py,sha256=eMQX9My9kax7togSTBmQOUVIV_rCw_cxE321FgCNjCQ,1849
+pyagentic/__init__.py,sha256=S1nJnbbDZzkH0AbKYWIAWCPhZJW2a2Ml2zdxi91WSPk,2012
 pyagentic/_version_scheme.py,sha256=hUYPvGhWz5L7RSuVxIqW3h10i4zNjfYXMofmoIk8ZBM,1569
 pyagentic/logging.py,sha256=vWLKGx0jZurWQT5pMr6fLH5NgJnZd_eaB97geBnqlwI,1718
 pyagentic/updates.py,sha256=JrBxbmTRxS-4tfSrai_wPK-dxSyCiNrYwC5MgrzGj54,870
 pyagentic/_base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyagentic/_base/_depends.py,sha256=O59cvg4uc4feDrPjn9HqryrMGzqNyulyv8intAmQ8PE,2188
 pyagentic/_base/_exceptions.py,sha256=r_wcuWgc_Y3g_D7DwLQL8NbTphIAeeNpIp-WDHMvvOk,3746
 pyagentic/_base/_info.py,sha256=2bY9_Ua9N7m94hcv6gLJCBZ2guxXTJf3YVOuJAyG4ns,2995
 pyagentic/_base/_mcp.py,sha256=YPRaqVFrgKDA5BZtvVrcScyADjo66cdB4_h6nXpRJBI,8329
-pyagentic/_base/_metaclasses.py,sha256=xg-AFj45KCby0LLWgvvQDNPjaySQhn49pCCv5cR9X-k,29682
+pyagentic/_base/_metaclasses.py,sha256=0PQ3ipidOPKo6xE5Ra2ZBhme74s3Ss9BLj9O0RehueA,34452
 pyagentic/_base/_ref.py,sha256=Ez1Iexxl7NLBK91frcgz_eFbrXfLZpm9fvkYHMFWA_w,3179
 pyagentic/_base/_spec.py,sha256=TH-DZTYFcxXmzxGympH4vATPPlpI2o88Wlv6S7UuNlQ,7112
 pyagentic/_base/_state.py,sha256=swjMl22rOgaIVEuqyL1bG7gpYpumuOZ6ytNImV_2lGw,1794
 pyagentic/_base/_tool.py,sha256=6Zkd20iwQX1uS-rw4i9IA8doM8qjchEZ3EmMk5Li9SE,11040
 pyagentic/_base/_validation.py,sha256=BBscZMrXB09LNNP17pYOAY6I4iCW8r2GBVStqBd-9f8,3833
 pyagentic/_base/_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyagentic/_base/_agent/_agent.py,sha256=HZJM27CPtXA_bNqNjMSvbmEbv1OY05JirGUkSacf1xo,39373
+pyagentic/_base/_agent/_agent.py,sha256=P35dpRp4Ihpc7AzGLW8bo_aj1pR2orvxu3a5777NIL8,39549
 pyagentic/_base/_agent/_agent_linking.py,sha256=gSHQkbH-BeKG8moROKDZiLs0ktLzW9bOVo0DFq3UNs8,1841
 pyagentic/_base/_agent/_agent_state.py,sha256=gvx0rQ1gaWfZHHAONX4YNsO_HE0xYQ14_GBKMP4Af-o,11507
 pyagentic/_utils/_typing.py,sha256=5aRZZOVzR0ZgnBfejkw__1yoARhn70P5QzA81sxUkls,3681
 pyagentic/_utils/_warnings.py,sha256=mjlBiYHGnnh5599Gsq5ke8mBFS6WsdhNa7jk20TT9_U,1330
-pyagentic/api/__init__.py,sha256=v-jaDw3mPCxpcllfYAbBCOdyC16qBA3B4eegxcDk4iU,1590
-pyagentic/api/_app.py,sha256=BOaMk28CPBEUOVoiQeg3e8D6CTuHw6h3V7ti0s2h-m8,22558
+pyagentic/api/__init__.py,sha256=7CklNYjxVj5XOyqTWvvWKZU6IYuU8CAfpOhNeGMH1d4,1712
+pyagentic/api/_app.py,sha256=G34AdK-h88EEuJxzmzzNPkskR5dUGKRHz16PE0g8i3E,25146
+pyagentic/api/_build.py,sha256=HfIAr9YREZk2BvyRwy4HmkMONQpnPptqytpxc2l_QB8,8133
 pyagentic/api/_config.py,sha256=2YaFBDW7aaRueemHPBd1XzW9m0oqVCBilt8MA-x6QqI,6547
 pyagentic/api/_docker.py,sha256=AoAQ66gT-Uf5WhiYpImKSpTPyboiTaqWvxG7mBLe54I,2229
 pyagentic/api/_mcp_server.py,sha256=9aOC18-FSv1qS7umqFHxMKV5FujblziR-_NDfNsXmFo,5032
-pyagentic/api/_models.py,sha256=1wI-GVYNwuNkDCktmmfcicMVsAgNEcUkJXnqN_ff4eo,3411
-pyagentic/api/_sessions.py,sha256=HU2pkCIA_b1syr7n6qIl0m2Ad5tvPzVplzYAeKS_9HM,3636
+pyagentic/api/_models.py,sha256=ReDeuzQWIZ7YYDAwa8yfPYZNR6cPQlBYRMtsni_5crw,3633
+pyagentic/api/_sessions.py,sha256=P-i67Jii3cAfCrotkWGxYnf-8LCkc96Vn9gnDgXrS6Y,3754
 pyagentic/api/jobs/__init__.py,sha256=SGZOE86xVwv4hX2zjpm8uLZZhizz0rv3EV5suUuiM8M,979
-pyagentic/api/jobs/_models.py,sha256=vIFZaES7v5hD68MvyPG-2D_miQDMNaWp_5IH_7TYxcw,6950
-pyagentic/api/jobs/_orchestrator.py,sha256=XgvFiQ9R-rLMGjkTGUUXhU6YsTg-x6nABfABvpfQX-E,17159
-pyagentic/api/jobs/_routes.py,sha256=At5nmn_7a3igaLPIgFnt3_xwTM3yYSsD_ZFRfmalymk,9764
-pyagentic/api/jobs/backends/__init__.py,sha256=LdlWjve6cdl04X09sJvlV-aUPK2euImC_cW73lg3tBM,1325
+pyagentic/api/jobs/_models.py,sha256=Q0E69uVkEibEUItuS1U0C38YG5ixKnp8IzxNvLVkDk8,7234
+pyagentic/api/jobs/_orchestrator.py,sha256=umt6IAIPpCJiDH7HYMSwT8X1SVDVUQ7lqxBpDiI1k4c,17415
+pyagentic/api/jobs/_routes.py,sha256=1tR-_udgiBIwLVy_JIvdW9Ik5BiYMEzAlIbufArzATU,10593
+pyagentic/api/jobs/backends/__init__.py,sha256=giGsZOH4Q2l5HU8ccO5q-sKsKdR23zOzWlECc_n4CwE,1544
 pyagentic/api/jobs/backends/_base.py,sha256=LITAW0FNWKAdEhmnixe5UakbBrxYY7rWbZD7jK6VZL8,4453
-pyagentic/api/jobs/backends/_in_process.py,sha256=5ltFfS39noeddXacp2GCUHW9A_SyMNw0xHVPbKcgtFI,4425
+pyagentic/api/jobs/backends/_in_process.py,sha256=pMyewlmkAUTsIn_q29zmYHPyyKNZNi2zhqZS2gQvyf8,4755
 pyagentic/api/jobs/store/__init__.py,sha256=jxm7hEa2AiV44_1UfYuJ-RofeM6I-DFMCywzYHNk1Nc,507
 pyagentic/api/jobs/store/_base.py,sha256=Ao9mRSRiwEz44mJRFWfqM5aZkXbemULoNwUBDRNDYuM,4856
-pyagentic/api/jobs/store/_sqlite.py,sha256=nzw5vkmrbIeetZqbw385CCnixltWtrBWGvhuay5OSlU,12291
+pyagentic/api/jobs/store/_sqlite.py,sha256=hX0MIo1PVYmlsw8Hc6WDb4qM8tyavHzYVd37uK0hRQ0,12675
 pyagentic/llm/__init__.py,sha256=4ABk1NnYmw_yf9qeS0WVZb8dLl3gC1xtoD7RmH9_G2U,966
 pyagentic/llm/_anthropic.py,sha256=oiyin7QCeHlo9hn8YGJri0QheOa_uvacQSvyS9djMsE,8372
 pyagentic/llm/_gemini.py,sha256=cC1borYCdL9EpdJ51j0kJRQuTnSdMsG7JN5ruq3w5Cg,10385
@@ -52,8 +54,8 @@ pyagentic/tracing/__init__.py,sha256=ddMOl_-Nf3WOhu-PYxSJ3kqHZ3eQXAOM5aySn9YmDtA
 pyagentic/tracing/_basic.py,sha256=jUBKdkOPveCjBzEhHKS_Rvp5l38iZg-5nFIl6xEwOVk,8906
 pyagentic/tracing/_langfuse.py,sha256=5b5tdT-gyRJP5HDcvCS4tn_k3AFDI6eNsXOd6On5gKQ,13986
 pyagentic/tracing/_tracer.py,sha256=HMisWfRLAQ9sdcjOvImiLij6OASd3siM8K-7nUfM3xs,7656
-pyagentic_core-2.10.1.dev2.dist-info/licenses/LICENSE,sha256=wcOzTj82hOc96HztJk2VzLB2hFHpdIGpjz8vvbpP1_s,1069
-pyagentic_core-2.10.1.dev2.dist-info/METADATA,sha256=oQsV2I4CSW0si5Q8YueIq1W2bqt3lNzJXSZmv787VAs,8212
-pyagentic_core-2.10.1.dev2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-pyagentic_core-2.10.1.dev2.dist-info/top_level.txt,sha256=lAWfd-ay434uEpSg2FM0ySN0o4vgNGE6D9dJkIhGyfY,10
-pyagentic_core-2.10.1.dev2.dist-info/RECORD,,
+pyagentic_core-2.11.1.dev1.dist-info/licenses/LICENSE,sha256=wcOzTj82hOc96HztJk2VzLB2hFHpdIGpjz8vvbpP1_s,1069
+pyagentic_core-2.11.1.dev1.dist-info/METADATA,sha256=GOf2IQSJPjEu105ZiXEf0WfET_7YC2la3d1LH1_Y77I,8212
+pyagentic_core-2.11.1.dev1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyagentic_core-2.11.1.dev1.dist-info/top_level.txt,sha256=lAWfd-ay434uEpSg2FM0ySN0o4vgNGE6D9dJkIhGyfY,10
+pyagentic_core-2.11.1.dev1.dist-info/RECORD,,