---
title: prefactor_langchain package
editUrl: true
head: []
template: doc
sidebar:
  hidden: false
  attrs: {}
pagefind: true
draft: false
---

# prefactor_langchain package

Prefactor LangChain - LangChain integration for Prefactor observability.

### *class* prefactor_langchain.AgentSpan(name: str = 'unnamed', start_time: float = <factory>, end_time: float | None = None, status: Literal['pending', 'running', 'completed', 'failed']='pending', inputs: dict[str, ~typing.Any]=<factory>, outputs: dict[str, ~typing.Any] | None=None, metadata: dict[str, ~typing.Any]=<factory>, tags: list[str] = <factory>, error: [ErrorInfo](prefactor_langchain.spans.md#prefactor_langchain.spans.ErrorInfo) | None = None, type: str = 'langchain:agent', agent_name: str | None = None, agent_config: dict[str, ~typing.Any]=<factory>, initial_messages: list[dict[str, ~typing.Any]]=<factory>, final_messages: list[dict[str, ~typing.Any]]=<factory>, iteration_count: int = 0)

Bases: [`LangChainSpan`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan)

Span representing an agent execution.

Captures the lifecycle of an agent run, including the agent’s
name, configuration, and the messages/state that drove the execution.

#### agent_config *: dict[str, Any]*

#### agent_name *: str | None* *= None*

#### final_messages *: list[dict[str, Any]]*

#### initial_messages *: list[dict[str, Any]]*

#### iteration_count *: int* *= 0*

#### to_dict() → dict[str, Any]

Convert to dictionary including agent-specific fields.

#### type *: str* *= 'langchain:agent'*

### *class* prefactor_langchain.ErrorInfo(error_type: str, message: str, stacktrace: str | None = None)

Bases: `object`

Error information for failed spans.

#### error_type *: str*

#### message *: str*

#### stacktrace *: str | None* *= None*

#### to_dict() → dict[str, Any]

Convert to dictionary for serialization.

### *class* prefactor_langchain.LLMSpan(name: str = 'unnamed', start_time: float = <factory>, end_time: float | None = None, status: Literal['pending', 'running', 'completed', 'failed']='pending', inputs: dict[str, ~typing.Any]=<factory>, outputs: dict[str, ~typing.Any] | None=None, metadata: dict[str, ~typing.Any]=<factory>, tags: list[str] = <factory>, error: [ErrorInfo](prefactor_langchain.spans.md#prefactor_langchain.spans.ErrorInfo) | None = None, type: str = 'langchain:agent', model_name: str | None = None, provider: str | None = None, token_usage: [TokenUsage](prefactor_langchain.spans.md#prefactor_langchain.spans.TokenUsage) | None = None, temperature: float | None = None, max_tokens: int | None = None, top_p: float | None = None, stop_sequences: list[str] = <factory>, messages: list[dict[str, ~typing.Any]]=<factory>, response_content: str | None = None)

Bases: [`LangChainSpan`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan)

Span representing an LLM call.

Captures model-specific metadata including the model name, provider,
token usage, and generation parameters.

#### max_tokens *: int | None* *= None*

#### messages *: list[dict[str, Any]]*

#### model_name *: str | None* *= None*

#### provider *: str | None* *= None*

#### response_content *: str | None* *= None*

#### stop_sequences *: list[str]*

#### temperature *: float | None* *= None*

#### to_dict() → dict[str, Any]

Convert to dictionary including LLM-specific fields.

#### token_usage *: [TokenUsage](prefactor_langchain.spans.md#prefactor_langchain.spans.TokenUsage) | None* *= None*

#### top_p *: float | None* *= None*

#### type *: str* *= 'langchain:llm'*

### *class* prefactor_langchain.LangChainSpan(name: str = 'unnamed', start_time: float = <factory>, end_time: float | None = None, status: Literal['pending', 'running', 'completed', 'failed']='pending', inputs: dict[str, ~typing.Any]=<factory>, outputs: dict[str, ~typing.Any] | None=None, metadata: dict[str, ~typing.Any]=<factory>, tags: list[str] = <factory>, error: [ErrorInfo](prefactor_langchain.spans.md#prefactor_langchain.spans.ErrorInfo) | None = None, type: str = 'langchain:agent')

