OpenAI SDK

1
import os
2
import json
3
from openai import OpenAI
4
from respan import Respan, workflow, task
5
from respan_instrumentation_openai import OpenAIInstrumentor
6
7
respan = Respan(instrumentations=[OpenAIInstrumentor()])
8
9
client = OpenAI(
10
    api_key=os.getenv("RESPAN_API_KEY"),
11
    base_url=os.getenv("RESPAN_BASE_URL", "https://api.respan.ai/api"),
12
)
13
14
tools = [
15
    {
16
        "type": "function",
17
        "function": {
18
            "name": "get_weather",
19
            "description": "Get the weather for a city.",
20
            "parameters": {
21
                "type": "object",
22
                "properties": {"city": {"type": "string"}},
23
                "required": ["city"],
24
            },
25
        },
26
    }
27
]
28
29
@task(name="get_weather")
30
def get_weather(city: str) -> str:
31
    return f"Sunny, 72F in {city}"
32
33
@workflow(name="weather_assistant")
34
def run(question: str):
35
    messages = [{"role": "user", "content": question}]
36
37
    response = client.chat.completions.create(
38
        model="gpt-4.1-nano",
39
        messages=messages,
40
        tools=tools,
41
    )
42
    message = response.choices[0].message
43
44
    if message.tool_calls:
45
        messages.append(message)
46
        for tc in message.tool_calls:
47
            args = json.loads(tc.function.arguments)
48
            result = get_weather(**args)
49
            messages.append(
50
                {"role": "tool", "tool_call_id": tc.id, "content": result}
51
            )
52
53
        final = client.chat.completions.create(
54
            model="gpt-4.1-nano",
55
            messages=messages,
56
            tools=tools,
57
        )
58
        print(f"Answer: {final.choices[0].message.content}")
59
60
run("What's the weather in Paris?")
61
respan.flush()

1
import os
2
from openai import OpenAI
3
from respan import Respan, workflow
4
from respan_instrumentation_openai import OpenAIInstrumentor
5
6
respan = Respan(instrumentations=[OpenAIInstrumentor()])
7
8
client = OpenAI(
9
    api_key=os.getenv("RESPAN_API_KEY"),
10
    base_url=os.getenv("RESPAN_BASE_URL", "https://api.respan.ai/api"),
11
)
12
13
@workflow(name="conversation")
14
def chat():
15
    messages = [
16
        {"role": "system", "content": "You are a concise cooking assistant."}
17
    ]
18
    questions = [
19
        "What can I make with eggs and cheese?",
20
        "How long does the omelette take?",
21
        "Any tips to make it fluffy?",
22
    ]
23
24
    for question in questions:
25
        messages.append({"role": "user", "content": question})
26
        response = client.chat.completions.create(
27
            model="gpt-4.1-nano",
28
            messages=messages,
29
        )
30
        answer = response.choices[0].message.content
31
        messages.append({"role": "assistant", "content": answer})
32
        print(f"User: {question}")
33
        print(f"Bot:  {answer}\n")
34
35
chat()
36
respan.flush()

1
import os
2
from pydantic import BaseModel
3
from openai import OpenAI
4
from respan import Respan, workflow
5
from respan_instrumentation_openai import OpenAIInstrumentor
6
7
respan = Respan(instrumentations=[OpenAIInstrumentor()])
8
9
client = OpenAI(
10
    api_key=os.getenv("RESPAN_API_KEY"),
11
    base_url=os.getenv("RESPAN_BASE_URL", "https://api.respan.ai/api"),
12
)
13
14
class MovieReview(BaseModel):
15
    title: str
16
    rating: int
17
    summary: str
18
    pros: list[str]
19
    cons: list[str]
