[Bug] openai-agents (TypeScript): MCP tool calls get no _meta from a toolMetaResolver #208

// issue_repro.js: MCP tool calls through the plugin's stateless MCP server get no `_meta` from a toolMetaResolver.
// Needs a Temporal dev server (`temporal server start-dev`). Usage: node issue_repro.js [address]
// The script writes its Workflow file next to itself. Exits 0 when the server gets no `_meta` on the plugin route.
const fs = require('node:fs');
const path = require('node:path');
const { Agent, Runner, Usage } = require('@openai/agents-core');
const { Client, Connection } = require('@temporalio/client');
const { NativeConnection, Runtime, DefaultLogger, Worker } = require('@temporalio/worker');
const { OpenAIAgentsPlugin, StatelessMCPServerProvider } = require('@temporalio/openai-agents');

const workflowsPath = path.join(__dirname, 'issue_repro_workflows.js');
fs.writeFileSync(
  workflowsPath,
  `const { Agent } = require('@openai/agents-core');
const { TemporalOpenAIRunner, statelessMcpServer } = require('@temporalio/openai-agents/workflow');
exports.mcpAgent = async (setResolverInWorkflow) => {
  const server = statelessMcpServer('tickets');
  if (setResolverInWorkflow) server.toolMetaResolver = ({ runContext }) => ({ tenant: runContext.context.tenant });
  const agent = new Agent({ name: 'tickets', instructions: 'Use the tool.', model: 'fake', mcpServers: [server] });
  return (await new TemporalOpenAIRunner().run(agent, 'go', { context: { tenant: 't-1' } })).finalOutput;
};
`
);

// An MCP server with a toolMetaResolver, as the framework's MCP guide shows. callTool records its `_meta`.
const metas = [];
const schema = { type: 'object', properties: {}, required: [], additionalProperties: false };
const server = () => ({
  name: 'tickets',
  cacheToolsList: false,
  toolMetaResolver: ({ runContext }) => ({ tenant: runContext.context.tenant }),
  async connect() {},
  async close() {},
  async invalidateToolsCache() {},
  async listTools() {
    return [{ name: 'echo_meta', description: 'Echo the request _meta.', inputSchema: schema }];
  },
  async callTool(_name, _args, meta) {
    metas.push(meta ?? null);
    return [{ type: 'text', text: 'ok' }];
  },
});

// A fake model: calls echo_meta once, then answers.
const model = {
  async getResponse(request) {
    if (request.input.some?.((item) => item.type === 'function_call_result')) {
      return {
        usage: new Usage(),
        output: [{ type: 'message', id: 'm', role: 'assistant', status: 'completed', content: [{ type: 'output_text', text: 'done' }] }],
      };
    }
    return {
      usage: new Usage(),
      output: [{ type: 'function_call', id: 'fc', callId: 'call', name: 'echo_meta', arguments: '{}', status: 'completed' }],
    };
  },
  async *getStreamedResponse() {
    throw new Error('not used');
  },
};

async function main() {
  const address = process.argv[2] ?? '127.0.0.1:7233';
  Runtime.install({ logger: new DefaultLogger('ERROR') });

  // Native control: the same server and model with the framework's Runner.
  const agent = new Agent({ name: 'tickets', instructions: 'Use the tool.', model: 'fake', mcpServers: [server()] });
  await new Runner({ modelProvider: { getModel: () => model }, tracingDisabled: true }).run(agent, 'go', {
    context: { tenant: 't-native' },
  });
  console.log(`native: server got _meta ${JSON.stringify(metas[0])}`);

  // Plugin: the same server from a StatelessMCPServerProvider factory.
  const plugin = new OpenAIAgentsPlugin({
    modelProvider: { getModel: () => model },
    mcpServerProviders: [new StatelessMCPServerProvider('tickets', server)],
  });
  const taskQueue = `mcp-meta-${Date.now()}`;
  const worker = await Worker.create({
    connection: await NativeConnection.connect({ address }),
    taskQueue,
    workflowsPath,
    plugins: [plugin],
  });
  const client = new Client({ connection: await Connection.connect({ address }), plugins: [plugin] });
  await worker.runUntil(async () => {
    for (const inWorkflow of [false, true]) {
      await client.workflow.execute('mcpAgent', { taskQueue, workflowId: `${taskQueue}-${inWorkflow}`, args: [inWorkflow] });
      const where = inWorkflow ? 'resolver also set on the Workflow-side server' : 'resolver on the factory server';
      console.log(`plugin (${where}): server got _meta ${JSON.stringify(metas.at(-1))}`);
    }
  });
  return metas.length === 3 && metas[1] === null && metas[2] === null;
}

main().then(
  (bug) => process.exit(bug ? 0 : 1),
  (err) => {
    console.error(err);
    process.exit(2);
  }
);