@task | Respan Docs

Overview

The @task decorator creates a child span for a single unit of work — an LLM call, data processing step, validation, or any discrete operation within a workflow.

1 from respan import task

Parameters

Parameter	Type	Default	Description
`name`	`str \| None`	Function name	Display name for the task span.
`version`	`int \| None`	`None`	Version number for the task.
`method_name`	`str \| None`	`None`	Required when decorating a class. Specifies which method to use as the entry point.
`processors`	`str \| List[str] \| None`	`None`	Route this span to specific named processors. See add_processor.
`export_filter`	`FilterParamDict \| None`	`None`	Filter dict to control which spans are exported. Uses AND logic — all conditions must match.

Function usage

1 from respan import Respan, workflow, task
2 from openai import OpenAI
3 
4 respan = Respan(api_key="your-api-key")
5 client = OpenAI()
6 
7 @task(name="generate_text")
8 def generate_text(prompt: str):
9     response = client.chat.completions.create(
10         model="gpt-4o-mini",
11         messages=[{"role": "user", "content": prompt}],
12     )
13     return response.choices[0].message.content
14 
15 @task(name="summarize")
16 def summarize(text: str):
17     response = client.chat.completions.create(
18         model="gpt-4o-mini",
19         messages=[{"role": "user", "content": f"Summarize: {text}"}],
20     )
21     return response.choices[0].message.content
22 
23 @workflow(name="content_pipeline")
24 def content_pipeline(topic: str):
25     text = generate_text(f"Write about {topic}")
26     return summarize(text)
27 
28 print(content_pipeline("Python"))

Class usage

1 from respan import Respan, workflow, task
2 
3 respan = Respan(api_key="your-api-key")
4 
5 @workflow(name="agent_run", method_name="run")
6 class Agent:
7     @task(name="respond")
8     def respond(self, prompt: str):
9         return f"Echo: {prompt}"
10 
11     def run(self):
12         return self.respond("Hello")
13 
14 print(Agent().run())

Features

Automatic I/O capture — Function arguments and return values are serialized as span input/output (up to 1MB).
Exception recording — Exceptions are automatically recorded on the span with error status.
Async support — Works with async def functions and generators.

Best practices

Keep tasks small and focused on a single operation
Use task names that reflect intent, not implementation details
Nest tasks inside workflows for proper trace hierarchy