20
21
@workflow(name="movie_review")
22
def review(movie: str) -> MovieReview:
23
    response = client.beta.chat.completions.parse(
24
        model="gpt-4.1-nano",
25
        messages=[
26
            {"role": "system", "content": "You are a film critic. Rate movies 1-10."},
27
            {"role": "user", "content": f"Review: {movie}"},
28
        ],
29
        response_format=MovieReview,
30
    )
31
    return response.choices[0].message.parsed
32
33
result = review("The Matrix")
34
print(f"{result.title} — {result.rating}/10")
35
print(f"Summary: {result.summary}")
36
respan.flush()

1
import os
2
import json
3
import time
4
from openai import OpenAI
5
from respan import Respan, workflow, task
6
from respan_instrumentation_openai import OpenAIInstrumentor
7
8
respan = Respan(instrumentations=[OpenAIInstrumentor()])
9
10
# Batch API requires direct OpenAI access
11
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
12
13
@task(name="create_batch_file")
14
def create_batch_file() -> str:
15
    tasks = []
16
    for i, topic in enumerate(["quantum computing", "blockchain", "edge computing"]):
17
        tasks.append({
18
            "custom_id": f"topic-{i}",
19
            "method": "POST",
20
            "url": "/v1/chat/completions",
21
            "body": {
22
                "model": "gpt-4.1-nano",
23
                "messages": [
24
                    {"role": "system", "content": "Explain in one sentence."},
25
                    {"role": "user", "content": f"What is {topic}?"},
26
                ],
27
            },
28
        })
29
30
    file_path = "/tmp/batch_input.jsonl"
31
    with open(file_path, "w") as f:
32
        for t in tasks:
33
            f.write(json.dumps(t) + "\n")
34
    return file_path
35
36
@task(name="upload_and_submit")
37
def upload_and_submit(file_path: str) -> str:
38
    batch_file = client.files.create(file=open(file_path, "rb"), purpose="batch")
39
    batch = client.batches.create(
40
        input_file_id=batch_file.id,
41
        endpoint="/v1/chat/completions",
42
        completion_window="24h",
43
    )
44
    return batch.id
45
46
@task(name="poll_batch")
47
def poll_batch(batch_id: str) -> str:
48
    while True:
49
        batch = client.batches.retrieve(batch_id)
50
        if batch.status == "completed":
51
            return batch.output_file_id
52
        elif batch.status in ("failed", "expired", "cancelled"):
53
            raise RuntimeError(f"Batch {batch.status}")
54
        time.sleep(5)
55
56
@task(name="download_results")
57
def download_results(output_file_id: str):
58
    content = client.files.content(output_file_id).content
59
    results = [json.loads(line) for line in content.decode().strip().split("\n")]
60
61
    with open("/tmp/batch_input.jsonl") as f:
62
        requests = [json.loads(line) for line in f]
63
64
    # Log each batch result as an individual traced span
65
    respan.log_batch_results(requests, results)
66
67
    for r in results:
68
        print(f"{r['custom_id']}: {r['response']['body']['choices'][0]['message']['content']}")
69
70
@workflow(name="batch_pipeline")
71
def run():
72
    file_path = create_batch_file()
73
    batch_id = upload_and_submit(file_path)
74
    output_file_id = poll_batch(batch_id)
75
    download_results(output_file_id)
76
77
run()
78
respan.flush()

1
import os
2
import json
3
import time
4
from openai import OpenAI
5
from respan import Respan, workflow, task, get_client
6
from respan_instrumentation_openai import OpenAIInstrumentor
7
8
respan = Respan(instrumentations=[OpenAIInstrumentor()])
9
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
10
11
# Phase 1: Submit batch and save trace context
12
@task(name="create_and_submit")
13
def create_and_submit(requests: list) -> dict:
14
    file_path = "/tmp/batch_async.jsonl"
15
    with open(file_path, "w") as f:
16
        for r in requests:
17
            f.write(json.dumps(r) + "\n")
18
19
    batch_file = client.files.create(file=open(file_path, "rb"), purpose="batch")
