graphai-lib 0.0.8__tar.gz → 0.0.9__tar.gz

{graphai_lib-0.0.8 → graphai_lib-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphai-lib
-Version: 0.0.8
+Version: 0.0.9
 Summary: Not an AI framework
 Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown

{graphai_lib-0.0.8 → graphai_lib-0.0.9}/graphai/callback.py

@@ -1,13 +1,53 @@
 import asyncio
+from dataclasses import dataclass
+from enum import Enum
 from pydantic import Field
 from typing import Any
 from collections.abc import AsyncIterator
+import warnings
 
 
 log_stream = True
 
 
+class StrEnum(Enum):
+    def __str__(self) -> str:
+        return str(self.value)
+
+class GraphEventType(StrEnum):
+    START = "start"
+    END = "end"
+    START_NODE = "start_node"
+    END_NODE = "end_node"
+    CALLBACK = "callback"
+
+@dataclass
+class GraphEvent:
+    """A graph event emitted for specific graph events such as start node or end node,
+    and used by the callback to emit user-defined events.
+
+    :param type: The type of event, can be start_node, end_node, or callback.
+    :type type: GraphEventType
+    :param identifier: The identifier of the event, this is set typically by a callback
+        handler and can be used to distinguish between different events. For example, a
+        conversation/session ID could be used.
+    :type identifier: str
+    :param token: The token associated with the event, such as LLM streamed output.
+    :type token: str | None
+    :param params: The parameters associated with the event, such as tool call parameters
+        or event metadata.
+    :type params: dict[str, Any] | None
+    """
+    type: GraphEventType
+    identifier: str
+    token: str | None = None
+    params: dict[str, Any] | None = None
+
+
 class Callback:
+    """The original callback handler class. Outputs a stream of structured text
+    tokens. It is recommended to use the newer `EventCallback` handler instead.
+    """
     identifier: str = Field(
         default="graphai",
         description=(
@@ -67,6 +107,11 @@ class Callback:
         special_token_format: str = "<{identifier}:{token}:{params}>",
         token_format: str = "{token}",
     ):
+        warnings.warn(
+            "The `Callback` class is deprecated and will be removed in " +
+            "v0.1.0. Use the `EventCallback` class instead.",
+            DeprecationWarning
+        )
         self.identifier = identifier
         self.special_token_format = special_token_format
         self.token_format = token_format
@@ -198,3 +243,100 @@ class Callback:
         return self.special_token_format.format(
             identifier=identifier, token=name, params=params_str
         )
+
+
+class EventCallback(Callback):
+    """The event callback handler class. Outputs a stream of structured text
+    tokens. It is recommended to use the newer `EventCallback` handler instead.
+    """
+    def __init__(
+        self,
+        identifier: str = "graphai",
+        special_token_format: str | None = None,
+        token_format: str | None = None,
+    ):
+        warnings.warn(
+            "The `special_token_format` and `token_format` parameters are " +
+            "deprecated and will be removed in v0.1.0.",
+            DeprecationWarning
+        )
+        if special_token_format is None:
+            special_token_format = "<{identifier}:{token}:{params}>"
+        if token_format is None:
+            token_format = "{token}"
+        super().__init__(identifier, special_token_format, token_format)
+        self.events: list[GraphEvent] = []
+
+    def __call__(self, token: str, node_name: str | None = None):
+        if self._done:
+            raise RuntimeError("Cannot add tokens to a closed stream")
+        self._check_node_name(node_name=node_name)
+        event = GraphEvent(type=GraphEventType.CALLBACK, identifier=self.identifier, token=token, params=None)
+        # otherwise we just assume node is correct and send token
+        self.queue.put_nowait(event)
+
+    async def acall(self, token: str, node_name: str | None = None):
+        # TODO JB: do we need to have `node_name` param?
+        if self._done:
+            raise RuntimeError("Cannot add tokens to a closed stream")
+        self._check_node_name(node_name=node_name)
+        event = GraphEvent(type=GraphEventType.CALLBACK, identifier=self.identifier, token=token, params=None)
+        # otherwise we just assume node is correct and send token
+        self.queue.put_nowait(event)
+
+    async def aiter(self) -> AsyncIterator[GraphEvent]:  # type: ignore[override]
+        """Used by receiver to get the tokens from the stream queue. Creates
+        a generator that yields tokens from the queue until the END token is
+        received.
+        """
+        while True:  # Keep going until we see the END token
+            try:
+                if self._done and self.queue.empty():
+                    break
+                token = await self.queue.get()
+                yield token
+                self.queue.task_done()
+                if token.type == GraphEventType.END:
+                    break
+            except asyncio.CancelledError:
+                break
+        self._done = True  # Mark as done after processing all tokens
+
+    async def start_node(self, node_name: str, active: bool = True):
+        """Starts a new node and emits the start token."""
+        if self._done:
+            raise RuntimeError("Cannot start node on a closed stream")
+        self.current_node_name = node_name
+        if self.first_token:
+            self.first_token = False
+        self.active = active
+        if self.active:
+            token = GraphEvent(type=GraphEventType.START_NODE, identifier=self.identifier, token=self.current_node_name, params=None)
+            self.queue.put_nowait(token)
+
+    async def end_node(self, node_name: str):
+        """Emits the end token for the current node."""
+        if self._done:
+            raise RuntimeError("Cannot end node on a closed stream")
+        # self.current_node_name = node_name
+        if self.active:
+            token = GraphEvent(type=GraphEventType.END_NODE, identifier=self.identifier, token=self.current_node_name, params=None)
+            self.queue.put_nowait(token)
+
+    async def close(self):
+        """Close the stream and prevent further tokens from being added.
+        This will send an END token and set the done flag to True.
+        """
+        if self._done:
+            return
+        end_token = GraphEvent(type=GraphEventType.END, identifier=self.identifier)
+        self._done = True  # Set done before putting the end token
+        self.queue.put_nowait(end_token)
+        # Don't wait for queue.join() as it can cause deadlock
+        # The stream will close when aiter processes the END token
+
+    async def _build_special_token(
+        self, name: str, params: dict[str, Any] | None = None
+    ):
+        raise NotImplementedError("This method is not implemented for the `EventCallback` class.")
+

{graphai_lib-0.0.8 → graphai_lib-0.0.9}/graphai/graph.py

@@ -1,8 +1,24 @@
-from typing import Any, Protocol, Type
+from __future__ import annotations
+import asyncio
+from typing import Any, Iterable, Protocol
+from graphlib import TopologicalSorter, CycleError
 from graphai.callback import Callback
 from graphai.utils import logger
 
 
+# to fix mypy error
+class _HasName(Protocol):
+    name: str
+
+
+class GraphError(Exception):
+    pass
+
+
+class GraphCompileError(GraphError):
+    pass
+
+
 class NodeProtocol(Protocol):
     """Protocol defining the interface of a decorated node."""
 
@@ -20,6 +36,26 @@ class NodeProtocol(Protocol):
     ) -> dict[str, Any]: ...
 
 
+def _name_of(x: Any) -> str | None:
+    """Return the node name if x is a str or has .name, else None."""
+    if x is None:
+        return None
+    if isinstance(x, str):
+        return x
+    name = getattr(x, "name", None)
+    return name if isinstance(name, str) else None
+
+
+def _require_name(x: Any, kind: str) -> str:
+    """Like _name_of, but raises a helpful compile error when missing."""
+    s = _name_of(x)
+    if s is None:
+        raise GraphCompileError(
+            f"Edge {kind} must be a node name (str) or object with .name"
+        )
+    return s
+
+
 class Graph:
     def __init__(
         self, max_steps: int = 10, initial_state: dict[str, Any] | None = None
@@ -28,7 +64,7 @@ class Graph:
         self.edges: list[Any] = []
         self.start_node: NodeProtocol | None = None
         self.end_nodes: list[NodeProtocol] = []
-        self.Callback: Type[Callback] = Callback
+        self.Callback: type[Callback] = Callback
         self.max_steps = max_steps
         self.state = initial_state or {}
 
@@ -37,22 +73,22 @@ class Graph:
         """Get the current graph state."""
         return self.state
 
-    def set_state(self, state: dict[str, Any]) -> "Graph":
+    def set_state(self, state: dict[str, Any]) -> Graph:
         """Set the graph state."""
         self.state = state
         return self
 
-    def update_state(self, values: dict[str, Any]) -> "Graph":
+    def update_state(self, values: dict[str, Any]) -> Graph:
         """Update the graph state with new values."""
         self.state.update(values)
         return self
 
-    def reset_state(self) -> "Graph":
+    def reset_state(self) -> Graph:
         """Reset the graph state to an empty dict."""
         self.state = {}
         return self
 
-    def add_node(self, node: NodeProtocol) -> "Graph":
+    def add_node(self, node: NodeProtocol) -> Graph:
         if node.name in self.nodes:
             raise Exception(f"Node with name '{node.name}' already exists.")
         self.nodes[node.name] = node
@@ -68,7 +104,9 @@ class Graph:
             self.end_nodes.append(node)
         return self
 
-    def add_edge(self, source: NodeProtocol | str, destination: NodeProtocol | str) -> "Graph":
+    def add_edge(
+        self, source: NodeProtocol | str, destination: NodeProtocol | str
+    ) -> Graph:
         """Adds an edge between two nodes that already exist in the graph.
 
         Args:
@@ -89,9 +127,7 @@ class Graph:
             else:
                 source_name = str(source)
         if source_node is None:
-            raise ValueError(
-                f"Node with name '{source_name}' not found."
-            )
+            raise ValueError(f"Node with name '{source_name}' not found.")
         # get destination node from graph
         destination_name: str
         if isinstance(destination, str):
@@ -105,9 +141,7 @@ class Graph:
             else:
                 destination_name = str(destination)
         if destination_node is None:
-            raise ValueError(
-                f"Node with name '{destination_name}' not found."
-            )
+            raise ValueError(f"Node with name '{destination_name}' not found.")
         edge = Edge(source_node, destination_node)
         self.edges.append(edge)
         return self
@@ -117,7 +151,7 @@ class Graph:
         sources: list[NodeProtocol],
         router: NodeProtocol,
         destinations: list[NodeProtocol],
-    ) -> "Graph":
+    ) -> Graph:
         if not router.is_router:
             raise TypeError("A router object must be passed to the router parameter.")
         [self.add_edge(source, router) for source in sources]
@@ -125,26 +159,162 @@ class Graph:
             self.add_edge(router, destination)
         return self
 
-    def set_start_node(self, node: NodeProtocol) -> "Graph":
+    def set_start_node(self, node: NodeProtocol) -> Graph:
         self.start_node = node
         return self
 
-    def set_end_node(self, node: NodeProtocol) -> "Graph":
+    def set_end_node(self, node: NodeProtocol) -> Graph:
         self.end_node = node
         return self
 
-    def compile(self) -> "Graph":
-        if not self.start_node:
-            raise Exception("Start node not defined.")
-        if not self.end_nodes:
-            raise Exception("No end nodes defined.")
-        if not self._is_valid():
-            raise Exception("Graph is not valid.")
-        return self
+    def compile(self, *, strict: bool = False) -> Graph:
+        """
+        Validate the graph:
+        - exactly one start node present (or Graph.start_node set)
+        - at least one end node present
+        - all edges reference known nodes
+        - all nodes reachable from the start
+          (optional) **no cycles** when strict=True
+        Returns self on success; raises GraphCompileError otherwise.
+        """
+        # nodes map
+        nodes = getattr(self, "nodes", None)
+        if not isinstance(nodes, dict) or not nodes:
+            raise GraphCompileError("No nodes have been added to the graph")
+
+        start_name: str | None = None
+        # Bind and narrow the attribute for mypy
+        start_node: _HasName | None = getattr(self, "start_node", None)
+        if start_node is not None:
+            start_name = start_node.name
+        else:
+            starts = [
+                name
+                for name, n in nodes.items()
+                if getattr(n, "is_start", False) or getattr(n, "start", False)
+            ]
+            if len(starts) > 1:
+                raise GraphCompileError(f"Multiple start nodes defined: {starts}")
+            if len(starts) == 1:
+                start_name = starts[0]
+
+        if not start_name:
+            raise GraphCompileError("No start node defined")
+
+        # at least one end node
+        if not any(
+            getattr(n, "is_end", False) or getattr(n, "end", False)
+            for n in nodes.values()
+        ):
+            raise GraphCompileError("No end node defined")
+
+        # normalize edges into adjacency {src: set(dst)}
+        raw_edges = getattr(self, "edges", None)
+        adj: dict[str, set[str]] = {name: set() for name in nodes.keys()}
+
+        def _add_edge(src: str, dst: str) -> None:
+            if src not in nodes:
+                raise GraphCompileError(f"Edge references unknown source node: {src}")
+            if dst not in nodes:
+                raise GraphCompileError(
+                    f"Edge from {src} references unknown node(s): ['{dst}']"
+                )
+            adj[src].add(dst)
+
+        if raw_edges is None:
+            pass
+        elif isinstance(raw_edges, dict):
+            for raw_src, dsts in raw_edges.items():
+                src = _require_name(raw_src, "source")
+                dst_iter = (
+                    [dsts]
+                    if isinstance(dsts, (str,)) or getattr(dsts, "name", None)
+                    else list(dsts)
+                )
+                for d in dst_iter:
+                    dst = _require_name(d, "destination")
+                    _add_edge(src, dst)
+        else:
+            # generic iterable of “edge records”
+            try:
+                iterator = iter(raw_edges)
+            except TypeError:
+                raise GraphCompileError("Internal edge map has unsupported type")
+
+            for item in iterator:
+                # (src, dst) OR (src, Iterable[dst])
+                if isinstance(item, (tuple, list)) and len(item) == 2:
+                    raw_src, rhs = item
+                    src = _require_name(raw_src, "source")
+
+                    if isinstance(rhs, str) or getattr(rhs, "name", None):
+                        dst = _require_name(rhs, "destination")
+                        _add_edge(src, rhs)
+                    else:
+                        # assume iterable of dsts (strings or node-like)
+                        try:
+                            for d in rhs:
+                                dst = _require_name(d, "destination")
+                                _add_edge(src, d)
+                        except TypeError:
+                            raise GraphCompileError(
+                                "Edge tuple second item must be a destination or an iterable of destinations"
+                            )
+                    continue
+
+                # Mapping-style: {"source": "...", "destination": "..."} or {"src": "...", "dst": "..."}
+                if isinstance(item, dict):
+                    src = _require_name(item.get("source", item.get("src")), "source")
+                    dst = _require_name(
+                        item.get("destination", item.get("dst")), "destination"
+                    )
+                    _add_edge(src, dst)
+                    continue
+
+                # Object with attributes .source/.destination (or .src/.dst)
+                if hasattr(item, "source") or hasattr(item, "src"):
+                    src = _require_name(
+                        getattr(item, "source", getattr(item, "src", None)), "source"
+                    )
+                    dst = _require_name(
+                        getattr(item, "destination", getattr(item, "dst", None)),
+                        "destination",
+                    )
+                    _add_edge(src, dst)
+                    continue
+
+                # If none matched, this is an unsupported edge record
+                raise GraphCompileError(
+                    "Edges must be dict[str, Iterable[str]] or an iterable of (src, dst), "
+                    "(src, Iterable[dst]), mapping{'source'/'destination'}, or objects with .source/.destination"
+                )
+
+        # reachability from start
+        seen: set[str] = set()
+        stack = [start_name]
+        while stack:
+            cur = stack.pop()
+            if cur in seen:
+                continue
+            seen.add(cur)
+            stack.extend(adj.get(cur, ()))
+
+        unreachable = sorted(set(nodes.keys()) - seen)
+        if unreachable:
+            raise GraphCompileError(f"Unreachable nodes: {unreachable}")
+
+        # optional cycle detection (strict mode)
+        if strict:
+            preds: dict[str, set[str]] = {n: set() for n in nodes.keys()}
+            for s, ds in adj.items():
+                for d in ds:
+                    preds[d].add(s)
+            try:
+                list(TopologicalSorter(preds).static_order())
+            except CycleError as e:
+                raise GraphCompileError("cycle detected in graph (strict mode)") from e
 
-    def _is_valid(self):
-        # Implement validation logic, e.g., checking for cycles, disconnected components, etc.
-        return True
+        return self
 
     def _validate_output(self, output: dict[str, Any], node_name: str):
         if not isinstance(output, dict):
@@ -205,6 +375,32 @@ class Graph:
             del state["callback"]
         return state
 
+    async def execute_many(
+        self, inputs: Iterable[dict[str, Any]], *, concurrency: int = 5
+    ) -> list[Any]:
+        """Execute the graph on many inputs concurrently.
+
+        :param inputs: An iterable of input dicts to feed into the graph.
+        :type inputs: Iterable[dict]
+        :param concurrency: Maximum number of graph executions to run at once.
+        :type concurrency: int
+        :param state: Optional shared state to pass to each execution.
+            If you want isolated state per execution, pass None
+            and the graph's normal semantics will apply.
+        :type state: Optional[Any]
+        :returns: The list of results in the same order as ``inputs``.
+        :rtype: list[Any]
+        """
+
+        sem = asyncio.Semaphore(concurrency)
+
+        async def _run_one(inp: dict[str, Any]) -> Any:
+            async with sem:
+                return await self.execute(input=inp)
+
+        tasks = [asyncio.create_task(_run_one(i)) for i in inputs]
+        return await asyncio.gather(*tasks)
+
     def get_callback(self):
         """Get a new instance of the callback class.
 
@@ -219,7 +415,7 @@ class Graph:
         as the default callback when no callback is passed to the `execute` method.
 
         :param callback_class: The callback class to use as the default callback.
-        :type callback_class: Type[Callback]
+        :type callback_class: type[Callback]
         """
         self.Callback = callback_class
         return self
@@ -249,20 +445,24 @@ class Graph:
             f"No outgoing edge found for current node '{current_node.name}'."
         )
 
-    def visualize(self):
+    def visualize(self, *, save_path: str | None = None):
+        """Render the current graph. If matplotlib is not installed,
+        raise a helpful error telling users to install the viz extra.
+        Optionally save to a file via `save_path`.
+        """
         try:
-            import networkx as nx
-        except ImportError:
+            import matplotlib.pyplot as plt
+        except ImportError as e:
             raise ImportError(
-                "NetworkX is required for visualization. Please install it with 'pip install networkx'."
-            )
+                "Graph visualization requires matplotlib. Install it with: `pip install matplotlib`"
+            ) from e
 
         try:
-            import matplotlib.pyplot as plt
-        except ImportError:
+            import networkx as nx
+        except ImportError as e:
             raise ImportError(
-                "Matplotlib is required for visualization. Please install it with 'pip install matplotlib'."
-            )
+                "NetworkX is required for visualization. Please install it with `pip install networkx`."
+            ) from e
 
         G: Any = nx.DiGraph()
 
@@ -328,8 +528,12 @@ class Graph:
             arrowsize=20,
         )
 
-        plt.axis("off")
-        plt.show()
+        if save_path:
+            plt.savefig(save_path, bbox_inches="tight")
+        else:
+            plt.axis("off")
+            plt.show()
+        plt.close()
 
 
 class Edge:

{graphai_lib-0.0.8 → graphai_lib-0.0.9}/graphai/utils.py

@@ -1,9 +1,18 @@
+from enum import Enum
 import inspect
 import os
-from typing import Any, Callable
+import sys
+from typing import Any, Callable, Union, get_args, get_origin
 from pydantic import BaseModel, Field
+from pydantic_core import PydanticUndefined
 import logging
-import sys
+
+
+# we support python 3.10 so we define our own StrEnum (introduced in 3.11)
+class StrEnum(str, Enum):
+    """Backport of StrEnum for Python < 3.11"""
+    def __str__(self):
+        return self.value
 
 
 class ColoredFormatter(logging.Formatter):
@@ -119,6 +128,9 @@ class Parameter(BaseModel):
             }
         }
 
+class OpenAIAPI(StrEnum):
+    COMPLETIONS = "completions"
+    RESPONSES = "responses"
 
 class FunctionSchema(BaseModel):
     """Class that consumes a function and can return a schema required by
@@ -167,29 +179,95 @@ class FunctionSchema(BaseModel):
         )
 
     @classmethod
-    def from_pydantic(cls, model: BaseModel) -> "FunctionSchema":
+    def from_pydantic(cls, model: type[BaseModel]) -> "FunctionSchema":
+        """Create a FunctionSchema from a Pydantic model class.
+        
+        :param model: The Pydantic model class to convert
+        :type model: type[BaseModel]
+        :return: FunctionSchema instance
+        :rtype: FunctionSchema
+        """
+        # Extract model metadata
+        name = model.__name__
+        description = model.__doc__ or ""
+        
+        # Build parameters list
+        parameters = []
         signature_parts = []
-        for field_name, field_model in model.__annotations__.items():
-            field_info = model.model_fields[field_name]
-            default_value = field_info.default
-            if default_value:
-                default_repr = repr(default_value)
-                signature_part = (
-                    f"{field_name}: {field_model.__name__} = {default_repr}"
+        
+        for field_name, field_info in model.model_fields.items():
+            # Get the field type
+            field_type = model.__annotations__.get(field_name)
+            
+            # Determine the type name - handle Optional and other generic types
+            type_name = str(field_type)
+            
+            # Try to extract the actual type from Optional[T] -> T
+            origin = get_origin(field_type)
+            args = get_args(field_type)
+            
+            if origin is Union:
+                # This is likely Optional[T] which is Union[T, None]
+                non_none_types = [arg for arg in args if arg is not type(None)]
+                if non_none_types:
+                    actual_type = non_none_types[0]
+                    if hasattr(actual_type, '__name__'):
+                        type_name = actual_type.__name__
+                    else:
+                        type_name = str(actual_type)
+            elif field_type and hasattr(field_type, '__name__'):
+                type_name = field_type.__name__
+            
+            # Check if field is required (no default value)
+            # In Pydantic v2, PydanticUndefined means no default
+            is_required = (
+                field_info.default is PydanticUndefined 
+                and field_info.default_factory is None
+            )
+            
+            # Get the actual default value
+            if field_info.default is not PydanticUndefined and field_info.default is not None:
+                default_value = field_info.default
+            elif field_info.default_factory is not None:
+                # For default_factory, we can't always call it without arguments
+                # Just use a placeholder to indicate there's a factory
+                try:
+                    # Try calling with no arguments (common case)
+                    default_value = field_info.default_factory()  # type: ignore[call-arg]
+                except TypeError:
+                    # If it needs arguments, just indicate it has a factory default
+                    default_value = "<factory>"
+            else:
+                default_value = inspect.Parameter.empty
+            
+            # Add parameter
+            parameters.append(
+                Parameter(
+                    name=field_name,
+                    description=field_info.description,
+                    type=type_name,
+                    default=default_value,
+                    required=is_required,
                 )
+            )
+            
+            # Build signature part
+            if default_value != inspect.Parameter.empty:
+                signature_parts.append(f"{field_name}: {type_name} = {repr(default_value)}")
             else:
-                signature_part = f"{field_name}: {field_model.__name__}"
-            signature_parts.append(signature_part)
-        signature = f"({', '.join(signature_parts)}) -> str"
+                signature_parts.append(f"{field_name}: {type_name}")
+        
+        signature = f"({', '.join(signature_parts)}) -> dict"
+        
         return cls.model_construct(
-            name=model.__class__.__name__,
-            description=model.__doc__ or "",
+            name=name,
+            description=description,
             signature=signature,
-            output="",  # TODO: Implement output
-            parameters=[],
+            output="dict",
+            parameters=parameters,
         )
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         schema_dict = {
             "type": "function",
             "function": {
@@ -210,14 +288,42 @@ class FunctionSchema(BaseModel):
         }
         return schema_dict
 
-    def to_openai(self) -> dict:
-        return self.to_dict()
+    def to_openai(self, api: OpenAIAPI=OpenAIAPI.COMPLETIONS) -> dict[str, Any]:
+        """Convert the function schema into OpenAI-compatible formats. Supports
+        both completions and responses APIs.
+
+        :param api: The API to convert to.
+        :type api: OpenAIAPI
+        :return: The function schema in OpenAI-compatible format.
+        :rtype: dict
+        """
+        if api == "completions":
+            return self.to_dict()
+        elif api == "responses":
+            return {
+                "type": "function",
+                "name": self.name,
+                "description": self.description,
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        k: v
+                        for param in self.parameters
+                        for k, v in param.to_dict().items()
+                    },
+                    "required": [
+                        param.name for param in self.parameters if param.required
+                    ],
+                },
+            }
+        else:
+            raise ValueError(f"Unrecognized OpenAI API: {api}")
 
 
 DEFAULT = set(["default", "openai", "ollama", "litellm"])
 
 
-def get_schemas(callables: list[Callable], format: str = "default") -> list[dict]:
+def get_schemas(callables: list[Callable], format: str = "default") -> list[dict[str, Any]]:
     if format in DEFAULT:
         return [
             FunctionSchema.from_callable(callable).to_dict() for callable in callables

{graphai_lib-0.0.8 → graphai_lib-0.0.9}/graphai_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphai-lib
-Version: 0.0.8
+Version: 0.0.9
 Summary: Not an AI framework
 Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown

{graphai_lib-0.0.8 → graphai_lib-0.0.9}/graphai_lib.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ pyproject.toml
 graphai/__init__.py
 graphai/callback.py
 graphai/graph.py
+graphai/py.typed
 graphai/utils.py
 graphai/nodes/__init__.py
 graphai/nodes/base.py

{graphai_lib-0.0.8 → graphai_lib-0.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "graphai-lib"
-version = "0.0.8"
+version = "0.0.9"
 description = "Not an AI framework"
 readme = "README.md"
 requires-python = ">=3.10,<3.14"
@@ -29,6 +29,9 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools]
 packages = ["graphai", "graphai.nodes"]
 
+[tool.setuptools.package-data]
+graphai = ["py.typed"]
+
 [tool.mypy]
 python_version = "3.10"
 warn_return_any = true