Bases: `object`

Base class for all LangChain spans.

All LangChain spans share common fields for timing, status,
inputs/outputs, and error information. Trace correlation
(span_id, parent_span_id, trace_id) is handled by the backend.

Note: The ‘type’ field is defined in subclasses to avoid dataclass
field shadowing issues.

#### complete(outputs: dict[str, Any] | None = None) → None

Mark the span as completed with outputs.

#### end_time *: float | None* *= None*

#### error *: [ErrorInfo](prefactor_langchain.spans.md#prefactor_langchain.spans.ErrorInfo) | None* *= None*

#### fail(error: Exception) → None

Mark the span as failed with error information.

#### inputs *: dict[str, Any]*

#### metadata *: dict[str, Any]*

#### name *: str* *= 'unnamed'*

#### outputs *: dict[str, Any] | None* *= None*

#### start_time *: float*

#### status *: Literal['pending', 'running', 'completed', 'failed']* *= 'pending'*

#### tags *: list[str]*

#### to_dict() → dict[str, Any]

Convert span to dictionary for serialization.

Returns a JSON-serializable dictionary representation of the span.

#### type *: str* *= 'langchain:agent'*

### *class* prefactor_langchain.LangChainToolSchemaConfig(span_type: str, input_schema: dict[str, Any])

Bases: `object`

Configuration for a tool-specific LangChain span schema.

#### span_type

Tool-specific span type suffix or full span type. Values are
normalized to `langchain:tool:<suffix>`.

* **Type:**
  str

#### input_schema

JSON schema for the tool arguments stored in `inputs` for
tool-specific spans.

* **Type:**
  dict[str, Any]

#### input_schema *: dict[str, Any]*

#### span_type *: str*

### *class* prefactor_langchain.PrefactorMiddleware(client: [PrefactorCoreClient](../../core/reference/prefactor_core.client.md#prefactor_core.client.PrefactorCoreClient) | None = None, agent_id: str = 'langchain-agent', agent_name: str | None = None, instance: [AgentInstanceHandle](../../core/reference/prefactor_core.managers.agent_instance.md#prefactor_core.managers.agent_instance.AgentInstanceHandle) | None = None, tool_schemas: Mapping[str, [LangChainToolSchemaConfig](prefactor_langchain.schemas.md#prefactor_langchain.schemas.LangChainToolSchemaConfig) | Mapping[str, Any]] | None = None)

Bases: `AgentMiddleware`

LangChain middleware for automatic tracing.

This middleware integrates with LangChain’s middleware system to automatically
create and emit spans for agent execution, LLM calls, and tool executions.

Three usage patterns are supported:

1. **Pre-configured Client** (recommended): Pass a pre-configured client for
   full control over settings. The user is responsible for client lifecycle.
2. **Pre-configured Instance**: Pass an existing AgentInstanceHandle to share
   a single instance between the LangChain middleware and other parts of your
   program. Use this when you need to create spans outside of the LangChain
   agent (e.g. for custom pre/post-processing steps). The caller owns the
   instance lifecycle and must call `instance.finish()` themselves.
3. **Factory Pattern**: Use from_config() for quick setup. The middleware
   owns both client and agent instance lifecycle.

Example - Pre-configured Client:
: from prefactor_core import PrefactorCoreClient, PrefactorCoreConfig
  from prefactor_http.config import HttpClientConfig
  <br/>
  # Configure and initialize client yourself
  http_config = HttpClientConfig(api_url=”…”, api_token=”…”)
  config = PrefactorCoreConfig(http_config=http_config)
  client = PrefactorCoreClient(config)
  await client.initialize()
  <br/>
  # Create middleware with pre-configured client
  middleware = PrefactorMiddleware(
  <br/>
  > client=client,
  > agent_id=”my-agent”,
  > agent_name=”My Agent”,
  <br/>
  )
  <br/>
  # User must close both middleware and client
  await middleware.close()  # Only closes agent instance
  await client.close()  # User closes their own client

