@aj-archipelago/cortex 1.3.62 → 1.3.63

package/tests/integration/graphql/async/stream/sys_entity_start_streaming.test.js

@@ -0,0 +1,71 @@
+import test from 'ava';
+import serverFactory from '../../../../../index.js';
+import { createWsClient, ensureWsConnection, collectSubscriptionEvents, validateProgressMessage } from '../../../../helpers/subscriptions.js';
+
+let testServer;
+let wsClient;
+
+test.before(async () => {
+  process.env.CORTEX_ENABLE_REST = 'true';
+  const { server, startServer } = await serverFactory();
+  startServer && await startServer();
+  testServer = server;
+
+  wsClient = createWsClient();
+  await ensureWsConnection(wsClient);
+});
+
+test.after.always('cleanup', async () => {
+  if (wsClient) wsClient.dispose();
+  if (testServer) await testServer.stop();
+});
+
+test.serial('sys_entity_start streaming works correctly', async (t) => {
+  const response = await testServer.executeOperation({
+    query: `
+      query TestQuery($text: String!, $chatHistory: [MultiMessage]!, $stream: Boolean!) {
+        sys_entity_start(text: $text, chatHistory: $chatHistory, stream: $stream) {
+          result
+          contextId
+          tool
+          warnings
+          errors
+        }
+      }
+    `,
+    variables: {
+      text: 'Tell me about the history of Al Jazeera',
+      chatHistory: [{ role: "user", content: ["Tell me about the history of Al Jazeera"] }],
+      stream: true
+    }
+  });
+
+  const requestId = response.body?.singleResult?.data?.sys_entity_start?.result;
+  t.truthy(requestId);
+
+  const events = await collectSubscriptionEvents(wsClient, {
+    query: `
+      subscription OnRequestProgress($requestId: String!) {
+        requestProgress(requestIds: [$requestId]) {
+          requestId
+          progress
+          data
+          info
+        }
+      }
+    `,
+    variables: { requestId },
+  }, 30000, { requireCompletion: false, minEvents: 1 });
+
+  t.true(events.length > 0);
+  for (const event of events) {
+    const progress = event.data.requestProgress;
+    validateProgressMessage(t, progress, requestId);
+    if (progress.data) {
+      const parsed = JSON.parse(progress.data);
+      t.true(typeof parsed === 'string' || typeof parsed === 'object');
+    }
+  }
+});
+
+

package/tests/integration/graphql/async/stream/vendors/claude_streaming.test.js

@@ -0,0 +1,56 @@
+import test from 'ava';
+import serverFactory from '../../../../../../index.js';
+import { createWsClient, ensureWsConnection, collectSubscriptionEvents } from '../../../../../helpers/subscriptions.js';
+
+let testServer;
+let wsClient;
+
+test.before(async () => {
+  const { server, startServer } = await serverFactory();
+  startServer && await startServer();
+  testServer = server;
+  wsClient = createWsClient();
+  await ensureWsConnection(wsClient);
+});
+
+test.after.always('cleanup', async () => {
+  if (wsClient) wsClient.dispose();
+  if (testServer) await testServer.stop();
+});
+
+test('Claude vendor streaming over subscriptions emits OAI-style deltas', async (t) => {
+  const response = await testServer.executeOperation({
+    query: `
+      query($text: String!, $chatHistory: [MultiMessage]!, $stream: Boolean, $aiStyle: String) {
+        sys_entity_agent(text: $text, chatHistory: $chatHistory, stream: $stream, aiStyle: $aiStyle) {
+          result
+        }
+      }
+    `,
+    variables: {
+      text: 'Say hi',
+      chatHistory: [{ role: 'user', content: ['Say hi'] }],
+      stream: true,
+      aiStyle: 'Anthropic'
+    }
+  });
+
+  const requestId = response.body?.singleResult?.data?.sys_entity_agent?.result;
+  if (!requestId) {
+    t.pass('Skipping - Claude vendor model not configured');
+    return;
+  }
+
+  const events = await collectSubscriptionEvents(wsClient, {
+    query: `
+      subscription($requestId: String!) {
+        requestProgress(requestIds: [$requestId]) { requestId progress data }
+      }
+    `,
+    variables: { requestId },
+  }, 20000, { requireCompletion: false, minEvents: 1 });
+
+  t.true(events.length > 0);
+});
+
+

package/tests/integration/graphql/async/stream/vendors/gemini_streaming.test.js

