> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# OpenAI Agents SDK

> Use W&B Weave with the OpenAI Agents SDK to track and monitor your agentic applications

You can use W\&B Weave with the OpenAI Agents SDK to trace and monitor your agentic applications.

<Tabs>
  <Tab title="Python">
    The [OpenAI Agents Python SDK](https://github.com/openai/openai-agents-python) is a lightweight and powerful framework for building multi-agent workflows.

    ## Installation

    Install the required dependencies using `pip`:

    ```bash theme={null}
    pip install weave openai-agents
    ```

    ## Get started

    To use the OpenAI Agents SDK with Weave:

    * Initialize Weave with your project name.
    * Add the Weave tracing processor to your agents.
    * Create and run your agents as usual.

    The following code sample creates an OpenAI Agent and integrates it with Weave for traceability. A Weave project is initialized and the `WeaveTracingProcessor` is set up to capture execution traces. A `Weather` data model represents weather information. The `get_weather` function is decorated as a tool the agent can use and returns a sample weather report. An agent named `Hello world` is configured with basic instructions and access to the weather tool. The `main` function runs the agent asynchronously with a sample input (`What's the weather in Tokyo?`) and prints the final response.

    ```python lines theme={null}
    from pydantic import BaseModel
    from agents import Agent, Runner, function_tool
    import agents
    import weave
    import asyncio

    weave.init("openai-agents")

    class Weather(BaseModel):
        city: str
        temperature_range: str
        conditions: str

    @function_tool
    def get_weather(city: str) -> Weather:
        return Weather(city=city, temperature_range="14-20C", conditions="Sunny with wind.")

    agent = Agent(
        name="Hello world",
        instructions="You are a helpful agent.",
        tools=[get_weather]
    )

    async def main():
        result = await Runner.run(agent, input="What's the weather in Tokyo?")    
        print(result.final_output)

    if __name__ == "__main__":
        asyncio.run(main())
    ```

    ## View traces

    When the above code sample is run, a link to the Weave dashboard is generated. Open the link to inspect traces from your agent run.
  </Tab>

  <Tab title="TypeScript">
    The [OpenAI Agents Node SDK](https://github.com/openai/openai-node) is a lightweight and powerful framework for building multi-agent workflows.

    ## Installation

    Install the required dependencies using `npm`. Weave's TypeScript integration requires `@openai/agents` version `0.4.15` or later:

    ```bash theme={null}
    npm install weave @openai/agents zod
    ```

    ## Get started

    In most Node.js environments, manual instrumentation is not required.\
    Weave automatically instruments `@openai/agents` when the module is loaded.

    Automatic instrumentation works by registering a module loader hook:

    * **CommonJS projects:** No additional configuration is required.
    * **ESM projects:** Node must be started with the `--import=weave/instrument` flag so the instrumentation loads before other modules.

    If you need help setting up your project or determining which type you are using, see [TypeScript SDK: Third-Party Integration Guide](/weave/guides/integrations/js).

    The following code sample creates an OpenAI Agent and integrates it with Weave for traceability. Replace `your-team-name/your-project-name` in the Weave project initialization with your entity and project. The sample defines a `get_weather` tool that returns a sample weather report, then configures an agent named `Hello world` with basic instructions and access to the weather tool. The `main` function runs the agent with a sample input (`What's the weather in Tokyo?`) and logs the final response.

    ```typescript lines theme={null}
    import * as weave from "weave";
    import { Agent, run, tool } from "@openai/agents";
    import { z } from "zod";

    const getWeather = tool({
      name: "get_weather",
      description: "Get the current weather for a given city.",
      parameters: z.object({
        city: z.string().describe("The name of the city"),
      }),
      async execute({ city }) {
        return `${city}: 14-20C, Sunny with wind.`;
      },
    });

    async function main() {
      // UPDATE to your project info.
      await weave.init("your-team-name/your-project-name");

      const agent = new Agent({
        name: "Hello world",
        instructions: "You are a helpful agent.",
        tools: [getWeather],
      });

      const result = await run(agent, [
        { role: "user", content: "What's the weather in Tokyo?" },
      ]);
      console.log(result.finalOutput);
    }

    main();
    ```

    In CommonJS, the `import * as weave from "weave"` statement must appear **before** `import { Agent, run, tool } from "@openai/agents"` for automatic instrumentation. If your code cannot follow this ordering, use the manual instrumentation technique that follows.

    ### Manual instrumentation

    Manual instrumentation is only needed in cases where the module loader hook cannot run, such as:

    * Bundlers that bundle dependencies into a single file.
    * Environments where Node CLI flags cannot be passed.
    * Dynamic module loading patterns that bypass the loader hook.

    In these cases, you can explicitly register the instrumentation by using `instrumentOpenAIAgents()`:

    ```typescript lines theme={null}
    import * as weave from "weave";

    await weave.init("openai-agents");
    await weave.instrumentOpenAIAgents();
    ```

    For full control over the tracing processor, such as for custom processor configuration or conditional registration, create and register one manually:

    ```typescript lines theme={null}
    import { addTraceProcessor } from "@openai/agents";
    import { createOpenAIAgentsTracingProcessor } from "weave";

    ...

    const processor = createOpenAIAgentsTracingProcessor();
    addTraceProcessor(processor);
    ```
  </Tab>
</Tabs>