Example - Pre-configured Instance (spans outside the agent):
: from prefactor_core import PrefactorCoreClient, PrefactorCoreConfig
  from prefactor_http.config import HttpClientConfig
  <br/>
  http_config = HttpClientConfig(api_url=”…”, api_token=”…”)
  config = PrefactorCoreConfig(http_config=http_config)
  client = PrefactorCoreClient(config)
  await client.initialize()
  <br/>
  instance = await client.create_agent_instance(agent_id=”my-agent”)
  await instance.start()
  <br/>
  # Share the same instance with the middleware AND your own code
  middleware = PrefactorMiddleware(instance=instance)
  <br/>
  # Instrument your own code with the same instance
  async with instance.span(“custom:preprocessing”) as ctx:
  <br/>
  > ctx.set_result({“step”: “preprocess”, “status”: “ok”})
  <br/>
  # Run your LangChain agent (middleware traces it automatically)
  result = agent.invoke({“messages”: […]})
  <br/>
  # Caller is responsible for cleanup
  await instance.finish()
  await client.close()

Example - Factory Pattern:
: middleware = PrefactorMiddleware.from_config(
  : api_url=”[https://api.prefactor.ai](https://api.prefactor.ai)”,
    api_token=”my-token”,
    agent_id=”my-agent”,
    agent_name=”My Agent”,
  <br/>
  )
  <br/>
  # Middleware manages both client and agent instance
  await middleware.close()  # Closes both

#### *async* aafter_agent(state: Any, runtime: Any) → dict[str, Any] | None

Async hook called after agent completes execution.

Finishes the `langchain:agent` span opened by `abefore_agent` by
exiting its async context manager.

* **Parameters:**
  * **state** – The agent state.
  * **runtime** – The runtime context.
* **Returns:**
  Optional state updates.

#### *async* abefore_agent(state: Any, runtime: Any) → dict[str, Any] | None

Async hook called before agent starts execution.

Creates a `langchain:agent` span using the async context manager so
that `SpanContextStack` is updated automatically.  Any outer workflow
span already on the stack (e.g. `workflow:agent_step`) is picked up
as the parent without any manual `set_parent_span()` call.

The span context is kept open and stored in `_agent_span_context`
until `aafter_agent` exits it.

* **Parameters:**
  * **state** – The agent state.
  * **runtime** – The runtime context.
* **Returns:**
  Optional state updates.

#### after_agent(state: Any, runtime: Any) → dict[str, Any] | None

Hook called after agent completes execution.

Finishes the agent span created in before_agent.

* **Parameters:**
  * **state** – The agent state.
  * **runtime** – The runtime context.
* **Returns:**
  Optional state updates.

#### *async* awrap_model_call(request: Any, handler: Callable[[Any], Any]) → Any

Wrap async model calls to trace LLM execution.

* **Parameters:**
  * **request** – The model request.
  * **handler** – The function that executes the model call.
* **Returns:**
  The model response.

#### *async* awrap_tool_call(request: Any, handler: Callable[[Any], Any]) → Any

Wrap async tool calls to trace tool execution.

* **Parameters:**
  * **request** – The tool request.
  * **handler** – The function that executes the tool call.
* **Returns:**
  The tool response.

#### before_agent(state: Any, runtime: Any) → dict[str, Any] | None

Hook called before agent starts execution.

Creates a root span for the entire agent execution.

* **Parameters:**
  * **state** – The agent state.
  * **runtime** – The runtime context.
* **Returns:**
  Optional state updates.

#### *async* close() → None

Close the middleware and cleanup resources.

Awaits all in-flight span-emit tasks first, then closes the agent
instance (if we created it) and finally the client.

#### *async* ensure_initialized() → [AgentInstanceHandle](../../core/reference/prefactor_core.managers.agent_instance.md#prefactor_core.managers.agent_instance.AgentInstanceHandle)

Initialize the middleware and return the agent instance handle.

#### *classmethod* from_config(api_url: str, api_token: str, agent_id: str = 'langchain-agent', agent_name: str | None = None, schema_registry: [SchemaRegistry](../../core/reference/prefactor_core.schema_registry.md#prefactor_core.schema_registry.SchemaRegistry) | None = None, include_langchain_schemas: bool = True, tool_schemas: Mapping[str, [LangChainToolSchemaConfig](prefactor_langchain.schemas.md#prefactor_langchain.schemas.LangChainToolSchemaConfig) | Mapping[str, Any]] | None = None) → [PrefactorMiddleware](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware)

Factory method to create middleware from configuration.

This creates a client and middleware with the specified settings.
The middleware owns the client and will auto-initialize it on first use.

* **Parameters:**
  * **api_url** – The Prefactor API URL.
  * **api_token** – The API token for authentication.
  * **agent_id** – Optional agent identifier for categorization.
  * **agent_name** – Optional human-readable agent name.
  * **schema_registry** – Optional SchemaRegistry for registering span schemas.
  * **include_langchain_schemas** – If True and schema_registry is provided,
    automatically register LangChain-specific schemas.
  * **tool_schemas** – Optional per-tool schema configuration for tool-specific
    span types.
* **Returns:**
  A configured PrefactorMiddleware instance with lazy initialization.

### Example

middleware = PrefactorMiddleware.from_config(
: api_url=”[https://api.prefactor.ai](https://api.prefactor.ai)”,
  api_token=”my-token”,
  agent_id=”my-agent”,
  agent_name=”My Agent”,

)

# Middleware auto-initializes on first use
# Cleanup when done:
await middleware.close()  # Closes both agent instance and client

#### set_parent_span(span_id: str | None) → None

Set the parent span ID for the next agent invocation (sync path only).

Only needed when using `agent.invoke()` via `run_in_executor`.
In that case, `before_agent` runs in a worker thread where
`contextvars` are not inherited, so the parent span ID must be
passed explicitly before entering the executor.

When using `agent.ainvoke()` (the recommended async path), parent
wiring is automatic via `SpanContextStack` — do not call this method.

* **Parameters:**
  **span_id** – The span ID to use as the parent, or None to clear it.

#### wrap_model_call(request: Any, handler: Callable[[Any], Any]) → Any

Wrap synchronous model calls to trace LLM execution.

* **Parameters:**
  * **request** – The model request.
  * **handler** – The function that executes the model call.
* **Returns:**
  The model response.

#### wrap_tool_call(request: Any, handler: Callable[[Any], Any]) → Any

Wrap synchronous tool calls to trace tool execution.

* **Parameters:**
  * **request** – The tool request.
  * **handler** – The function that executes the tool call.
* **Returns:**
  The tool response.

### *class* prefactor_langchain.TokenUsage(prompt_tokens: int, completion_tokens: int, total_tokens: int)

Bases: `object`

Token usage information for LLM calls.

#### completion_tokens *: int*

#### prompt_tokens *: int*

#### to_dict() → dict[str, Any]

Convert to dictionary for serialization.

#### total_tokens *: int*

### *class* prefactor_langchain.ToolSpan(name: str = 'unnamed', start_time: float = <factory>, end_time: float | None = None, status: Literal['pending', 'running', 'completed', 'failed']='pending', inputs: dict[str, ~typing.Any]=<factory>, outputs: dict[str, ~typing.Any] | None=None, metadata: dict[str, ~typing.Any]=<factory>, tags: list[str] = <factory>, error: [ErrorInfo](prefactor_langchain.spans.md#prefactor_langchain.spans.ErrorInfo) | None = None, type: str = 'langchain:agent', tool_name: str | None = None, tool_schema: dict[str, ~typing.Any] | None=None, arguments: dict[str, ~typing.Any]=<factory>, execution_time_ms: int | None = None, tool_type: str | None = None, retriever_metadata: dict[str, ~typing.Any] | None=None)

Bases: [`LangChainSpan`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan)

Span representing a tool execution.

Captures tool-specific metadata including the tool name, schema,
arguments, and execution time. Can represent any tool call including
retrievers (with appropriate metadata).

#### arguments *: dict[str, Any]*

#### execution_time_ms *: int | None* *= None*

#### retriever_metadata *: dict[str, Any] | None* *= None*

#### to_dict() → dict[str, Any]

Convert to dictionary including tool-specific fields.

#### tool_name *: str | None* *= None*

#### tool_schema *: dict[str, Any] | None* *= None*

#### tool_type *: str | None* *= None*

#### type *: str* *= 'langchain:tool'*

### prefactor_langchain.compile_langchain_agent_schema(agent_schema: Mapping[str, Any] | None = None, , tool_schemas: Mapping[str, [LangChainToolSchemaConfig](prefactor_langchain.schemas.md#prefactor_langchain.schemas.LangChainToolSchemaConfig) | Mapping[str, Any]] | None = None) → tuple[dict[str, Any], dict[str, str]]

Compile a LangChain agent schema with optional tool-specific span types.

* **Parameters:**
  * **agent_schema** – Optional base agent schema to merge with the built-in
    LangChain span schemas.
  * **tool_schemas** – Optional Python-first per-tool schema configuration.
* **Returns:**
  A tuple of `(compiled_agent_schema, tool_span_types)` where
  `tool_span_types` maps tool names to normalized span types.

### prefactor_langchain.extract_error_info(error: Exception) → [ErrorInfo](prefactor_langchain.spans.md#prefactor_langchain.spans.ErrorInfo)

Extract error information from an exception.

* **Parameters:**
  **error** – The exception to extract information from.
* **Returns:**
  ErrorInfo containing error details.

### prefactor_langchain.extract_token_usage(response: Any) → [TokenUsage](prefactor_langchain.spans.md#prefactor_langchain.spans.TokenUsage) | None

Extract token usage from a ModelResponse.

Checks each message in `response.result` for `usage_metadata`
(the standard LangChain field populated by all providers), accumulating
totals across messages.

* **Parameters:**
  **response** – A ModelResponse object from LangChain.
* **Returns:**
  TokenUsage if available, None otherwise.

### prefactor_langchain.register_langchain_schemas(registry: Any, , agent_schema: Mapping[str, Any] | None = None, tool_schemas: Mapping[str, [LangChainToolSchemaConfig](prefactor_langchain.schemas.md#prefactor_langchain.schemas.LangChainToolSchemaConfig) | Mapping[str, Any]] | None = None) → dict[str, str]

Register all LangChain span schemas with a schema registry.

Registers the built-in schemas for LangChain-specific span types
(agent, llm, tool) using the full `span_type_schemas` form, which
includes params schemas, result schemas, titles, and descriptions. When
tool schemas are configured, this also registers per-tool span types.

* **Parameters:**
  * **registry** – The SchemaRegistry to register schemas with.
  * **agent_schema** – Optional base agent schema that may include embedded
    `toolSchemas` or `tool_schemas` config.
  * **tool_schemas** – Optional Python-first per-tool schema configuration.
* **Returns:**
  A dict mapping tool names to their normalized span types. Returns an
  empty dict when no tool-specific schemas are registered.

### Example

from prefactor_core import SchemaRegistry
from prefactor_langchain.schemas import register_langchain_schemas

registry = SchemaRegistry()
register_langchain_schemas(registry)

# Now the registry has langchain:agent, langchain:llm, langchain:tool
assert registry.has_schema(“langchain:llm”)

## Submodules

* [prefactor_langchain.metadata_extractor module](prefactor_langchain.metadata_extractor.md)
  * [`extract_error_info()`](prefactor_langchain.metadata_extractor.md#prefactor_langchain.metadata_extractor.extract_error_info)
  * [`extract_token_usage()`](prefactor_langchain.metadata_extractor.md#prefactor_langchain.metadata_extractor.extract_token_usage)
* [prefactor_langchain.middleware module](prefactor_langchain.middleware.md)
  * [`PrefactorMiddleware`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware)
    * [`PrefactorMiddleware.aafter_agent()`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware.aafter_agent)
    * [`PrefactorMiddleware.abefore_agent()`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware.abefore_agent)
    * [`PrefactorMiddleware.after_agent()`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware.after_agent)
    * [`PrefactorMiddleware.awrap_model_call()`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware.awrap_model_call)
    * [`PrefactorMiddleware.awrap_tool_call()`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware.awrap_tool_call)
    * [`PrefactorMiddleware.before_agent()`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware.before_agent)
    * [`PrefactorMiddleware.close()`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware.close)
    * [`PrefactorMiddleware.ensure_initialized()`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware.ensure_initialized)
    * [`PrefactorMiddleware.from_config()`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware.from_config)
    * [`PrefactorMiddleware.set_parent_span()`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware.set_parent_span)
    * [`PrefactorMiddleware.wrap_model_call()`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware.wrap_model_call)
    * [`PrefactorMiddleware.wrap_tool_call()`](prefactor_langchain.middleware.md#prefactor_langchain.middleware.PrefactorMiddleware.wrap_tool_call)
* [prefactor_langchain.schemas module](prefactor_langchain.schemas.md)
  * [`LangChainToolSchemaConfig`](prefactor_langchain.schemas.md#prefactor_langchain.schemas.LangChainToolSchemaConfig)
    * [`LangChainToolSchemaConfig.span_type`](prefactor_langchain.schemas.md#prefactor_langchain.schemas.LangChainToolSchemaConfig.span_type)
    * [`LangChainToolSchemaConfig.input_schema`](prefactor_langchain.schemas.md#prefactor_langchain.schemas.LangChainToolSchemaConfig.input_schema)
    * [`LangChainToolSchemaConfig.input_schema`](prefactor_langchain.schemas.md#id0)
    * [`LangChainToolSchemaConfig.span_type`](prefactor_langchain.schemas.md#id1)
  * [`compile_langchain_agent_schema()`](prefactor_langchain.schemas.md#prefactor_langchain.schemas.compile_langchain_agent_schema)
  * [`register_langchain_schemas()`](prefactor_langchain.schemas.md#prefactor_langchain.schemas.register_langchain_schemas)
* [prefactor_langchain.spans module](prefactor_langchain.spans.md)
  * [`AgentSpan`](prefactor_langchain.spans.md#prefactor_langchain.spans.AgentSpan)
    * [`AgentSpan.agent_config`](prefactor_langchain.spans.md#prefactor_langchain.spans.AgentSpan.agent_config)
    * [`AgentSpan.agent_name`](prefactor_langchain.spans.md#prefactor_langchain.spans.AgentSpan.agent_name)
    * [`AgentSpan.final_messages`](prefactor_langchain.spans.md#prefactor_langchain.spans.AgentSpan.final_messages)
    * [`AgentSpan.initial_messages`](prefactor_langchain.spans.md#prefactor_langchain.spans.AgentSpan.initial_messages)
    * [`AgentSpan.iteration_count`](prefactor_langchain.spans.md#prefactor_langchain.spans.AgentSpan.iteration_count)
    * [`AgentSpan.to_dict()`](prefactor_langchain.spans.md#prefactor_langchain.spans.AgentSpan.to_dict)
    * [`AgentSpan.type`](prefactor_langchain.spans.md#prefactor_langchain.spans.AgentSpan.type)
  * [`ErrorInfo`](prefactor_langchain.spans.md#prefactor_langchain.spans.ErrorInfo)
    * [`ErrorInfo.error_type`](prefactor_langchain.spans.md#prefactor_langchain.spans.ErrorInfo.error_type)
    * [`ErrorInfo.message`](prefactor_langchain.spans.md#prefactor_langchain.spans.ErrorInfo.message)
    * [`ErrorInfo.stacktrace`](prefactor_langchain.spans.md#prefactor_langchain.spans.ErrorInfo.stacktrace)
    * [`ErrorInfo.to_dict()`](prefactor_langchain.spans.md#prefactor_langchain.spans.ErrorInfo.to_dict)
  * [`LLMSpan`](prefactor_langchain.spans.md#prefactor_langchain.spans.LLMSpan)
    * [`LLMSpan.max_tokens`](prefactor_langchain.spans.md#prefactor_langchain.spans.LLMSpan.max_tokens)
    * [`LLMSpan.messages`](prefactor_langchain.spans.md#prefactor_langchain.spans.LLMSpan.messages)
    * [`LLMSpan.model_name`](prefactor_langchain.spans.md#prefactor_langchain.spans.LLMSpan.model_name)
    * [`LLMSpan.provider`](prefactor_langchain.spans.md#prefactor_langchain.spans.LLMSpan.provider)
    * [`LLMSpan.response_content`](prefactor_langchain.spans.md#prefactor_langchain.spans.LLMSpan.response_content)
    * [`LLMSpan.stop_sequences`](prefactor_langchain.spans.md#prefactor_langchain.spans.LLMSpan.stop_sequences)
    * [`LLMSpan.temperature`](prefactor_langchain.spans.md#prefactor_langchain.spans.LLMSpan.temperature)
    * [`LLMSpan.to_dict()`](prefactor_langchain.spans.md#prefactor_langchain.spans.LLMSpan.to_dict)
    * [`LLMSpan.token_usage`](prefactor_langchain.spans.md#prefactor_langchain.spans.LLMSpan.token_usage)
    * [`LLMSpan.top_p`](prefactor_langchain.spans.md#prefactor_langchain.spans.LLMSpan.top_p)
    * [`LLMSpan.type`](prefactor_langchain.spans.md#prefactor_langchain.spans.LLMSpan.type)
  * [`LangChainSpan`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan)
    * [`LangChainSpan.complete()`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.complete)
    * [`LangChainSpan.end_time`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.end_time)
    * [`LangChainSpan.error`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.error)
    * [`LangChainSpan.fail()`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.fail)
    * [`LangChainSpan.inputs`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.inputs)
    * [`LangChainSpan.metadata`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.metadata)
    * [`LangChainSpan.name`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.name)
    * [`LangChainSpan.outputs`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.outputs)
    * [`LangChainSpan.start_time`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.start_time)
    * [`LangChainSpan.status`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.status)
    * [`LangChainSpan.tags`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.tags)
    * [`LangChainSpan.to_dict()`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.to_dict)
    * [`LangChainSpan.type`](prefactor_langchain.spans.md#prefactor_langchain.spans.LangChainSpan.type)
  * [`TokenUsage`](prefactor_langchain.spans.md#prefactor_langchain.spans.TokenUsage)
    * [`TokenUsage.completion_tokens`](prefactor_langchain.spans.md#prefactor_langchain.spans.TokenUsage.completion_tokens)
    * [`TokenUsage.prompt_tokens`](prefactor_langchain.spans.md#prefactor_langchain.spans.TokenUsage.prompt_tokens)
    * [`TokenUsage.to_dict()`](prefactor_langchain.spans.md#prefactor_langchain.spans.TokenUsage.to_dict)
    * [`TokenUsage.total_tokens`](prefactor_langchain.spans.md#prefactor_langchain.spans.TokenUsage.total_tokens)
  * [`ToolSpan`](prefactor_langchain.spans.md#prefactor_langchain.spans.ToolSpan)
    * [`ToolSpan.arguments`](prefactor_langchain.spans.md#prefactor_langchain.spans.ToolSpan.arguments)
    * [`ToolSpan.execution_time_ms`](prefactor_langchain.spans.md#prefactor_langchain.spans.ToolSpan.execution_time_ms)
    * [`ToolSpan.retriever_metadata`](prefactor_langchain.spans.md#prefactor_langchain.spans.ToolSpan.retriever_metadata)
    * [`ToolSpan.to_dict()`](prefactor_langchain.spans.md#prefactor_langchain.spans.ToolSpan.to_dict)
    * [`ToolSpan.tool_name`](prefactor_langchain.spans.md#prefactor_langchain.spans.ToolSpan.tool_name)
    * [`ToolSpan.tool_schema`](prefactor_langchain.spans.md#prefactor_langchain.spans.ToolSpan.tool_schema)
    * [`ToolSpan.tool_type`](prefactor_langchain.spans.md#prefactor_langchain.spans.ToolSpan.tool_type)
    * [`ToolSpan.type`](prefactor_langchain.spans.md#prefactor_langchain.spans.ToolSpan.type)