@@ -0,0 +1,66 @@
+import test from 'ava';
+import serverFactory from '../../../../../../index.js';
+import { createWsClient, ensureWsConnection, collectSubscriptionEvents } from '../../../../../helpers/subscriptions.js';
+
+let testServer;
+let wsClient;
+
+test.before(async () => {
+  const { server, startServer } = await serverFactory();
+  startServer && await startServer();
+  testServer = server;
+  wsClient = createWsClient();
+  await ensureWsConnection(wsClient);
+});
+
+test.after.always('cleanup', async () => {
+  if (wsClient) wsClient.dispose();
+  if (testServer) await testServer.stop();
+});
+
+test('Gemini vendor streaming over subscriptions emits OAI-style deltas', async (t) => {
+  const response = await testServer.executeOperation({
+    query: `
+      query($text: String!, $chatHistory: [MultiMessage]!, $stream: Boolean, $aiStyle: String) {
+        sys_entity_agent(text: $text, chatHistory: $chatHistory, stream: $stream, aiStyle: $aiStyle) {
+          result
+        }
+      }
+    `,
+    variables: {
+      text: 'Say hi',
+      chatHistory: [{ role: 'user', content: ['Say hi'] }],
+      stream: true,
+      aiStyle: 'Google'
+    }
+  });
+
+  const requestId = response.body?.singleResult?.data?.sys_entity_agent?.result;
+  if (!requestId) {
+    t.pass('Skipping - Google vendor model not configured');
+    return;
+  }
+
+  const events = await collectSubscriptionEvents(wsClient, {
+    query: `
+      subscription($requestId: String!) {
+        requestProgress(requestIds: [$requestId]) { requestId progress data }
+      }
+    `,
+    variables: { requestId },
+  }, 20000, { requireCompletion: false, minEvents: 1 });
+  t.true(events.length > 0);
+  const hasDelta = events.some(e => {
+    const data = e?.data?.requestProgress?.data;
+    if (!data) return false;
+    try {
+      const parsed = JSON.parse(data);
+      return parsed?.choices?.[0]?.delta;
+    } catch (_) {
+      return false;
+    }
+  });
+  t.true(hasDelta);
+});
+
+

package/tests/integration/graphql/async/stream/vendors/grok_streaming.test.js

@@ -0,0 +1,56 @@
+import test from 'ava';
+import serverFactory from '../../../../../../index.js';
+import { createWsClient, ensureWsConnection, collectSubscriptionEvents } from '../../../../../helpers/subscriptions.js';
+
+let testServer;
+let wsClient;
+
+test.before(async () => {
+  const { server, startServer } = await serverFactory();
+  startServer && await startServer();
+  testServer = server;
+  wsClient = createWsClient();
+  await ensureWsConnection(wsClient);
+});
+
+test.after.always('cleanup', async () => {
+  if (wsClient) wsClient.dispose();
+  if (testServer) await testServer.stop();
+});
+
+test('XAI Grok vendor streaming over subscriptions emits OAI-style deltas', async (t) => {
+  const response = await testServer.executeOperation({
+    query: `
+      query($text: String!, $chatHistory: [MultiMessage]!, $stream: Boolean, $aiStyle: String) {
+        sys_entity_agent(text: $text, chatHistory: $chatHistory, stream: $stream, aiStyle: $aiStyle) {
+          result
+        }
+      }
+    `,
+    variables: {
+      text: 'Say hi',
+      chatHistory: [{ role: 'user', content: ['Say hi'] }],
+      stream: true,
+      aiStyle: 'XAI'
+    }
+  });
+
+  const requestId = response.body?.singleResult?.data?.sys_entity_agent?.result;
+  if (!requestId) {
+    t.pass('Skipping - XAI vendor model not configured');
+    return;
+  }
+
+  const events = await collectSubscriptionEvents(wsClient, {
+    query: `
+      subscription($requestId: String!) {
+        requestProgress(requestIds: [$requestId]) { requestId progress data }
+      }
+    `,
+    variables: { requestId },
+  }, 20000, { requireCompletion: false, minEvents: 1 });
+
+  t.true(events.length > 0);
+});
+
+

package/tests/integration/graphql/async/stream/vendors/openai_streaming.test.js

