@bpmsoftwaresolutions/ai-engine-client 1.1.71 → 1.1.74

package/src/transport/index.js

@@ -0,0 +1,176 @@
+import { appendQuery, extractLogaProjectionMetadata, isJsonBody, parseContentDispositionFilename, readJson } from '../utils/http.js';
+
+export async function resolveAccessToken(client) {
+  if (typeof client.tokenProvider === 'function') {
+    const provided = await client.tokenProvider();
+    if (!provided) return null;
+    if (typeof provided === 'string') return provided;
+    if (typeof provided === 'object' && typeof provided.token === 'string') return provided.token;
+    if (typeof provided === 'object' && typeof provided.accessToken === 'string') return provided.accessToken;
+    throw new Error('tokenProvider must return a token string or an object with a token or accessToken field.');
+  }
+  return client.accessToken;
+}
+
+export async function buildHeaders(client, { headers, body, accept }) {
+  const token = await resolveAccessToken(client);
+  const resolvedHeaders = {
+    accept: accept || 'application/json',
+    'x-actor-id': client.actorId,
+    ...(client.agentSessionId ? { 'x-agent-session-id': client.agentSessionId } : {}),
+    'x-ai-engine-client-version': client.clientVersion,
+    'x-ai-engine-client-capabilities': client.clientCapabilities.join(','),
+    ...(isJsonBody(body) ? { 'content-type': 'application/json' } : {}),
+    ...(token ? { authorization: `Bearer ${token}` } : {}),
+    ...(!token && client.clientId ? { 'x-client-id': client.clientId } : {}),
+    ...(!token && client.apiKey ? { 'x-api-key': client.apiKey } : {}),
+    ...headers,
+  };
+  for (const [key, value] of Object.entries(resolvedHeaders)) {
+    if (value === undefined) delete resolvedHeaders[key];
+  }
+  return resolvedHeaders;
+}
+
+export async function requestJson(client, path, { method = 'GET', query, headers, body } = {}) {
+  const url = appendQuery(`${client.baseUrl}${path}`, query);
+  const controller = new AbortController();
+  const timeoutHandle = setTimeout(() => controller.abort(), client.timeoutMs);
+  try {
+    const resolvedHeaders = await buildHeaders(client, { headers, body, accept: 'application/json' });
+    const response = await client.fetchImpl(url, {
+      method,
+      headers: resolvedHeaders,
+      body: isJsonBody(body) ? JSON.stringify(body) : body,
+      signal: controller.signal,
+    });
+    const payload = await readJson(response);
+    if (!response.ok) {
+      const error = new Error(payload?.message || payload?.error || `Request failed with status ${response.status}.`);
+      error.status = response.status;
+      error.payload = payload;
+      throw error;
+    }
+    return payload;
+  } catch (error) {
+    if (error?.name === 'AbortError') {
+      const timeoutError = new Error(`Request to ${url.pathname} timed out after ${client.timeoutMs}ms.`);
+      timeoutError.code = 'REQUEST_TIMEOUT';
+      timeoutError.status = 0;
+      throw timeoutError;
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+
+export async function requestText(client, path, { method = 'GET', query, headers, body } = {}) {
+  const url = appendQuery(`${client.baseUrl}${path}`, query);
+  const controller = new AbortController();
+  const timeoutHandle = setTimeout(() => controller.abort(), client.timeoutMs);
+  try {
+    const resolvedHeaders = await buildHeaders(client, {
+      headers,
+      body,
+      accept: 'text/markdown, text/plain;q=0.9, application/json;q=0.8',
+    });
+    const response = await client.fetchImpl(url, {
+      method,
+      headers: resolvedHeaders,
+      body: isJsonBody(body) ? JSON.stringify(body) : body,
+      signal: controller.signal,
+    });
+    const contentType = response.headers.get('content-type') || '';
+    const contentDisposition = response.headers.get('content-disposition') || '';
+    const readResponseText = async () => {
+      if (typeof response.text === 'function') {
+        return response.text();
+      }
+      if (typeof response.json === 'function') {
+        const payload = await response.json();
+        return typeof payload === 'string' ? payload : JSON.stringify(payload);
+      }
+      return '';
+    };
+    if (!response.ok) {
+      const payload = contentType.includes('application/json')
+        ? await response.json()
+        : { message: await readResponseText() };
+      const error = new Error(payload?.message || payload?.error || `Request failed with status ${response.status}.`);
+      error.status = response.status;
+      error.payload = payload;
+      throw error;
+    }
+    return {
+      text: await readResponseText(),
+      contentType,
+      fileName: parseContentDispositionFilename(contentDisposition),
+      headers: Object.fromEntries(response.headers.entries()),
+    };
+  } catch (error) {
+    if (error?.name === 'AbortError') {
+      const timeoutError = new Error(`Request to ${url.pathname} timed out after ${client.timeoutMs}ms.`);
+      timeoutError.code = 'REQUEST_TIMEOUT';
+      timeoutError.status = 0;
+      throw timeoutError;
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+
+export async function requestLogaProjection(client, path, options = {}) {
+  const result = await requestText(client, path, options);
+  return {
+    ...result,
+    ...extractLogaProjectionMetadata(new Headers(result.headers || {})),
+  };
+}
+
+export async function requestBinary(client, path, { method = 'GET', query, headers, body } = {}) {
+  const url = appendQuery(`${client.baseUrl}${path}`, query);
+  const controller = new AbortController();
+  const timeoutHandle = setTimeout(() => controller.abort(), client.timeoutMs);
+  try {
+    const resolvedHeaders = await buildHeaders(client, {
+      headers,
+      body,
+      accept: 'audio/mpeg, application/octet-stream;q=0.9, application/json;q=0.8',
+    });
+    const response = await client.fetchImpl(url, {
+      method,
+      headers: resolvedHeaders,
+      body: isJsonBody(body) ? JSON.stringify(body) : body,
+      signal: controller.signal,
+    });
+    const contentType = response.headers.get('content-type') || '';
+    const contentDisposition = response.headers.get('content-disposition') || '';
+    if (!response.ok) {
+      const payload = contentType.includes('application/json')
+        ? await response.json()
+        : { message: await response.text() };
+      const error = new Error(payload?.message || payload?.error || `Request failed with status ${response.status}.`);
+      error.status = response.status;
+      error.payload = payload;
+      throw error;
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return {
+      arrayBuffer,
+      contentType,
+      fileName: parseContentDispositionFilename(contentDisposition),
+    };
+  } catch (error) {
+    if (error?.name === 'AbortError') {
+      const timeoutError = new Error(`Request to ${url.pathname} timed out after ${client.timeoutMs}ms.`);
+      timeoutError.code = 'REQUEST_TIMEOUT';
+      timeoutError.status = 0;
+      throw timeoutError;
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}

package/src/utils/http.js

@@ -0,0 +1,83 @@
+export function appendQuery(url, query) {
+  const target = new URL(url);
+  for (const [key, value] of Object.entries(query || {})) {
+    if (value === undefined || value === null || value === '') continue;
+    target.searchParams.set(key, String(value));
+  }
+  return target;
+}
+
+export function parseContentDispositionFilename(headerValue) {
+  const value = String(headerValue || '');
+  const quotedMatch = value.match(/filename="([^"]+)"/i);
+  if (quotedMatch) return quotedMatch[1];
+  const plainMatch = value.match(/filename=([^;]+)/i);
+  return plainMatch ? plainMatch[1].trim() : null;
+}
+
+export function readResponseHeader(headers, name) {
+  if (!headers || typeof headers.get !== 'function') return null;
+  return headers.get(name) || headers.get(name.toLowerCase()) || null;
+}
+
+export function extractLogaProjectionMetadata(headers) {
+  const projectionWorkflow = readResponseHeader(headers, 'x-projection-workflow');
+  const projectionVersion = readResponseHeader(headers, 'x-projection-version');
+  const sourceVersion = readResponseHeader(headers, 'x-source-version');
+  const correlationId = readResponseHeader(headers, 'x-correlation-id');
+  const logaContract = readResponseHeader(headers, 'x-loga-contract');
+  const navigationContract = readResponseHeader(headers, 'x-navigation-contract');
+  const projectionType = readResponseHeader(headers, 'x-projection-type');
+  const sourceTruth = readResponseHeader(headers, 'x-source-truth');
+  const refreshPolicy = readResponseHeader(headers, 'x-refresh-policy');
+  const generatedAt = readResponseHeader(headers, 'x-generated-at');
+
+  return {
+    logaContract,
+    navigationContract,
+    interactionContract: 'loga-choreography/v1',
+    projectionType,
+    projectionWorkflow,
+    projectionVersion,
+    sourceTruth,
+    sourceVersion,
+    correlationId,
+    refreshPolicy,
+    generatedAt,
+    provenance: {
+      sourceTruth,
+      sourceVersion,
+      projectionVersion,
+      projectionWorkflow,
+      correlationId,
+      generatedAt,
+    },
+  };
+}
+
+export function isFormDataBody(value) {
+  return typeof FormData !== 'undefined' && value instanceof FormData;
+}
+
+export function isBinaryBody(value) {
+  return (
+    value instanceof ArrayBuffer
+    || ArrayBuffer.isView(value)
+    || (typeof Blob !== 'undefined' && value instanceof Blob)
+    || value instanceof URLSearchParams
+    || typeof value === 'string'
+  );
+}
+
+export function isJsonBody(value) {
+  if (value === undefined || value === null) return false;
+  if (isFormDataBody(value) || isBinaryBody(value)) return false;
+  return typeof value === 'object';
+}
+
+export async function readJson(response) {
+  const contentType = response.headers.get('content-type') || '';
+  if (contentType.includes('application/json')) return response.json();
+  const text = await response.text();
+  return { message: text };
+}

package/src/utils/text.js

@@ -0,0 +1,30 @@
+export function cleanText(value) {
+  const text = String(value || '').trim();
+  return text || null;
+}
+
+export function cleanList(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map(cleanText).filter(Boolean);
+}
+
+export function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function trimTrailingSlash(value) {
+  return String(value || '').replace(/\/+$/, '');
+}
+
+export function normalizeEnum(value, allowed, defaultValue, fieldName, aliases = {}) {
+  const text = cleanText(value);
+  if (!text) return defaultValue;
+  let normalized = text.toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(aliases, normalized)) {
+    normalized = aliases[normalized];
+  }
+  if (!allowed.includes(normalized)) {
+    throw new Error(`${fieldName} must be one of ${allowed.join(', ')}.`);
+  }
+  return normalized;
+}