20
    batch = client.batches.create(
21
        input_file_id=batch_file.id,
22
        endpoint="/v1/chat/completions",
23
        completion_window="24h",
24
    )
25
26
    # Save trace ID — in production, persist this to a database
27
    rc = get_client()
28
    trace_id = rc.get_current_trace_id()
29
30
    return {"batch_id": batch.id, "trace_id": trace_id, "input_file": file_path}
31
32
@workflow(name="batch_submit")
33
def submit(requests):
34
    return create_and_submit(requests)
35
36
# Phase 2: Retrieve results (separate process/job)
37
def retrieve_and_log(saved: dict):
38
    batch_id = saved["batch_id"]
39
40
    while True:
41
        batch = client.batches.retrieve(batch_id)
42
        if batch.status == "completed":
43
            break
44
        elif batch.status in ("failed", "expired", "cancelled"):
45
            raise RuntimeError(f"Batch {batch.status}")
46
        time.sleep(5)
47
48
    content = client.files.content(batch.output_file_id).content
49
    results = [json.loads(line) for line in content.decode().strip().split("\n")]
50
51
    with open(saved["input_file"]) as f:
52
        requests = [json.loads(line) for line in f]
53
54
    # Log results into the ORIGINAL trace
55
    respan.log_batch_results(requests, results, trace_id=saved["trace_id"])
56
57
# Run
58
requests = [
59
    {
60
        "custom_id": f"topic-{i}",
61
        "method": "POST",
62
        "url": "/v1/chat/completions",
63
        "body": {
64
            "model": "gpt-4.1-nano",
65
            "messages": [
66
                {"role": "system", "content": "Explain in one sentence."},
67
                {"role": "user", "content": f"What is {topic}?"},
68
            ],
69
        },
70
    }
71
    for i, topic in enumerate(["quantum computing", "blockchain", "edge computing"])
72
]
73
74
saved = submit(requests)
75
respan.flush()
76
77
# Later (could be a different process)...
78
retrieve_and_log(saved)
79
respan.flush()

1
# OpenAI
2
response = client.chat.completions.create(model="gpt-4o", messages=messages)
3
4
# Anthropic
5
response = client.chat.completions.create(model="claude-sonnet-4-5-20250929", messages=messages)
6
7
# Google
8
response = client.chat.completions.create(model="gemini-2.5-flash", messages=messages)

1
PROMPT_ID = "YOUR_PROMPT_ID"
2
3
response = client.chat.completions.create(
4
    model="gpt-4.1-nano",
5
    messages=[
6
        {"role": "user", "content": "Add dark mode support to the dashboard"},
7
    ],
8
    extra_body={
9
        "prompt": {
10
            "prompt_id": PROMPT_ID,
11
            "schema_version": 2,
12
            "variables": {
13
                "feature_request": "Add dark mode support",
14
            },
15
        }
16
    },
17
)
18
print(response.choices[0].message.content)

1
PROMPT_ID = "YOUR_PROMPT_ID"
2
3
response = client.responses.create(
4
    model="gpt-4.1-nano",
5
    input=[
6
        {"role": "user", "content": "Add dark mode support to the dashboard"},
7
    ],
8
    extra_body={
9
        "respan_params": {
10
            "prompt": {
11
                "prompt_id": PROMPT_ID,
12
                "schema_version": 2,
13
                "variables": {
14
                    "feature_request": "Add dark mode support",
15
                },
16
            }
17
        }
18
    },
19
)
20
print(response.output_text)

1
response = client.chat.completions.create(
2
    model="gpt-4.1-nano",
3
    messages=[{"role": "user", "content": "Hello"}],
4
    extra_body={
5
        "customer_identifier": "user_123",
6
        "fallback_models": ["gpt-3.5-turbo"],
7
        "metadata": {"session_id": "abc123"},
8
        "thread_identifier": "conversation_456",
9
    },
10
)