backend-manager 5.9.4 → 5.9.6

package/test/helpers/ai-request-payload.js

@@ -1,300 +0,0 @@
-/**
- * Test: AI request payload shape (libraries/ai/providers/openai.js)
- *
- * Verifies the transformation from the BEM-facing `ai.request()` options
- * (specifically `options.prompt` in either legacy object form or array form)
- * into the eventual OpenAI HTTP payload (the `input: [...]` array).
- *
- * These tests exercise the pure helpers `normalizePrompt` and `formatHistory`
- * directly — no network, no assistant required.
- */
-const OpenAI = require('../../src/manager/libraries/ai/providers/openai.js');
-const { normalizePrompt, formatHistory, VALID_PROMPT_ROLES } = OpenAI._internals;
-
-function noopLog() {}
-
-function baseOptions(overrides = {}) {
-  return {
-    dedupeConsecutiveRoles: true,
-    history: { messages: [], limit: 5 },
-    message: { attachments: [] },
-    ...overrides,
-  };
-}
-
-module.exports = {
-  description: 'AI request payload shape (system/developer/user roles)',
-  type: 'group',
-  tests: [
-    // ─── normalizePrompt ───
-
-    {
-      name: 'normalize-undefined-returns-empty-array',
-      async run({ assert }) {
-        assert.deepEqual(normalizePrompt(undefined), [], 'undefined → []');
-      },
-    },
-
-    {
-      name: 'normalize-null-returns-empty-array',
-      async run({ assert }) {
-        assert.deepEqual(normalizePrompt(null), [], 'null → []');
-      },
-    },
-
-    {
-      name: 'normalize-empty-object-returns-empty-array',
-      async run({ assert }) {
-        assert.deepEqual(normalizePrompt({}), [], 'empty object → []');
-      },
-    },
-
-    {
-      name: 'normalize-legacy-object-form-wraps-as-system-segment',
-      async run({ assert }) {
-        const result = normalizePrompt({ path: '/tmp/example.md', settings: { foo: 'bar' } });
-
-        assert.equal(result.length, 1, 'one segment');
-        assert.equal(result[0].role, 'system', 'legacy object defaults to system role');
-        assert.equal(result[0].path, '/tmp/example.md', 'path preserved');
-        assert.deepEqual(result[0].settings, { foo: 'bar' }, 'settings preserved');
-      },
-    },
-
-    {
-      name: 'normalize-legacy-object-with-content-only',
-      async run({ assert }) {
-        const result = normalizePrompt({ content: 'inline prompt text' });
-
-        assert.equal(result.length, 1, 'one segment');
-        assert.equal(result[0].role, 'system', 'defaults to system');
-        assert.equal(result[0].content, 'inline prompt text', 'content preserved');
-        assert.equal(result[0].path, '', 'no path');
-      },
-    },
-
-    {
-      name: 'normalize-array-form-preserves-roles-and-order',
-      async run({ assert }) {
-        const result = normalizePrompt([
-          { role: 'system',    content: 'platform rules' },
-          { role: 'developer', content: 'operator config' },
-        ]);
-
-        assert.equal(result.length, 2, 'two segments');
-        assert.equal(result[0].role, 'system', 'first is system');
-        assert.equal(result[0].content, 'platform rules', 'first content');
-        assert.equal(result[1].role, 'developer', 'second is developer');
-        assert.equal(result[1].content, 'operator config', 'second content');
-      },
-    },
-
-    {
-      name: 'normalize-array-segment-without-role-defaults-to-system',
-      async run({ assert }) {
-        const result = normalizePrompt([
-          { content: 'rule 1' },
-          { role: 'developer', content: 'rule 2' },
-        ]);
-
-        assert.equal(result[0].role, 'system', 'missing role → system');
-        assert.equal(result[1].role, 'developer', 'explicit role preserved');
-      },
-    },
-
-    {
-      name: 'normalize-array-with-invalid-role-throws',
-      async run({ assert }) {
-        let threw = false;
-        try {
-          normalizePrompt([{ role: 'admin', content: 'bad' }]);
-        } catch (e) {
-          threw = true;
-          assert.equal(
-            String(e.message).includes('Invalid prompt role'),
-            true,
-            'error mentions Invalid prompt role',
-          );
-        }
-        assert.equal(threw, true, 'should throw on invalid role');
-      },
-    },
-
-    {
-      name: 'normalize-valid-roles-set-matches-openai-model-spec',
-      async run({ assert }) {
-        const expected = ['system', 'developer', 'user', 'assistant'];
-        const actual = [...VALID_PROMPT_ROLES].sort();
-
-        assert.deepEqual(actual, expected.sort(), 'valid roles per OpenAI Model Spec');
-      },
-    },
-
-    {
-      name: 'normalize-all-valid-roles-accepted',
-      async run({ assert }) {
-        const segments = ['system', 'developer', 'user', 'assistant'].map((role) => ({
-          role,
-          content: `content for ${role}`,
-        }));
-
-        const result = normalizePrompt(segments);
-
-        assert.equal(result.length, 4, 'all four segments accepted');
-        result.forEach((segment, i) => {
-          assert.equal(segment.role, segments[i].role, `segment ${i} role preserved`);
-        });
-      },
-    },
-
-    // ─── formatHistory → OpenAI Responses API payload shape ───
-
-    {
-      name: 'format-single-system-prompt-emits-system-then-user',
-      async run({ assert }) {
-        const promptSegments = normalizePrompt({ content: 'You are a helpful assistant.' });
-        const formatted = formatHistory(baseOptions(), promptSegments, 'Hello!', noopLog);
-
-        assert.equal(formatted.length, 2, 'two messages: system + user');
-        assert.equal(formatted[0].role, 'system', 'first message is system');
-        assert.equal(formatted[0].content[0].type, 'input_text', 'system uses input_text');
-        assert.equal(formatted[0].content[0].text, 'You are a helpful assistant.', 'system text');
-        assert.equal(formatted[1].role, 'user', 'second message is user');
-        assert.equal(formatted[1].content[0].text, 'Hello!', 'user text');
-      },
-    },
-
-    {
-      name: 'format-system-plus-developer-emits-three-messages-in-order',
-      async run({ assert }) {
-        const promptSegments = normalizePrompt([
-          { role: 'system',    content: 'Platform rules go here.' },
-          { role: 'developer', content: 'Operator config goes here.' },
-        ]);
-        const formatted = formatHistory(baseOptions(), promptSegments, 'Customer email body.', noopLog);
-
-        assert.equal(formatted.length, 3, 'three messages');
-        assert.equal(formatted[0].role, 'system', 'order: system');
-        assert.equal(formatted[1].role, 'developer', 'order: developer');
-        assert.equal(formatted[2].role, 'user', 'order: user');
-        assert.equal(formatted[0].content[0].text, 'Platform rules go here.', 'system content');
-        assert.equal(formatted[1].content[0].text, 'Operator config goes here.', 'developer content');
-        assert.equal(formatted[2].content[0].text, 'Customer email body.', 'user content');
-      },
-    },
-
-    {
-      name: 'format-empty-prompt-array-emits-only-user-message',
-      async run({ assert }) {
-        const formatted = formatHistory(baseOptions(), [], 'Just a user message.', noopLog);
-
-        assert.equal(formatted.length, 1, 'only the user message');
-        assert.equal(formatted[0].role, 'user', 'role: user');
-        assert.equal(formatted[0].content[0].text, 'Just a user message.', 'text preserved');
-      },
-    },
-
-    {
-      name: 'format-interleaves-prompt-history-and-new-user-message',
-      async run({ assert }) {
-        const promptSegments = normalizePrompt([
-          { role: 'system',    content: 'system rules' },
-          { role: 'developer', content: 'developer rules' },
-        ]);
-        const options = baseOptions({
-          history: {
-            messages: [
-              { role: 'user',      content: 'first user msg' },
-              { role: 'assistant', content: 'first ai reply' },
-            ],
-            limit: 5,
-          },
-        });
-        const formatted = formatHistory(options, promptSegments, 'second user msg', noopLog);
-
-        const roleSequence = formatted.map((m) => m.role);
-        assert.deepEqual(
-          roleSequence,
-          ['system', 'developer', 'user', 'assistant', 'user'],
-          'prompts → history → new user message',
-        );
-      },
-    },
-
-    {
-      name: 'format-assistant-history-uses-output_text-type',
-      async run({ assert }) {
-        const options = baseOptions({
-          history: {
-            messages: [{ role: 'assistant', content: 'previous reply' }],
-            limit: 5,
-          },
-        });
-        const formatted = formatHistory(options, [], 'new message', noopLog);
-
-        const assistantMsg = formatted.find((m) => m.role === 'assistant');
-        assert.equal(assistantMsg.content[0].type, 'output_text', 'assistant uses output_text');
-      },
-    },
-
-    {
-      name: 'format-respects-history-limit',
-      async run({ assert }) {
-        const options = baseOptions({
-          history: {
-            messages: [
-              { role: 'user',      content: 'msg 1' },
-              { role: 'assistant', content: 'msg 2' },
-              { role: 'user',      content: 'msg 3' },
-              { role: 'assistant', content: 'msg 4' },
-              { role: 'user',      content: 'msg 5' },
-              { role: 'assistant', content: 'msg 6' },
-            ],
-            limit: 2,
-          },
-        });
-        const formatted = formatHistory(options, normalizePrompt({ content: 'sys' }), 'now', noopLog);
-
-        // Expected: 1 system + 2 history + 1 user = 4 messages
-        assert.equal(formatted.length, 4, 'system + 2 history + new user');
-        assert.equal(formatted[1].content[0].text, 'msg 5', 'second-to-last history kept');
-        assert.equal(formatted[2].content[0].text, 'msg 6', 'last history kept');
-        assert.equal(formatted[3].content[0].text, 'now', 'new user message appended');
-      },
-    },
-
-    {
-      name: 'format-dedupes-trailing-user-history-when-flag-set',
-      async run({ assert }) {
-        const options = baseOptions({
-          dedupeConsecutiveRoles: true,
-          history: {
-            messages: [
-              { role: 'assistant', content: 'reply' },
-              { role: 'user',      content: 'should be dropped' },
-            ],
-            limit: 5,
-          },
-        });
-        const formatted = formatHistory(options, [], 'real new message', noopLog);
-
-        // history's trailing 'user' is dropped, then the real new message is appended
-        assert.equal(formatted.length, 2, 'assistant + new user only');
-        assert.equal(formatted[0].role, 'assistant', 'kept assistant');
-        assert.equal(formatted[1].role, 'user', 'new user');
-        assert.equal(formatted[1].content[0].text, 'real new message', 'new user content');
-      },
-    },
-
-    {
-      name: 'format-strips-and-trims-content',
-      async run({ assert }) {
-        const promptSegments = normalizePrompt({ content: '  padded system content  \n' });
-        const formatted = formatHistory(baseOptions(), promptSegments, '  padded user content  ', noopLog);
-
-        assert.equal(formatted[0].content[0].text, 'padded system content', 'system trimmed');
-        assert.equal(formatted[1].content[0].text, 'padded user content', 'user trimmed');
-      },
-    },
-  ],
-};

