fiddler-langgraph 0.1.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

fiddler_langgraph/VERSION

@@ -1 +1 @@
-0.1.1
+1.0.0

fiddler_langgraph/core/attributes.py

@@ -3,8 +3,6 @@
 import contextvars
 from typing import Any
 
-from pydantic import ConfigDict, validate_call
-
 # Key used for storing Fiddler-specific attributes in metadata dictionary
 FIDDLER_METADATA_KEY = '_fiddler_attributes'
 
@@ -66,22 +64,3 @@ _CONVERSATION_ID: contextvars.ContextVar[str] = contextvars.ContextVar(
 _CUSTOM_ATTRIBUTES: contextvars.ContextVar[dict[str, Any]] = contextvars.ContextVar(
     '_CUSTOM_ATTRIBUTES'
 )
-
-
-@validate_call(config=ConfigDict(strict=True, arbitrary_types_allowed=True))
-def add_session_attributes(key: str, value: str) -> None:
-    """Adds Fiddler-specific attributes to a runnable's metadata.
-
-    This is used for various runnable types like Pregel nodes, LLM calls, tool
-    calls, and retriever calls.
-
-    Args:
-        key (str): The attribute key to add or update.
-        value (str): The attribute value to set.
-    """
-    try:
-        current_attributes = _CUSTOM_ATTRIBUTES.get().copy()
-    except LookupError:
-        current_attributes = {}
-    current_attributes[key] = value
-    _CUSTOM_ATTRIBUTES.set(current_attributes)

fiddler_langgraph/core/client.py

@@ -60,7 +60,7 @@ class FiddlerClient:
         self,
         api_key: str,
         application_id: str,
-        url: str = 'http://localhost:4318',
+        url: str,
         console_tracer: bool = False,
         span_limits: SpanLimits | None = _default_span_limits,
         sampler: sampling.Sampler | None = None,
@@ -76,41 +76,69 @@ class FiddlerClient:
         Args:
             api_key (str): The API key for authenticating with the Fiddler backend. **Required**.
             application_id (str): The unique identifier (UUID4) for the application. **Required**.
-            url (str): The base URL for the Fiddler backend. While it defaults to
-                `http://localhost:4318` for local development, this **must** be set to your
-                Fiddler instance URL for any other use.
+            url (str): The base URL for your Fiddler instance. This is specific to your
+                deployment, whether hosted, VPC-deployed, on-premise, or local development
+                (e.g., `https://your-instance.fiddler.ai`, `http://localhost:4318`). **Required**.
             console_tracer (bool): If True, traces will be printed to the console
                 instead of being sent to the Fiddler backend. Useful for debugging.
                 Defaults to `False`.
             span_limits (SpanLimits | None): Configuration for span limits, such as the
                 maximum number of attributes or events. Defaults to a restrictive
-                set of internal limits.
+                set of internal limits (32 events/links/attributes, 2048 char limit).
             sampler (sampling.Sampler | None): The sampler for deciding which spans to record.
-                Defaults to `None`, which uses the parent-based OpenTelemetry sampler.
+                Defaults to `None`, which uses the parent-based always-on OpenTelemetry sampler
+                (100% sampling).
             compression (Compression): The compression for exporting traces.
-                Can be `Compression.Gzip` or `Compression.NoCompression`.
-                Defaults to `Compression.Gzip`.
+                Can be `Compression.Gzip`, `Compression.Deflate`, or `Compression.NoCompression`.
+                Defaults to `Compression.Gzip` (recommended for production).
             jsonl_capture_enabled (bool): Whether to enable JSONL capture of trace data.
                 When enabled, all span data will be captured and saved to a JSONL file
-                in OpenTelemetry format for analysis. Defaults to `False`.
+                in OpenTelemetry format for offline analysis. Defaults to `False`.
             jsonl_file_path (str): Path to the JSONL file where trace data will be saved.
                 Only used when `jsonl_capture_enabled` is `True`. Defaults to
                 "fiddler_trace_data.jsonl".
 
         Raises:
             ValueError: If `application_id` is not a valid UUID4 or if the
-                `url` is not a valid HTTPS URL.
+                `url` is not a valid HTTP/HTTPS URL.
 
         Examples:
-            >>> from opentelemetry.sdk.trace import SpanLimits
-            >>> from fiddler_langgraph import FiddlerClient
-            >>>
-            >>> client = FiddlerClient(
-            ...     api_key='YOUR_API_KEY',
-            ...     application_id='YOUR_APPLICATION_ID',
-            ...     url='https://your-fiddler-instance.fiddler.ai',
-            ...     span_limits=SpanLimits(max_span_attributes=64),
-            ... )
+            Basic connection to your Fiddler instance:
+
+            .. code-block:: python
+
+                client = FiddlerClient(
+                    api_key='YOUR_API_KEY',
+                    application_id='YOUR_APPLICATION_ID',
+                    url='https://your-instance.fiddler.ai',
+                )
+
+            High-volume applications with custom configuration:
+
+            .. code-block:: python
+
+                from opentelemetry.sdk.trace import SpanLimits, sampling
+                from opentelemetry.exporter.otlp.proto.http.trace_exporter import Compression
+
+                client = FiddlerClient(
+                    api_key='YOUR_API_KEY',
+                    application_id='YOUR_APPLICATION_ID',
+                    url='https://your-instance.fiddler.ai',
+                    span_limits=SpanLimits(max_span_attributes=64),
+                    sampler=sampling.TraceIdRatioBased(0.1),  # Sample 10% of traces
+                    compression=Compression.Gzip,
+                )
+
+            Local development with console output:
+
+            .. code-block:: python
+
+                client = FiddlerClient(
+                    api_key='dev-key',
+                    application_id='00000000-0000-0000-0000-000000000000',
+                    url='http://localhost:4318',
+                    console_tracer=True,  # Print traces to console for debugging
+                )
         """
         # Validate application_id is a valid UUID4
 
@@ -216,9 +244,11 @@ class FiddlerClient:
             ValueError: If the tracer has already been initialized.
 
         Examples:
-            >>> from fiddler_langgraph import FiddlerClient
-            >>> client = FiddlerClient(api_key='...', application_id='...')
-            >>> client.update_resource({'service.version': '1.2.3'})
+            .. code-block:: python
+
+                from fiddler_langgraph import FiddlerClient
+                client = FiddlerClient(api_key='...', application_id='...', url='https://your-instance.fiddler.ai')
+                client.update_resource({'service.version': '1.2.3'})
         """
         if self._tracer is not None:
             raise ValueError('Cannot update resource after tracer is initialized')
@@ -305,11 +335,13 @@ class FiddlerClient:
             RuntimeError: If tracer initialization fails.
 
         Examples:
-            >>> from fiddler_langgraph import FiddlerClient
-            >>> client = FiddlerClient(api_key='...', application_id='...')
-            >>> tracer = client.get_tracer()
-            >>> with tracer.start_as_current_span('my-operation'):
-            ...     print('Doing some work...')
+            .. code-block:: python
+
+                from fiddler_langgraph import FiddlerClient
+                client = FiddlerClient(api_key='...', application_id='...', url='https://your-instance.fiddler.ai')
+                tracer = client.get_tracer()
+                with tracer.start_as_current_span('my-operation'):
+                    print('Doing some work...')
         """
         if self._tracer is None:
             self._initialize_tracer()

fiddler_langgraph/tracing/instrumentation.py

@@ -16,6 +16,7 @@ from wrapt import wrap_function_wrapper
 
 from fiddler_langgraph.core.attributes import (
     _CONVERSATION_ID,
+    _CUSTOM_ATTRIBUTES,
     FIDDLER_METADATA_KEY,
     FiddlerSpanAttributes,
 )
@@ -26,13 +27,98 @@ from fiddler_langgraph.tracing.util import _check_langgraph_version, _get_packag
 
 @validate_call(config=ConfigDict(strict=True))
 def set_conversation_id(conversation_id: str) -> None:
-    """Set the conversation ID for the current application invocation.
+    """Enables end-to-end tracing of multi-step workflows and conversations.
+
+    The primary purpose of set_conversation_id is to enable end-to-end tracing
+    of a multi-step workflow. Modern agentic applications often involve a complex
+    sequence of events to fulfill a single user request. The result in your Fiddler
+    dashboard is that you can instantly filter for and view the entire, ordered
+    sequence of operations that constituted a single conversation or task. This is
+    crucial for debugging complex failures, analyzing latency across an entire
+    workflow, and understanding the agent's behavior from start to finish.
+
     This will remain in use until it is called again with a new conversation ID.
-    Note (Robin 11th Sep 2025): This should be moved to the core.attributes module in the future.
+
+    Args:
+        conversation_id (str): Unique identifier for the conversation session. **Required**.
+
+    Returns:
+        None
+
+    Examples:
+        .. code-block:: python
+
+            from langgraph.prebuilt import create_react_agent
+            from fiddler_langgraph.tracing.instrumentation import set_conversation_id
+            import uuid
+
+            # Basic usage
+            agent = create_react_agent(model, tools=[])
+            conversation_id = str(uuid.uuid4())
+            set_conversation_id(conversation_id)
+            agent.invoke({"messages": [{"role": "user", "content": "Write me a novel"}]})
+
+            # Multi-turn conversation tracking
+            def handle_conversation(user_id, session_id):
+                # Create a unique conversation ID combining user and session
+                conversation_id = f"{user_id}_{session_id}_{uuid.uuid4()}"
+                set_conversation_id(conversation_id)
+                return conversation_id
+
+            # Different conversation types
+            business_conversation_id = f"business_{uuid.uuid4()}"
+            support_conversation_id = f"support_{uuid.uuid4()}"
     """
     _CONVERSATION_ID.set(conversation_id)
 
 
+@validate_call(config=ConfigDict(strict=True, arbitrary_types_allowed=True))
+def add_session_attributes(key: str, value: str) -> None:
+    """Adds custom session-level attributes that persist across all spans in the current context.
+
+    Session attributes are key-value pairs that apply to all operations within the current
+    execution context (thread or async coroutine). Use this to add metadata that describes
+    the session environment, such as user information, deployment environment, or feature flags.
+
+    These attributes are stored in context variables and automatically included in all spans
+    created during the session. They persist until the context ends or the attribute is updated
+    with a new value.
+
+    Note: Context variables are shallow copied - modifications to mutable values (lists, dicts)
+    are shared between contexts.
+
+    Args:
+        key (str): The attribute key to add or update. Will be formatted as
+            'fiddler.session.user.{key}' in the OpenTelemetry span. **Required**.
+        value (str): The attribute value to set. **Required**.
+
+    Returns:
+        None
+
+    Examples:
+        .. code-block:: python
+
+            from fiddler_langgraph.tracing.instrumentation import add_session_attributes
+
+            # Add user information to all spans in this session
+            add_session_attributes("user_id", "user_12345")
+            add_session_attributes("tier", "premium")
+
+            # Add deployment environment context
+            add_session_attributes("environment", "production")
+            add_session_attributes("region", "us-west-2")
+
+            # Update an existing attribute
+            add_session_attributes("user_id", "user_67890")  # Overwrites previous value
+    """
+    try:
+        current_attributes = _CUSTOM_ATTRIBUTES.get().copy()
+    except LookupError:
+        current_attributes = {}
+    current_attributes[key] = value
+    _CUSTOM_ATTRIBUTES.set(current_attributes)
+
+
 @validate_call(config=ConfigDict(strict=True, arbitrary_types_allowed=True))
 def _set_default_metadata(
     node: BaseLanguageModel | BaseRetriever | BaseTool,
@@ -59,14 +145,137 @@ def add_span_attributes(
     node: BaseLanguageModel | BaseRetriever | BaseTool,
     **kwargs: Any,
 ) -> None:
-    """Adds Fiddler-specific attributes to a runnable's metadata.
+    """Adds custom span-level attributes to a specific runnable component's metadata.
+
+    Span attributes are key-value pairs that apply to a specific component (LLM, tool, or retriever)
+    and are included in the OpenTelemetry spans created when that component executes. Use this to
+    add metadata that describes the component's configuration, purpose, or operational context.
+
+    Unlike session attributes (which apply to all spans in a context), span attributes are scoped
+    to individual components. This is useful for:
+    - Identifying which model or tool is being used
+    - Tagging components by purpose or category
+    - Adding version information or deployment metadata
+    - Tracking A/B test variants or experimental configurations
 
-    This is used for various runnable types like LLM calls, tool
-    calls, and retriever calls.
+    The attributes are stored in the component's metadata dictionary under the key
+    '_fiddler_attributes' and will be automatically included in spans when the component executes.
+    Attributes persist for the lifetime of the component instance.
+
+    Supported component types:
+    - **BaseLanguageModel**: LLM calls (ChatOpenAI, ChatAnthropic, etc.)
+    - **BaseRetriever**: Document retrieval operations
+    - **BaseTool**: Tool/function calls in agent workflows
 
     Args:
-        node (BaseLanguageModel | BaseRetriever | BaseTool): The runnable node.
-        **kwargs: The attributes to add as key-value pairs.
+        node (BaseLanguageModel | BaseRetriever | BaseTool): The LangChain component to annotate
+            with custom attributes. The component's metadata will be modified in place. **Required**.
+        **kwargs (Any): Arbitrary keyword arguments representing the attributes to add. Each
+            key-value pair will be stored as a span attribute. Keys should be strings, and values
+            can be any type (though simple types like str, int, bool are recommended for
+            observability). **Required** (at least one attribute).
+
+    Returns:
+        None
+
+    Examples:
+        Tagging an LLM with model information:
+
+        .. code-block:: python
+
+            from langchain_openai import ChatOpenAI
+            from fiddler_langgraph.tracing.instrumentation import add_span_attributes
+
+            llm = ChatOpenAI(model="gpt-4")
+            add_span_attributes(
+                llm,
+                model_name="gpt-4",
+                provider="openai",
+                purpose="summarization"
+            )
+
+        Adding version and environment metadata:
+
+        .. code-block:: python
+
+            add_span_attributes(
+                llm,
+                version="v2.1.0",
+                environment="production",
+                region="us-west-2"
+            )
+
+        Tagging tools in a multi-tool agent:
+
+        .. code-block:: python
+
+            from langchain.tools import Tool
+
+            search_tool = Tool(
+                name="search",
+                func=search_function,
+                description="Search the web"
+            )
+            add_span_attributes(
+                search_tool,
+                tool_category="external_api",
+                rate_limit="100/min",
+                cost_per_call=0.001
+            )
+
+        A/B testing different retrievers:
+
+        .. code-block:: python
+
+            from langchain_community.vectorstores import FAISS
+
+            retriever_a = FAISS.from_documents(docs, embeddings).as_retriever()
+            add_span_attributes(
+                retriever_a,
+                variant="semantic_search",
+                experiment_id="exp_2024_q1",
+                retrieval_strategy="similarity"
+            )
+
+            retriever_b = FAISS.from_documents(docs, embeddings).as_retriever(
+                search_type="mmr"
+            )
+            add_span_attributes(
+                retriever_b,
+                variant="mmr_search",
+                experiment_id="exp_2024_q1",
+                retrieval_strategy="maximum_marginal_relevance"
+            )
+
+        Combining with session attributes:
+
+        .. code-block:: python
+
+            from fiddler_langgraph.tracing.instrumentation import (
+                add_session_attributes,
+                add_span_attributes,
+                set_conversation_id
+            )
+
+            # Session-level: applies to all spans
+            set_conversation_id("conv_12345")
+            add_session_attributes("user_id", "user_789")
+
+            # Span-level: applies only to this LLM's spans
+            llm = ChatOpenAI(model="gpt-4-turbo")
+            add_span_attributes(
+                llm,
+                model_tier="premium",
+                use_case="customer_support"
+            )
+
+    Note:
+        - Attributes are stored in the component's `metadata` dictionary, which persists
+          for the lifetime of the component instance
+        - If the component doesn't have a `metadata` attribute, one will be created
+        - Multiple calls to `add_span_attributes` on the same component will merge attributes
+        - Later calls with the same key will overwrite previous values
+        - This modifies the component in place - no need to reassign the return value
     """
     _set_default_metadata(node)
     metadata = cast(dict[str, Any], node.metadata)
@@ -77,33 +286,60 @@ def add_span_attributes(
 
 @validate_call(config=ConfigDict(strict=True))
 def set_llm_context(llm: BaseLanguageModel | RunnableBinding, context: str) -> None:
-    """Sets a context string on a language model instance.
-    If the language model is a RunnableBinding, the context will be set on the bound object.
+    """Sets additional context information on a language model instance.
 
-    https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.base.RunnableBinding.html
+    This context provides environmental or operational information that will be
+    attached to all spans created for this model. Use this to add relevant metadata
+    such as user preferences, session state, or runtime conditions that influenced
+    the LLM's behavior. This is valuable for debugging and understanding why the
+    model produced specific outputs.
 
-    The bound object of the RunnableBinding must be a BaseLanguageModel.
-    This context can be used to provide additional information about the
-    environment or data that the language model is being used in. This
-    information will be attached to the spans created for this model.
-    In case the user passes a RunnableBinding, the context will be set on the
-    bound object.
+    Supports both `BaseLanguageModel` instances and `RunnableBinding` objects. When a
+    `RunnableBinding` is provided, the context is automatically set on the underlying
+    bound object (which must be a `BaseLanguageModel`).
+
+    For more information on RunnableBinding, see:
+    https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.base.RunnableBinding.html
 
     Args:
-        llm (BaseLanguageModel | RunnableBinding): The language model instance. **Required**.
-        context (str): The context string to add. **Required**.
+        llm (BaseLanguageModel | RunnableBinding): The language model instance or binding. **Required**.
+        context (str): The context string to add. This will be included in span attributes
+            as 'gen_ai.llm.context'. **Required**.
+
+    Raises:
+        TypeError: If a RunnableBinding is provided but its bound object is not a BaseLanguageModel.
 
     Examples:
-        >>> from langchain_openai import ChatOpenAI
-        >>> from fiddler_langgraph.tracing.instrumentation import set_llm_context
-        >>>
-        >>> llm = ChatOpenAI()
-        >>> set_llm_context(llm, "This is a test context.")
-        >>>
-        >>> # If you are using a RunnableBinding, you can pass the bound object
-        >>> # directly to set_llm_context.
-        >>> bound_llm = llm.bind(x=1)
-        >>> set_llm_context(bound_llm, "This is a test context.")
+        Basic usage with ChatOpenAI:
+
+        .. code-block:: python
+
+            from langchain_openai import ChatOpenAI
+            from fiddler_langgraph.tracing.instrumentation import set_llm_context
+
+            llm = ChatOpenAI(model="gpt-4")
+            set_llm_context(llm, "User prefers concise responses")
+
+        With user preferences:
+
+        .. code-block:: python
+
+            set_llm_context(llm, "User language: Spanish, Expertise: Beginner")
+
+        Using with RunnableBinding:
+
+        .. code-block:: python
+
+            bound_llm = llm.bind(temperature=0.7, max_tokens=100)
+            set_llm_context(bound_llm, "Creative writing mode with token limits")
+
+        Adding session context:
+
+        .. code-block:: python
+
+            import uuid
+            session_id = uuid.uuid4()
+            set_llm_context(llm, f"Session: {session_id}, Environment: Production")
     """
     if isinstance(llm, RunnableBinding):
         if not isinstance(llm.bound, BaseLanguageModel):
@@ -129,22 +365,58 @@ class LangGraphInstrumentor(BaseInstrumentor):
 
     This class provides automatic instrumentation for applications built with
     LangGraph. It captures traces from the execution of LangGraph graphs and
-    sends them to the Fiddler platform.
+    sends them to the Fiddler platform for monitoring and analysis.
+
+    Instrumentation works by monkey-patching LangChain's callback system to inject
+    a custom callback handler that captures trace data. Once instrumented, all
+    LangGraph operations will automatically generate telemetry data.
+
+    Note: Instrumentation persists for the lifetime of the application unless
+    explicitly removed by calling `uninstrument()`. Calling `instrument()` multiple
+    times is safe - it will not create duplicate handlers.
+
+    Thread Safety: The instrumentation applies globally to the process and affects
+    all threads. In concurrent environments (multi-threading, async), all contexts
+    share the same instrumented callback system.
 
     To use the instrumentor, you first need to create a `FiddlerClient`
     instance. Then, you can create an instance of `LangGraphInstrumentor` and
     call the `instrument()` method.
 
     Examples:
-        >>> from fiddler_langgraph import FiddlerClient
-        >>> from fiddler_langgraph.tracing import LangGraphInstrumentor
-        >>>
-        >>> client = FiddlerClient(api_key="...", application_id="...")
-        >>> instrumentor = LangGraphInstrumentor(client=client)
-        >>> instrumentor.instrument()
+        Basic usage:
+
+        .. code-block:: python
+
+            from fiddler_langgraph import FiddlerClient
+            from fiddler_langgraph.tracing import LangGraphInstrumentor
+
+            client = FiddlerClient(api_key="...", application_id="...", url="https://your-instance.fiddler.ai")
+            instrumentor = LangGraphInstrumentor(client=client)
+            instrumentor.instrument()
+
+        Removing instrumentation:
+
+        .. code-block:: python
+
+            # Clean up instrumentation when shutting down
+            instrumentor.uninstrument()
+
+        Context manager pattern (advanced):
+
+        .. code-block:: python
+
+            with LangGraphInstrumentor(client).instrument():
+                # Instrumented operations here
+                agent.invoke({"messages": [...]})
+            # Automatically uninstrumented after block
 
     Attributes:
         _client (FiddlerClient): The FiddlerClient instance used for configuration.
+        _tracer (_CallbackHandler | None): The callback handler instance for tracing.
+        _langgraph_version: The installed LangGraph version.
+        _langchain_version: The installed LangChain Core version.
+        _fiddler_langgraph_version: The Fiddler LangGraph SDK version.
     """
 
     def __init__(self, client: FiddlerClient):

{fiddler_langgraph-0.1.1.dist-info → fiddler_langgraph-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fiddler-langgraph
-Version: 0.1.1
+Version: 1.0.0
 Summary: Python SDK for instrumenting GenAI Applications with Fiddler
 Author-email: Fiddler AI <support@fiddler.ai>
 License-Expression: Apache-2.0
@@ -82,7 +82,7 @@ from fiddler_langgraph import FiddlerClient
 
 # Initialize the FiddlerClient with basic configuration
 client = FiddlerClient(
-    url="https://api.fiddler.ai",
+    url="https://your-instance.fiddler.ai",
     api_key="fdl_api_key",
     application_id="fdl_application_id"  # Must be a valid UUID4
 )
@@ -147,7 +147,7 @@ The Fiddler SDK provides flexible configuration options for OpenTelemetry integr
 client = FiddlerClient(
     api_key="your-api-key",
     application_id="your-app-id",  # Must be a valid UUID4
-    url="https://api.fiddler.ai"
+    url="https://your-instance.fiddler.ai"
 )
 ```
 
@@ -173,6 +173,7 @@ sampler = sampling.TraceIdRatioBased(0.1)  # Sample 10% of traces
 client = FiddlerClient(
     api_key="your-api-key",
     application_id="your-app-id",
+    url="https://your-instance.fiddler.ai",
     span_limits=custom_limits,
     sampler=sampler,
     console_tracer=False,  # Set to True for debugging
@@ -191,6 +192,7 @@ from opentelemetry.exporter.otlp.proto.http.trace_exporter import Compression
 client = FiddlerClient(
     api_key="your-api-key",
     application_id="your-app-id",
+    url="https://your-instance.fiddler.ai",
     compression=Compression.Gzip,
 )
 
@@ -198,6 +200,7 @@ client = FiddlerClient(
 client = FiddlerClient(
     api_key="your-api-key",
     application_id="your-app-id",
+    url="https://your-instance.fiddler.ai",
     compression=Compression.NoCompression,
 )
 
@@ -205,6 +208,7 @@ client = FiddlerClient(
 client = FiddlerClient(
     api_key="your-api-key",
     application_id="your-app-id",
+    url="https://your-instance.fiddler.ai",
     compression=Compression.Deflate,
 )
 ```
@@ -224,7 +228,8 @@ os.environ['OTEL_BSP_EXPORT_TIMEOUT'] = '10000'
 
 client = FiddlerClient(
     api_key="your-api-key",
-    application_id="your-app-id"
+    application_id="your-app-id",
+    url="https://your-instance.fiddler.ai"
 )
 ```
 

{fiddler_langgraph-0.1.1.dist-info → fiddler_langgraph-1.0.0.dist-info}/RECORD

@@ -1,15 +1,15 @@
-fiddler_langgraph/VERSION,sha256=gERzFlKfxiAU-6oEf7Z8Uaww4ygwzaNwQFNJ2NZtGWw,6
+fiddler_langgraph/VERSION,sha256=WYVJhIUxBN9cNT4vaBoV_HkkdC-aLkaMKa8kjc5FzgM,6
 fiddler_langgraph/__init__.py,sha256=cqomWAmuY-2KvwJTvo7c7cecCPoe31pv4vgyBk_E8oQ,315
 fiddler_langgraph/core/__init__.py,sha256=HXPZt8YpmVrvwEEukoWR78LufMKtl7lVjLtcl9UNSoc,42
-fiddler_langgraph/core/attributes.py,sha256=Kj2p03gzuaVWhgd4odm15xMP-FbYSDA5aBi-dvEtgkA,2864
-fiddler_langgraph/core/client.py,sha256=qgDsMI_bBVSV-75tLjnM0of0i464g9KyeUljiccRkIE,13658
+fiddler_langgraph/core/attributes.py,sha256=TbTwr8WtmJpDDRgTP8S3wD3ZHc3wwGJK1lu3vHal3mY,2169
+fiddler_langgraph/core/client.py,sha256=Fn4sPiTfAF1i375Qg_9DYwD0wAT65K6j3M9luyTVKPE,14948
 fiddler_langgraph/core/span_processor.py,sha256=ODYmdo0FUYEFbIWS_VaR9L6qHUVvpnuk-RSIhgRxyb0,1164
 fiddler_langgraph/tracing/__init__.py,sha256=Kw8VUB7RDffBq4ss0v6vNQYi4KDQOM0J1elbMrqJpsU,49
 fiddler_langgraph/tracing/callback.py,sha256=oI6Zpbfe50mGu85NArd8rXxOyYvOKUV4fY--EBnlQlo,31264
-fiddler_langgraph/tracing/instrumentation.py,sha256=LHCYW6asySajbF-sOOi6_6J7UBD6z1Vwp4QjHP9zzt0,10580
+fiddler_langgraph/tracing/instrumentation.py,sha256=AlCM9GWp3qN_Fa9cl-USJjrUhuvKmrLokzkLMgah-CY,21142
 fiddler_langgraph/tracing/jsonl_capture.py,sha256=7Sy0nbxRftV5y64UCovSlm07qXn-EfG3uHpBu9H2ZiU,8174
 fiddler_langgraph/tracing/util.py,sha256=RKMrrmdCXSRJrTIHngdhRsotPLEY_LR1SKnUXAJC40Y,2678
-fiddler_langgraph-0.1.1.dist-info/METADATA,sha256=79J7iKAC1ZqCwGp1guUDNWZfjzM-5LSf03x1HBqwfVg,10184
-fiddler_langgraph-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fiddler_langgraph-0.1.1.dist-info/top_level.txt,sha256=hOKdR6_3AkS4dS6EfE9Ii7YrS_hApnyGfY-0v0DV0s4,18
-fiddler_langgraph-0.1.1.dist-info/RECORD,,
+fiddler_langgraph-1.0.0.dist-info/METADATA,sha256=tfc_l2tf5HwODWFknx1qPfoVOFtfqHQ4GrqvzKPAxgI,10424
+fiddler_langgraph-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fiddler_langgraph-1.0.0.dist-info/top_level.txt,sha256=hOKdR6_3AkS4dS6EfE9Ii7YrS_hApnyGfY-0v0DV0s4,18
+fiddler_langgraph-1.0.0.dist-info/RECORD,,