Unable to type events, potentially due to duplicate exports

[jonjomckay]

Describe the bug

I'm trying to handle streamed events in my project, but the rawItem field is always coming through as unknown, even when I type it explicitly.

import type { RunToolCallItem } from '@openai/agents-core';
import type { ToolCallItem } from '@openai/agents-core/types';

const result: ReadableStream<RunStreamEvent>;

for await (const event of result) {
  if (event.type === 'run_item_stream_event') {
  	if (event.name === 'tool_called' && event.item.type === 'tool_call_item') {
  		const item = event.item as RunToolCallItem;
  		// item.rawItem is "unknown" here, though it should be "protocol.ToolCallItem"
  
  		const rawItem = event.item.rawItem as ToolCallItem;
  		// rawItem is "unknown" here, despite casting it to "ToolCallItem"
  	}
  }
}

I think this is happening due to duplicate exports in protocol.ts - one for the Zod schema, and one for the type inferred from the Zod schema:

export const ToolCallItem = z.discriminatedUnion('type', [
  ComputerUseCallItem,
  ShellCallItem,
  ApplyPatchCallItem,
  FunctionCallItem,
  HostedToolCallItem,
]);

export type ToolCallItem = z.infer<typeof ToolCallItem>;

Debug information

• Agents SDK version: (e.g. v0.3.4)
• Runtime environment (e.g. Node.js 22.19.0)

Repro steps

See above.

Expected behavior

Either event.item and event.rawItem are typed correctly automatically through type inference, or using an explicit type should not come through as unknown.

[seratch]

I am not sure what's going on on your local code but the typing works for me without any issues:

code snippet i used:

import { Agent, run } from '@openai/agents';

async function main() {
  const agent = new Agent({ name: 'my agent' });
  const stream = await run(agent, 'Hello', { stream: true });
  for await (const event of stream) {
    if (event.type === 'run_item_stream_event') {
      if (event.name === 'tool_called' && event.item.type === 'tool_call_item') {
        event.item;
      }
    }
  }
}

[jonjomckay]

Weirdly, it seems to work fine if you're in this repo/project, but in a project that consumes the package from npm, those types are unknown.

I've noticed it also happens with things that use e.g. RunResult.history - items come through as any rather than AgentInputItem. I think because AgentInputItem is a union of types that have those duplicated exports.

[jonjomckay]

@seratch any thoughts on the above? I think renaming the exports should fix it.

[seratch]

I've created a simple project and confirmed typing works without any issues. Here is the code I used:

import { Agent, run, tool } from '@openai/agents';
import { z } from 'zod';

const getWeatherTool = tool({
  name: 'get_weather',
  description: 'Get the weather for a given city',
  parameters: z.object({ city: z.string() }),
  async execute({ city }) {
    return `The weather in ${city} is sunny.`;
  },
});

async function main() {
  const agent = new Agent({
    name: 'My Agent',
    instructions: 'My Agent instructions',
    tools: [getWeatherTool],
    modelSettings: { toolChoice: 'required' }
  });

  const result = await run(agent, 'Hey, what is the weather in Tokyo?', { stream: true });
  for await (const event of result) {
    // console.log(event);
    if (event.type === 'run_item_stream_event') {
      if (event.name === 'tool_called' && event.item.type === 'tool_call_item') {
        console.log(event.item);
        console.log(event.item.rawItem);
      }
    }
  }
}
main().catch(console.error);

The correct type comes up on my code editor:

[hboylan]

I'm also encountering the issue with types.

Agents SDK: 0.3.4
TS version: 5.9.3
Node: 24.11.1

Having to cast to my own type

Trying to manually cast AssistantMessageItem intended type still results in any

[hboylan]

I'd propose renaming the zod schema const variables to something like:

// Before:
export const ToolCallItem = z.discriminatedUnion('type', [... ]);
export type ToolCallItem = z.infer<typeof ToolCallItem>;

// After:
export const ToolCallItemSchema = z.discriminatedUnion('type', [... ]);
export type ToolCallItem = z.infer<typeof ToolCallItemSchema>;