[Bug] strands-agents (TypeScript): OpenAIModel calls fail in the model Activity on Strands 1.15.0 and later #296

'use strict';
// A Strands OpenAIModel through the Temporal plugin: one agent turn natively, then the same turn in
// a Workflow. The real OpenAIModel runs in both; only its `fetch` is a recording fake. The script
// prints both routes and exits 0 when the plugin route sends the request and returns the reply, as
// natively, and 1 when it does not. `node reproduce.cjs chat` uses the Chat Completions API instead
// of the default Responses API.
const crypto = require('node:crypto');
const fs = require('node:fs');
const path = require('node:path');
const { Agent } = require('@strands-agents/sdk');
const { OpenAIModel } = require('@strands-agents/sdk/models/openai');
const { StrandsPlugin } = require('@temporalio/strands-agents');
const { Worker, Runtime, DefaultLogger } = require('@temporalio/worker');
const { TestWorkflowEnvironment } = require('@temporalio/testing');

const api = process.argv[2] ?? 'responses';
const requests = [];

const sse = (events) => events.map((e) => `data: ${JSON.stringify(e)}\n\n`).join('');

// A text reply in the streaming format of the API the request went to.
function reply(url, text) {
  if (url.endsWith('/chat/completions')) {
    const chunk = (delta, finish) => ({ id: 'chat_1', object: 'chat.completion.chunk', created: 1, model: 'gpt-test', choices: [{ index: 0, delta, finish_reason: finish }] });
    return sse([chunk({ role: 'assistant', content: text }, null), chunk({}, 'stop')]) + 'data: [DONE]\n\n';
  }
  const base = { id: 'resp_1', object: 'response', created_at: 1, model: 'gpt-test', output: [], error: null, incomplete_details: null, instructions: null, metadata: {}, parallel_tool_calls: true, temperature: 1, tool_choice: 'auto', tools: [], top_p: 1 };
  const message = { type: 'message', id: 'msg_1', role: 'assistant', status: 'completed', content: [{ type: 'output_text', text, annotations: [] }] };
  return sse([
    { type: 'response.created', response: { ...base, status: 'in_progress' } },
    { type: 'response.output_item.added', item: { ...message, status: 'in_progress', content: [] }, output_index: 0 },
    { type: 'response.output_text.delta', item_id: message.id, output_index: 0, content_index: 0, delta: text, logprobs: [] },
    { type: 'response.output_item.done', item: message, output_index: 0 },
    { type: 'response.completed', response: { ...base, status: 'completed', output: [message] } },
  ].map((e, n) => ({ ...e, sequence_number: n })));
}

async function recordingFetch(url, init) {
  requests.push(String(url).replace('http://fake-openai.test/v1', ''));
  return new Response(reply(String(url), 'answer'), { status: 200, headers: { 'content-type': 'text/event-stream' } });
}

const model = () => new OpenAIModel({ api, modelId: 'gpt-test', apiKey: 'test-key', clientConfig: { baseURL: 'http://fake-openai.test/v1', fetch: recordingFetch } });

async function main() {
  const versions = {};
  for (const p of ['@temporalio/strands-agents', '@temporalio/worker', '@strands-agents/sdk', 'openai']) {
    versions[p] = JSON.parse(fs.readFileSync(path.join(__dirname, 'node_modules', p, 'package.json'), 'utf8')).version;
  }
  console.log(JSON.stringify({ api, versions }));

  // Native control: the same model and turn, outside Temporal.
  const native = { reply: (await new Agent({ model: model(), printer: false }).invoke('hello')).toString() };
  console.log(JSON.stringify({ route: 'native', result: native, requests: requests.splice(0) }));

  Runtime.install({ logger: new DefaultLogger('ERROR') });
  const env = await TestWorkflowEnvironment.createLocal();
  let plugin;
  try {
    const taskQueue = `openai-${crypto.randomUUID()}`;
    const worker = await Worker.create({
      connection: env.nativeConnection,
      taskQueue,
      workflowsPath: require.resolve('./workflows.js'),
      plugins: [new StrandsPlugin({ models: { openai: model } })],
    });
    plugin = await worker.runUntil(env.client.workflow.execute('oneTurn', { taskQueue, workflowId: crypto.randomUUID() }));
  } finally {
    await env.teardown();
  }
  const pluginRequests = requests.splice(0);
  console.log(JSON.stringify({ route: 'plugin', result: plugin, requests: pluginRequests }));

  const same = plugin.reply === native.reply && pluginRequests.length === 1;
  console.log(JSON.stringify({ result: same ? 'plugin route matches native' : 'plugin route differs from native' }));
  process.exitCode = same ? 0 : 1;
}

main().catch((err) => {
  console.error(err);
  process.exitCode = 2;
});

'use strict';
const { TemporalAgent } = require('@temporalio/strands-agents');

// One turn on the `openai` Worker model. A failed model Activity ends the run after two attempts, so
// the script does not wait on endless retries.
async function oneTurn() {
  const agent = new TemporalAgent({
    model: 'openai',
    printer: false,
    activityOptions: { startToCloseTimeout: '10 seconds', retry: { maximumAttempts: 2 } },
  });
  try {
    return { reply: (await agent.invoke('hello')).toString() };
  } catch (err) {
    const chain = [];
    for (let e = err; e; e = e.cause) chain.push(`${e.name}: ${e.message}`);
    return { error: chain.join(' <- ') };
  }
}

module.exports = { oneTurn };