@@ -0,0 +1,72 @@
+import test from 'ava';
+import serverFactory from '../../../../../../index.js';
+import { createWsClient, ensureWsConnection, collectSubscriptionEvents } from '../../../../../helpers/subscriptions.js';
+
+let testServer;
+let wsClient;
+
+test.before(async () => {
+  const { server, startServer } = await serverFactory();
+  startServer && await startServer();
+  testServer = server;
+  wsClient = createWsClient();
+  await ensureWsConnection(wsClient);
+});
+
+test.after.always('cleanup', async () => {
+  if (wsClient) wsClient.dispose();
+  if (testServer) await testServer.stop();
+});
+
+test('OpenAI vendor streaming over subscriptions emits OAI-style deltas', async (t) => {
+  const response = await testServer.executeOperation({
+    query: `
+      query($text: String!, $chatHistory: [MultiMessage]!, $stream: Boolean, $aiStyle: String) {
+        sys_entity_agent(text: $text, chatHistory: $chatHistory, stream: $stream, aiStyle: $aiStyle) {
+          result
+        }
+      }
+    `,
+    variables: {
+      text: 'Say hi',
+      chatHistory: [{ role: 'user', content: ['Say hi'] }],
+      stream: true,
+      aiStyle: 'OpenAI'
+    }
+  });
+
+  const requestId = response.body?.singleResult?.data?.sys_entity_agent?.result;
+  if (!requestId) {
+    t.pass('Skipping - OpenAI vendor model not configured');
+    return;
+  }
+
+  const events = await collectSubscriptionEvents(wsClient, {
+    query: `
+      subscription($requestId: String!) {
+        requestProgress(requestIds: [$requestId]) { requestId progress data }
+      }
+    `,
+    variables: { requestId },
+  }, 20000, { requireCompletion: false, minEvents: 1 });
+
+  t.true(events.length > 0);
+
+  // Ensure streamed chunks (when they include model) use gpt-4.1 (not mini)
+  const models = events
+    .map(e => {
+      try {
+        return JSON.parse(e?.data?.requestProgress?.data || '{}')?.model;
+      } catch (_) {
+        return undefined;
+      }
+    })
+    .filter(Boolean);
+
+  if (models.length > 0) {
+    t.truthy(models.find(m => /gpt-4\.1(?!-mini)/.test(m)));
+    t.falsy(models.find(m => /gpt-4\.1-mini/.test(m)));
+  }
+});
+
+

package/tests/integration/graphql/features/google/sysToolGoogleSearch.test.js

@@ -0,0 +1,96 @@
+import test from 'ava';
+import sinon from 'sinon';
+
+const mockGoogleResponse = {
+  searchInformation: {
+    totalResults: '123',
+    searchTime: 0.12
+  },
+  items: [
+    {
+      title: 'Pikachu - Wikipedia',
+      link: 'https://en.wikipedia.org/wiki/Pikachu',
+      snippet: 'Pikachu is a species of Pokémon...'
+    },
+    {
+      title: 'Pokemon News - Official Site',
+      link: 'https://www.pokemon.com/us',
+      snippet: 'The official source for Pokémon news...'
+    }
+  ]
+};
+
+// Build a minimal stub pathway for google_cse returning canned results
+const buildStubGooglePathway = () => ({
+  name: 'google_cse',
+  // Simulate the core rootResolver returning data.result
+  rootResolver: async () => {
+    return { result: JSON.stringify(mockGoogleResponse) };
+  }
+});
+
+// Build a minimal resolver object to pass to executePathway
+const buildResolver = () => ({
+  errors: [],
+  tool: null,
+  mergeResults: () => {},
+});
+
+// Ensure required env vars exist before importing config/tool
+const setEnv = (t) => {
+  t.context.originalEnv = { ...process.env };
+  process.env.OPENAI_API_KEY = 'test-openai-key';
+  process.env.GOOGLE_CSE_KEY = 'test-google-key';
+  process.env.GOOGLE_CSE_CX = 'test-google-cx';
+};
+
+const restoreEnv = (t) => {
+  process.env = t.context.originalEnv;
+};
+
+// We import modules lazily after env vars are set to avoid config init errors
+const loadModules = async () => {
+  const { config } = await import('../../../../../config.js');
+  const toolModule = await import('../../../../../pathways/system/entity/tools/sys_tool_google_search.js');
+  return { config, tool: toolModule.default };
+};
+
+// Helper to inject stub google_cse pathway
+const injectStubPathway = (config) => {
+  const existing = config.get('pathways') || {};
+  const modified = { ...existing, google_cse: buildStubGooglePathway() };
+  config.load({ pathways: modified });
+};
+
+// Test: normalization to SearchResponse
+
+test('sys_tool_google_search normalizes Google items into SearchResponse', async (t) => {
+  setEnv(t);
+  const { config, tool } = await loadModules();
+  injectStubPathway(config);
+
+  const resolver = buildResolver();
+  const args = { q: 'pokemon', userMessage: 'testing' };
+
+  const resultStr = await tool.executePathway({ args, runAllPrompts: null, resolver });
+  t.truthy(resultStr, 'Should return a stringified JSON response');
+
+  const result = JSON.parse(resultStr);
+  t.is(result._type, 'SearchResponse');
+  t.true(Array.isArray(result.value));
+
+  // Normalized items should match the CSE items length
+  const items = result.value;
+  t.is(items.length, mockGoogleResponse.items.length);
+  t.truthy(items[0].searchResultId);
+  t.is(items[0].title, mockGoogleResponse.items[0].title);
+  t.is(items[0].url, mockGoogleResponse.items[0].link);
+  t.is(items[0].content, mockGoogleResponse.items[0].snippet);
+
+  // Tool metadata is set
+  t.truthy(resolver.tool);
+  const toolMeta = JSON.parse(resolver.tool);
+  t.is(toolMeta.toolUsed, 'GoogleSearch');
+
+  restoreEnv(t);
+});