@bpmsoftwaresolutions/ai-engine-client 1.1.31 → 1.1.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmsoftwaresolutions/ai-engine-client",
-  "version": "1.1.31",
+  "version": "1.1.33",
   "description": "Thin npm client for the AI Engine operator and retrieval APIs",
   "type": "module",
   "main": "./src/index.js",

package/src/index.js

@@ -1,5 +1,5 @@
 const DEFAULT_TIMEOUT_MS = 30000;
-export const AI_ENGINE_CLIENT_VERSION = '1.1.31';
+export const AI_ENGINE_CLIENT_VERSION = '1.1.33';
 export const GOVERNED_MUTATION_REQUIRED_CAPABILITIES = [
   'executeVerifiedMutation',
   'post_mutation_verification',
@@ -19,6 +19,7 @@ export const LOGA_CONTRACT = 'ai-engine-ui/v1';
 export const LOGA_INTERACTION_CONTRACT = 'loga-choreography/v1';
 export const LOGA_NAVIGATION_CONTRACT = 'loga-navigation/v1';
 export const LOGA_PROJECTION_WORKFLOW = 'loga-document-projection';
+export const TASK_BOUND_SUBSTRATE_EXECUTION_POLICY = 'task_bound_substrate_execution/v1';
 
 function trimTrailingSlash(value) {
   return String(value || '').replace(/\/+$/, '');
@@ -122,6 +123,35 @@ function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
+function normalizeTaskBindingPolicy(taskBinding, { expectedAction = null } = {}) {
+  if (!isPlainObject(taskBinding)) return taskBinding;
+  const taskId = cleanText(taskBinding.task_id || taskBinding.implementation_item_task_id);
+  const roadmapItemId = cleanText(taskBinding.roadmap_item_id || taskBinding.implementation_item_id);
+  const taskStatus = cleanText(taskBinding.task_status || taskBinding.status);
+  const allowedActions = cleanList(taskBinding.allowed_actions);
+  const substrateAction = cleanText(taskBinding.substrate_action) || cleanText(expectedAction);
+  return {
+    ...taskBinding,
+    ...(taskId ? { task_id: taskId } : {}),
+    ...(roadmapItemId ? { roadmap_item_id: roadmapItemId, implementation_item_id: roadmapItemId } : {}),
+    ...(taskStatus ? { task_status: taskStatus } : {}),
+    ...(allowedActions.length > 0 ? { allowed_actions: allowedActions } : {}),
+    ...(substrateAction ? { substrate_action: substrateAction } : {}),
+    policy_key: cleanText(taskBinding.policy_key) || 'task_bound_substrate_execution',
+    policy_version: cleanText(taskBinding.policy_version) || 'v1',
+    policy_identifier: cleanText(taskBinding.policy_identifier) || TASK_BOUND_SUBSTRATE_EXECUTION_POLICY,
+  };
+}
+
+function normalizeMetadataTaskBinding(metadata, { expectedAction = null } = {}) {
+  if (!isPlainObject(metadata)) return metadata;
+  if (!isPlainObject(metadata.task_binding)) return metadata;
+  return {
+    ...metadata,
+    task_binding: normalizeTaskBindingPolicy(metadata.task_binding, { expectedAction }),
+  };
+}
+
 function isActiveBinding(binding) {
   return isPlainObject(binding) && (
     binding.is_active === true ||
@@ -221,6 +251,13 @@ export class AIEngineClient {
       promoteUxGateRemediationImplementationCandidate: (remediationId, payload) =>
         this.promoteUxGateRemediationImplementationCandidate(remediationId, payload),
       getUxGateRemediationProjection: (remediationId) => this.getLogaUxGateRemediationProjection(remediationId),
+      getGeneratedExecutionUsabilityProjection: (query) => this.getLogaGeneratedExecutionUsabilityProjection(query),
+    };
+    this.executionTelemetry = {
+      getCurrent: () => this.getExecutionTelemetryCurrent(),
+      listProcessRuns: (query) => this.listExecutionProcessRuns(query),
+      getProcessRun: (processRunId) => this.getExecutionProcessRun(processRunId),
+      getGeneratedExecutionUsability: (query) => this.getGeneratedExecutionUsability(query),
     };
     this.scripts = {
       generate: (payload) => this.generateScript(payload),
@@ -272,6 +309,32 @@ export class AIEngineClient {
     });
   }
 
+  async getExecutionTelemetryCurrent() {
+    return this._request('/api/operator/execution-telemetry/current');
+  }
+
+  async listExecutionProcessRuns({ limit, artifactKind, status, since } = {}) {
+    return this._request('/api/operator/execution-telemetry/process-runs', {
+      query: { limit, artifact_kind: artifactKind, status, since },
+    });
+  }
+
+  async getExecutionProcessRun(processRunId) {
+    return this._request(`/api/operator/execution-telemetry/process-runs/${processRunId}`);
+  }
+
+  async getGeneratedExecutionUsability({ artifactPath, limit } = {}) {
+    return this._request('/api/operator/generated-execution-usability', {
+      query: { artifact_path: artifactPath, limit },
+    });
+  }
+
+  async getLogaGeneratedExecutionUsabilityProjection({ artifactPath, limit } = {}) {
+    return this._requestLogaProjection('/api/loga/ai-engine/generated-execution-usability', {
+      query: { artifact_path: artifactPath, limit },
+    });
+  }
+
   async getAntiPatternRules() {
     return this._request('/api/governance/anti-pattern-rules');
   }
@@ -497,13 +560,22 @@ export class AIEngineClient {
         execution_purpose: executionPurpose,
         success_criteria: successCriteria,
         mutation_allowed: mutationAllowed,
-        metadata,
+        metadata: normalizeMetadataTaskBinding(metadata),
       },
     });
   }
 
   async claimWorkItem(body = {}) {
-    return this._request('/api/governance/claims/claim-work-item', { method: 'POST', body });
+    const normalizedBody = isPlainObject(body)
+      ? {
+          ...body,
+          ...(isPlainObject(body.task_binding)
+            ? { task_binding: normalizeTaskBindingPolicy(body.task_binding) }
+            : {}),
+          metadata: normalizeMetadataTaskBinding(body.metadata),
+        }
+      : body;
+    return this._request('/api/governance/claims/claim-work-item', { method: 'POST', body: normalizedBody });
   }
 
   async bindClaimedWorkItem({
@@ -873,9 +945,17 @@ export class AIEngineClient {
 
   async routeImplementationItem(implementationItemId, body = {}) {
     if (!implementationItemId) throw new Error('implementationItemId is required.');
+    const normalizedBody = isPlainObject(body)
+      ? {
+          ...body,
+          ...(isPlainObject(body.task_binding)
+            ? { task_binding: normalizeTaskBindingPolicy(body.task_binding) }
+            : {}),
+        }
+      : body;
     return this._request(`/api/governed-implementation/items/${encodeURIComponent(implementationItemId)}/routing`, {
       method: 'PATCH',
-      body,
+      body: normalizedBody,
     });
   }