package/test/helpers/ai-test-provider.js

@@ -1,202 +0,0 @@
-/**
- * Test: deterministic AI test provider (libraries/ai/providers/test.js)
- *
- * The test provider is a first-class provider (the `test` payment-processor
- * precedent) that consumer suites drive with directives embedded in the last
- * user message. These tests exercise the full request() surface directly —
- * no network involved by design.
- */
-const TestProvider = require('../../src/manager/libraries/ai/providers/test.js');
-const { parseScript } = TestProvider._internals;
-
-function makeProvider() {
-  // No Manager — the provider falls back to the BEM_TESTING signal, which the
-  // test runner sets
-  return new TestProvider({});
-}
-
-module.exports = {
-  description: 'AI test provider (scripted sequences)',
-  type: 'group',
-  tests: [
-    // ─── Script parsing ───
-
-    {
-      name: 'parse-script-orders-steps-and-strips-directives',
-      async run({ assert }) {
-        const { steps, cleanText } = parseScript(
-          'Check my order [[tool:check_order {"orderNumber":"1"}]] please [[reply:{"message":"done"}]]',
-        );
-
-        assert.equal(steps.length, 2, 'two steps');
-        assert.equal(steps[0].type, 'tools', 'first step is a tool call');
-        assert.equal(steps[0].calls[0].name, 'check_order', 'tool name parsed');
-        assert.deepEqual(steps[0].calls[0].arguments, { orderNumber: '1' }, 'tool args parsed');
-        assert.equal(steps[1].type, 'reply', 'second step is the reply');
-        assert.equal(cleanText, 'Check my order  please', 'directives stripped from echo text');
-      },
-    },
-
-    {
-      name: 'parse-script-delay-attaches-to-next-step',
-      async run({ assert }) {
-        const { steps } = parseScript('[[delay:50]][[tool:slow_tool]]');
-
-        assert.equal(steps.length, 1, 'one step');
-        assert.equal(steps[0].delay, 50, 'delay attached to the tool step');
-      },
-    },
-
-    // ─── Echo default ───
-
-    {
-      name: 'echo-reply-without-directives',
-      async run({ assert }) {
-        const provider = makeProvider();
-        const result = await provider.request({
-          messages: [
-            { role: 'system', content: 'sys' },
-            { role: 'user', content: 'hello there' },
-          ],
-        });
-
-        assert.equal(result.content, 'Echo: hello there', 'echoes the user message');
-        assert.equal(result.stopReason, 'end', 'final turn');
-        assert.deepEqual(result.toolCalls, [], 'no tool calls');
-        assert.equal(result.tokens.total.count > 0, true, 'tokens accounted');
-      },
-    },
-
-    {
-      name: 'echo-reply-json-mode-wraps-message',
-      async run({ assert }) {
-        const provider = makeProvider();
-        const result = await provider.request({
-          response: 'json',
-          messages: [{ role: 'user', content: 'hi' }],
-        });
-
-        assert.equal(typeof result.content, 'object', 'parsed object');
-        assert.equal(result.content.message, 'Echo: hi', 'wrapped message');
-      },
-    },
-
-    // ─── Scripted reply ───
-
-    {
-      name: 'scripted-json-reply',
-      async run({ assert }) {
-        const provider = makeProvider();
-        const result = await provider.request({
-          response: 'json',
-          messages: [
-            { role: 'user', content: 'whatever [[reply:{"message":"Hi!","actions":[{"type":"reply","label":"More"}]}]]' },
-          ],
-        });
-
-        assert.equal(result.content.message, 'Hi!', 'scripted message');
-        assert.equal(result.content.actions[0].label, 'More', 'scripted actions');
-        assert.equal(result.stopReason, 'end', 'final turn');
-      },
-    },
-
-    // ─── Tool loop sequence ───
-
-    {
-      name: 'tool-then-reply-sequence-across-turns',
-      async run({ assert }) {
-        const provider = makeProvider();
-        const script = 'check it [[tool:check_order {"orderNumber":"42"}]] [[reply:{"message":"Order 42 shipped"}]]';
-
-        // Turn 1: the provider emits the tool call
-        const first = await provider.request({
-          response: 'json',
-          messages: [
-            { role: 'system', content: 'sys' },
-            { role: 'user', content: script },
-          ],
-        });
-
-        assert.equal(first.stopReason, 'tool_use', 'first turn requests the tool');
-        assert.equal(first.toolCalls.length, 1, 'one call');
-        assert.equal(first.toolCalls[0].name, 'check_order', 'tool name');
-        assert.deepEqual(first.toolCalls[0].arguments, { orderNumber: '42' }, 'tool args');
-
-        // Turn 2: caller appended the assistant turn + tool result — provider
-        // moves to the next step (the reply)
-        const second = await provider.request({
-          response: 'json',
-          messages: [
-            { role: 'system', content: 'sys' },
-            { role: 'user', content: script },
-            { role: 'assistant', toolCalls: first.toolCalls },
-            { role: 'tool', toolCallId: first.toolCalls[0].id, content: '{"status":"shipped"}' },
-          ],
-        });
-
-        assert.equal(second.stopReason, 'end', 'second turn is final');
-        assert.equal(second.content.message, 'Order 42 shipped', 'scripted final reply');
-      },
-    },
-
-    {
-      name: 'parallel-tools-directive-emits-multiple-calls',
-      async run({ assert }) {
-        const provider = makeProvider();
-        const result = await provider.request({
-          messages: [
-            { role: 'user', content: '[[tools:[{"name":"a","arguments":{"x":1}},{"name":"b","arguments":{"y":2}}]]]' },
-          ],
-        });
-
-        assert.equal(result.stopReason, 'tool_use', 'tool turn');
-        assert.equal(result.toolCalls.length, 2, 'two parallel calls');
-        assert.equal(result.toolCalls[0].name, 'a', 'first call');
-        assert.equal(result.toolCalls[1].name, 'b', 'second call');
-        assert.deepEqual(result.toolCalls[1].arguments, { y: 2 }, 'second args');
-      },
-    },
-
-    // ─── Scripted error ───
-
-    {
-      name: 'scripted-error-throws',
-      async run({ assert }) {
-        const provider = makeProvider();
-        let threw = false;
-
-        try {
-          await provider.request({
-            messages: [{ role: 'user', content: '[[error:boom]]' }],
-          });
-        } catch (e) {
-          threw = true;
-          assert.equal(e.message, 'boom', 'scripted error message');
-        }
-
-        assert.equal(threw, true, 'throws the scripted error');
-      },
-    },
-
-    // ─── Script exhaustion ───
-
-    {
-      name: 'exhausted-script-falls-back-to-echo',
-      async run({ assert }) {
-        const provider = makeProvider();
-        const script = 'hi [[tool:t1]]';
-
-        const second = await provider.request({
-          messages: [
-            { role: 'user', content: script },
-            { role: 'assistant', toolCalls: [{ id: 'c', name: 't1', arguments: {} }] },
-            { role: 'tool', toolCallId: 'c', content: 'r' },
-          ],
-        });
-
-        assert.equal(second.stopReason, 'end', 'falls back to a final turn');
-        assert.equal(String(second.content).startsWith('Echo:'), true, 'echo fallback');
-      },
-    },
-  ],
-};