@bpmsoftwaresolutions/ai-engine-client 1.1.88 → 1.1.89

package/src/domains/charters.js

@@ -0,0 +1,5 @@
+export function createChartersDomain(client) {
+  return {
+    runCharter: (body = {}) => client._request('/api/charters/run', { method: 'POST', body }),
+  };
+}

package/src/domains/claims.js

@@ -0,0 +1,58 @@
+import { cleanText } from '../utils/text.js';
+
+export function createClaimsDomain(client) {
+  return {
+    getClaim: (claimId) => {
+      if (!claimId) throw new Error('claimId is required.');
+      return client._request(`/api/governance/claims/${encodeURIComponent(claimId)}`);
+    },
+    claimIsValid: async (claimId) => {
+      const claim = await client.getClaim(claimId);
+      return cleanText(claim?.status) === 'active';
+    },
+    signoffClaim: (claimId, body = {}) => {
+      if (!claimId) throw new Error('claimId is required.');
+      return client._request(`/api/governance/claims/${encodeURIComponent(claimId)}/signoff`, {
+        method: 'POST',
+        body,
+      });
+    },
+    promoteClaimSurface: ({
+      claimId,
+      workflowId,
+      contextSessionId,
+      actorId,
+      requiredToolKeys,
+      intentId,
+      bindingScope,
+      usageMode,
+      operatorScope,
+      allowedArgumentPolicy,
+      ...rest
+    } = {}) => {
+      if (!claimId) throw new Error('claimId is required.');
+      if (!workflowId) throw new Error('workflowId is required.');
+      if (!contextSessionId) throw new Error('contextSessionId is required.');
+      if (!actorId) throw new Error('actorId is required.');
+      if (!Array.isArray(requiredToolKeys) || requiredToolKeys.length === 0) {
+        throw new Error('requiredToolKeys must be a non-empty array.');
+      }
+      return client._request('/api/governance/claims/promote-surface', {
+        method: 'POST',
+        body: {
+          ...rest,
+          claim_id: claimId,
+          workflow_id: workflowId,
+          context_session_id: contextSessionId,
+          actor_id: actorId,
+          required_tool_keys: requiredToolKeys,
+          intent_id: intentId,
+          binding_scope: bindingScope,
+          usage_mode: usageMode,
+          operator_scope: operatorScope,
+          allowed_argument_policy: allowedArgumentPolicy,
+        },
+      });
+    },
+  };
+}

package/src/domains/commit-governance.js

@@ -0,0 +1,68 @@
+export function createCommitGovernanceDomain(client) {
+  return {
+    evaluateCommitGovernance: ({
+      claimId,
+      contextSessionId,
+      agentId,
+      intentId,
+      changedFiles,
+      declaredScopeFiles,
+      diffSummary,
+      branch,
+      headSha,
+    } = {}) => client._request('/api/commit-governance/evaluate', {
+      method: 'POST',
+      body: {
+        claim_id: claimId,
+        context_session_id: contextSessionId,
+        agent_id: agentId,
+        intent_id: intentId,
+        changed_files: changedFiles,
+        declared_scope_files: declaredScopeFiles,
+        diff_summary: diffSummary,
+        branch,
+        head_sha: headSha,
+      },
+    }),
+    checkGitShipReadiness: ({
+      claimId,
+      actorId,
+      targetBranch,
+      shipCommand,
+      packageName,
+      declaredScopeFiles,
+      stagedFiles,
+      dirtyFiles,
+      branch,
+      headSha,
+      packageJsonVersion,
+      facadeMinClientVersion,
+      packageRelease,
+      packageJsonHash,
+      sdkVersionHash,
+    } = {}) => client._request('/api/commit-governance/ship-readiness', {
+      method: 'POST',
+      body: {
+        claim_id: claimId,
+        actor_id: actorId,
+        target_branch: targetBranch,
+        ship_command: shipCommand,
+        package_name: packageName,
+        declared_scope_files: declaredScopeFiles,
+        staged_files: stagedFiles,
+        dirty_files: dirtyFiles,
+        branch,
+        head_sha: headSha,
+        package_json_version: packageJsonVersion,
+        facade_min_client_version: facadeMinClientVersion,
+        package_release: packageRelease,
+        package_json_hash: packageJsonHash,
+        sdk_version_hash: sdkVersionHash,
+      },
+    }),
+    getCommitGovernanceEvaluation: (evaluationId) => client._request(`/api/commit-governance/evaluations/${encodeURIComponent(evaluationId)}`),
+    listCommitGovernanceEvaluationsByClaim: (claimId, { limit } = {}) => client._request(`/api/commit-governance/claims/${encodeURIComponent(claimId)}/evaluations`, {
+      query: { limit },
+    }),
+  };
+}

package/src/domains/context-orientation.js

@@ -0,0 +1,48 @@
+export function createContextOrientationDomain(client) {
+  return {
+    conductOrientation: async ({
+      agentId,
+      runtimeSessionId,
+      intentId,
+      executionPurpose,
+      agentSignature,
+      understandingSummary,
+      lockClaim = true,
+    } = {}) => {
+      const { context_session, reminders } = await client.contextSessions.openContextSession({
+        agentId,
+        runtimeSessionId,
+        intentId,
+        executionPurpose,
+      });
+      const sessionId = context_session.context_session_id;
+
+      const required = (reminders || []).filter((reminder) => reminder.severity === 'required');
+      let acknowledgedCount = 0;
+      for (const reminder of required) {
+        await client.contextSessions.acknowledgeReminder(sessionId, {
+          reminderId: reminder.reminder_id,
+          agentSignature,
+          understandingSummary,
+        });
+        acknowledgedCount++;
+      }
+
+      const completion = await client.contextSessions.completeOrientation(sessionId);
+
+      let claimLockResult = null;
+      if (lockClaim) {
+        claimLockResult = await client.contextSessions.lockContextSessionClaim(sessionId);
+      }
+
+      return {
+        context_session_id: sessionId,
+        intent_id: intentId,
+        context_session: claimLockResult?.context_session || completion.context_session,
+        gate_result: claimLockResult?.gate_result || completion.gate_result,
+        acknowledged_count: acknowledgedCount,
+        claim_locked: lockClaim && !!claimLockResult,
+      };
+    },
+  };
+}

package/src/domains/context-sessions.js

@@ -0,0 +1,46 @@
+import { cleanText } from '../utils/text.js';
+
+export function contextSessionIdFromInput(input) {
+  if (input !== null && typeof input === 'object' && !Array.isArray(input)) {
+    return cleanText(input.contextSessionId)
+      || cleanText(input.context_session_id)
+      || cleanText(input.context_session?.context_session_id)
+      || cleanText(input.claim?.context_session_id);
+  }
+  return cleanText(input);
+}
+
+export function createContextSessionsDomain(client) {
+  return {
+    openContextSession: ({ agentId, runtimeSessionId, intentId, executionPurpose, notes } = {}) => client._request('/api/context-session/open', {
+      method: 'POST',
+      body: {
+        agent_id: agentId,
+        runtime_session_id: runtimeSessionId,
+        intent_id: intentId,
+        execution_purpose: executionPurpose,
+        notes,
+      },
+    }),
+    getOrientationWindow: (contextSessionId) => client._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/window`),
+    acknowledgeReminder: (contextSessionId, { reminderId, agentSignature, understandingSummary } = {}) => client._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/acknowledge`, {
+      method: 'POST',
+      body: {
+        reminder_id: reminderId,
+        agent_signature: agentSignature,
+        understanding_summary: understandingSummary,
+      },
+    }),
+    completeOrientation: (contextSessionId) => client._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/complete`, {
+      method: 'POST',
+    }),
+    lockContextSessionClaim: (input) => {
+      const contextSessionId = contextSessionIdFromInput(input);
+      if (!contextSessionId) throw new Error('contextSessionId is required.');
+      return client._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/lock-claim`, {
+        method: 'POST',
+      });
+    },
+    getContextSessionGateStatus: (contextSessionId) => client._request(`/api/context-session/${encodeURIComponent(contextSessionId)}/gate-status`),
+  };
+}

package/src/domains/execution-eligibility.js

@@ -0,0 +1,44 @@
+import { cleanText } from '../utils/text.js';
+import { GOVERNED_MUTATION_REQUIRED_CAPABILITIES } from '../constants/governance.js';
+
+export function buildEligibilityError(message, details = {}) {
+  const error = new Error(message);
+  error.code = 'EXECUTION_ELIGIBILITY_FAILED';
+  error.details = details;
+  return error;
+}
+
+export function createExecutionEligibilityDomain(client) {
+  return {
+    getExecutionEligibility: (body = {}) => client._request('/api/governance/execution-eligibility', {
+      method: 'POST',
+      body: {
+        required_capabilities: GOVERNED_MUTATION_REQUIRED_CAPABILITIES,
+        verification_required: true,
+        ...body,
+      },
+    }),
+    _assertExecutionEligibility: async (body = {}) => {
+      const eligibility = await client.getExecutionEligibility(body);
+      if (eligibility?.execution_eligible && eligibility?.mutation_allowed) {
+        return eligibility;
+      }
+      const remediation = cleanText(eligibility?.remediation_command);
+      const verification = cleanText(eligibility?.verification_command);
+      throw buildEligibilityError(
+        [
+          `Execution eligibility gate blocked mutation${cleanText(body?.requested_mutation_surface) ? ` on ${cleanText(body.requested_mutation_surface)}` : ''}.`,
+          remediation ? `Fix: ${remediation}` : null,
+          verification ? `Then verify: ${verification}` : null,
+        ].filter(Boolean).join(' '),
+        {
+          required_gate: eligibility?.required_gate || 'execution_eligibility.required_gate',
+          execution_eligibility: eligibility ?? null,
+          requested_mutation_surface: cleanText(body?.requested_mutation_surface) || null,
+          remediation_command: remediation || null,
+          verification_command: verification || null,
+        },
+      );
+    },
+  };
+}

package/src/domains/governed-implementation.js

@@ -0,0 +1,7 @@
+export function createGovernedImplementationDomain(client) {
+  return {
+    getExecutionEligibility: (body = {}) => client.executionEligibility.getExecutionEligibility(body),
+    _assertExecutionEligibility: (body = {}) => client.executionEligibility._assertExecutionEligibility(body),
+    executeVerifiedMutation: (request = {}) => client.verifiedMutations.executeVerifiedMutation(request),
+  };
+}

package/src/domains/session-governance.js

@@ -0,0 +1,64 @@
+export function createSessionGovernanceDomain(client) {
+  return {
+    startSessionGovernance: ({
+      intent,
+      objective,
+      allowedScopes,
+      allowedMutationSurfaces,
+      requiredToolKeys,
+      sessionKey,
+      workflowRunId,
+      workflowId,
+      workflowSlug,
+      governedScope,
+      successCriteria,
+      disallowedSurfaces,
+      ...rest
+    } = {}) => client._request('/api/v1/session-governance/startup', {
+      method: 'POST',
+      body: {
+        ...rest,
+        objective: objective ?? intent,
+        allowed_mutation_surfaces: allowedMutationSurfaces ?? allowedScopes,
+        required_tool_keys: requiredToolKeys,
+        session_key: sessionKey,
+        workflow_run_id: workflowRunId,
+        workflow_id: workflowId,
+        workflow_slug: workflowSlug,
+        governed_scope: governedScope,
+        success_criteria: successCriteria,
+        disallowed_surfaces: disallowedSurfaces,
+      },
+    }),
+    startReviewGovernance: ({
+      intent,
+      objective,
+      readScope,
+      requiredToolKeys,
+      sessionKey,
+      workflowRunId,
+      workflowId,
+      workflowSlug,
+      turnPersisted,
+      ...rest
+    } = {}) => client._request('/api/v1/session-governance/review/startup', {
+      method: 'POST',
+      body: {
+        ...rest,
+        intent: intent ?? 'review code',
+        objective: objective ?? intent,
+        read_scope: readScope,
+        required_tool_keys: requiredToolKeys,
+        session_key: sessionKey,
+        workflow_run_id: workflowRunId,
+        workflow_id: workflowId,
+        workflow_slug: workflowSlug ?? 'code-review/read-only',
+        turn_persisted: turnPersisted,
+      },
+    }),
+    evaluateTurnCompliance: (sessionId) => client._request(`/api/v1/session-governance/${encodeURIComponent(sessionId)}/compliance`),
+    blockIfNonCompliant: (sessionId) => client._request(`/api/v1/session-governance/${encodeURIComponent(sessionId)}/block-if-non-compliant`, {
+      method: 'POST',
+    }),
+  };
+}

package/src/domains/tool-binding-approvals.js

@@ -0,0 +1,102 @@
+export function createToolBindingApprovalsDomain(client) {
+  return {
+    createWorkflowToolBindingApprovalLane: ({
+      operatorActorType,
+      requesterActor,
+      requestedToolKeys,
+      blockedReason,
+      rollbackPlan,
+      requesterActorType,
+      operatorActorId,
+      targetWorkflowId,
+      targetWorkflowRunId,
+      relatedGapRecordIds,
+      requestedBindingScope,
+      riskClassification,
+      metadata,
+      ...rest
+    } = {}) => {
+      if (!operatorActorType) throw new Error('operatorActorType is required.');
+      if (!requesterActor) throw new Error('requesterActor is required.');
+      if (!Array.isArray(requestedToolKeys) || requestedToolKeys.length === 0) {
+        throw new Error('requestedToolKeys must be a non-empty array.');
+      }
+      if (!blockedReason) throw new Error('blockedReason is required.');
+      if (!rollbackPlan) throw new Error('rollbackPlan is required.');
+      return client._request('/api/governance/bootstrap/workflow-tool-binding-approval/create', {
+        method: 'POST',
+        body: {
+          ...rest,
+          operator_actor_type: operatorActorType,
+          requester_actor: requesterActor,
+          requested_tool_keys: requestedToolKeys,
+          blocked_reason: blockedReason,
+          rollback_plan: rollbackPlan,
+          requester_actor_type: requesterActorType,
+          operator_actor_id: operatorActorId,
+          target_workflow_id: targetWorkflowId,
+          target_workflow_run_id: targetWorkflowRunId,
+          related_gap_record_ids: relatedGapRecordIds,
+          requested_binding_scope: requestedBindingScope,
+          risk_classification: riskClassification,
+          metadata,
+        },
+      });
+    },
+    recordWorkflowToolBindingApprovalDecision: (approvalRequestId, {
+      operatorActorType,
+      decision,
+      operatorActorId,
+      decisionNotes,
+      decisionConditions,
+      ...rest
+    } = {}) => {
+      if (!approvalRequestId) throw new Error('approvalRequestId is required.');
+      if (!operatorActorType) throw new Error('operatorActorType is required.');
+      if (!decision) throw new Error('decision is required.');
+      return client._request(`/api/governance/bootstrap/workflow-tool-binding-approval/${encodeURIComponent(approvalRequestId)}/approval-decision`, {
+        method: 'POST',
+        body: {
+          ...rest,
+          operator_actor_type: operatorActorType,
+          operator_actor_id: operatorActorId,
+          decision,
+          decision_notes: decisionNotes,
+          decision_conditions: decisionConditions,
+        },
+      });
+    },
+    executeWorkflowToolBindingApprovalBinding: (approvalRequestId, {
+      operatorActorType,
+      operatorActorId,
+      ...rest
+    } = {}) => {
+      if (!approvalRequestId) throw new Error('approvalRequestId is required.');
+      if (!operatorActorType) throw new Error('operatorActorType is required.');
+      return client._request(`/api/governance/bootstrap/workflow-tool-binding-approval/${encodeURIComponent(approvalRequestId)}/binding-execution`, {
+        method: 'POST',
+        body: {
+          ...rest,
+          operator_actor_type: operatorActorType,
+          operator_actor_id: operatorActorId,
+        },
+      });
+    },
+    revalidateWorkflowToolBindingStartup: (approvalRequestId, {
+      operatorActorType,
+      operatorActorId,
+      ...rest
+    } = {}) => {
+      if (!approvalRequestId) throw new Error('approvalRequestId is required.');
+      if (!operatorActorType) throw new Error('operatorActorType is required.');
+      return client._request(`/api/governance/bootstrap/workflow-tool-binding-approval/${encodeURIComponent(approvalRequestId)}/startup-revalidation`, {
+        method: 'POST',
+        body: {
+          ...rest,
+          operator_actor_type: operatorActorType,
+          operator_actor_id: operatorActorId,
+        },
+      });
+    },
+  };
+}

package/src/domains/verified-mutations.js

@@ -0,0 +1,7 @@
+import { executeVerifiedMutation as executeVerifiedMutationHelper } from '../utils/verified-mutations.js';
+
+export function createVerifiedMutationsDomain(client) {
+  return {
+    executeVerifiedMutation: (request = {}) => executeVerifiedMutationHelper(request),
+  };
+}

package/src/domains/work-start.js

@@ -0,0 +1,192 @@
+import { cleanList, cleanText, isPlainObject } from '../utils/text.js';
+import { normalizeMetadataTaskBinding, normalizeTaskBindingPolicy } from '../utils/task-binding.js';
+import { contextSessionIdFromInput } from './context-sessions.js';
+
+function isActiveBinding(binding) {
+  return binding !== null && typeof binding === 'object' && !Array.isArray(binding) && (
+    binding.is_active === true ||
+    binding.is_active === 1 ||
+    binding.is_active === 'true' ||
+    binding.is_active === 'True'
+  );
+}
+
+function activeToolKeysFromRegistry(registry) {
+  const bindings = Array.isArray(registry?.bindings) ? registry.bindings : [];
+  const seen = new Set();
+  const keys = [];
+  for (const binding of bindings) {
+    if (!isActiveBinding(binding)) continue;
+    const key = cleanText(binding.tool_key);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    keys.push(key);
+  }
+  return keys;
+}
+
+function reminderTokens(reminders) {
+  const tokens = [];
+  for (const reminder of Array.isArray(reminders) ? reminders : []) {
+    if (reminder === null || typeof reminder !== 'object' || Array.isArray(reminder)) continue;
+    for (const value of [reminder.reminder_key, reminder.reminder_id]) {
+      const token = cleanText(value);
+      if (token && !tokens.includes(token)) tokens.push(token);
+    }
+  }
+  return tokens;
+}
+
+export function createWorkStartDomain(client) {
+  return {
+    startWork: (body = {}) => client._request('/api/work/start', { method: 'POST', body }),
+    startClaimedWork: ({
+      claimName,
+      actorId,
+      intentId,
+      declaredScopeFiles,
+      allowedMutationSurfaces,
+      runtimeSessionId,
+      executionPurpose,
+      successCriteria,
+      mutationAllowed,
+      metadata,
+      ...rest
+    } = {}) => client._request('/api/governance/claims/start-claimed-work', {
+      method: 'POST',
+      body: {
+        ...rest,
+        claim_name: claimName,
+        actor_id: actorId,
+        intent_id: intentId,
+        declared_scope_files: declaredScopeFiles,
+        allowed_mutation_surfaces: allowedMutationSurfaces,
+        runtime_session_id: runtimeSessionId,
+        execution_purpose: executionPurpose,
+        success_criteria: successCriteria,
+        mutation_allowed: mutationAllowed,
+        metadata: normalizeMetadataTaskBinding(metadata),
+      },
+    }),
+    claimWorkItem: (body = {}) => {
+      const normalizedBody = body !== null && typeof body === 'object' && !Array.isArray(body)
+        ? {
+            ...body,
+            ...(body.task_binding !== null && typeof body.task_binding === 'object' && !Array.isArray(body.task_binding)
+              ? { task_binding: normalizeTaskBindingPolicy(body.task_binding) }
+              : {}),
+            metadata: normalizeMetadataTaskBinding(body.metadata),
+          }
+        : body;
+      return client._request('/api/governance/claims/claim-work-item', { method: 'POST', body: normalizedBody });
+    },
+    bindClaimedWorkItem: async ({
+      claimId,
+      contextSessionId,
+      workflowRunId,
+      agentSessionId,
+      claimedItemId,
+      claimedItemKey,
+      claimName,
+      actorId,
+      workflowId,
+      workflowSlug,
+      requiredToolKeys,
+      declaredScopeFiles,
+      allowedMutationSurfaces,
+      successCriteria,
+      acknowledgedReminders,
+      intentConfirmation,
+      actorSignature,
+      autoSignoff = true,
+      metadata,
+    } = {}) => {
+      const normalizedContextSessionId = contextSessionIdFromInput({
+        contextSessionId,
+        context_session_id: contextSessionId,
+        claim: { context_session_id: contextSessionId },
+      });
+      const normalizedClaimId = cleanText(claimId);
+      const normalizedWorkflowRunId = cleanText(workflowRunId);
+      const normalizedAgentSessionId = cleanText(agentSessionId);
+      const normalizedClaimedItemId = cleanText(claimedItemId);
+      const normalizedClaimedItemKey = cleanText(claimedItemKey);
+      const normalizedClaimedItemRef = normalizedClaimedItemId || normalizedClaimedItemKey;
+      if (!normalizedContextSessionId) throw new Error('contextSessionId is required.');
+      if (!normalizedWorkflowRunId) throw new Error('workflowRunId is required.');
+      if (!normalizedAgentSessionId) throw new Error('agentSessionId is required.');
+      if (!normalizedClaimedItemRef) throw new Error('claimedItemId or claimedItemKey is required.');
+
+      const normalizedWorkflowId = cleanText(workflowId);
+      const normalizedWorkflowSlug = cleanText(workflowSlug);
+      let normalizedRequiredToolKeys = cleanList(requiredToolKeys);
+      let workflowRegistry = null;
+      if (normalizedRequiredToolKeys.length === 0 && (normalizedWorkflowId || normalizedWorkflowSlug)) {
+        workflowRegistry = await client.getWorkflowToolRegistry({
+          workflowId: normalizedWorkflowId,
+          workflowSlug: normalizedWorkflowSlug,
+        });
+        normalizedRequiredToolKeys = activeToolKeysFromRegistry(workflowRegistry);
+      }
+
+      const lockClaimResult = await client.contextSessions.lockContextSessionClaim(normalizedContextSessionId);
+      const lockedContextSession = lockClaimResult?.context_session || lockClaimResult;
+      const lockedContextSessionId = contextSessionIdFromInput(lockedContextSession) || normalizedContextSessionId;
+
+      const claimWorkItemResult = await client.claimWorkItem({
+        context_session_id: lockedContextSessionId,
+        workflow_run_id: normalizedWorkflowRunId,
+        agent_session_id: normalizedAgentSessionId,
+        claimed_item_id: normalizedClaimedItemId,
+        claimed_item_key: normalizedClaimedItemKey,
+        claim_name: claimName,
+        actor_id: actorId,
+        workflow_id: normalizedWorkflowId,
+        workflow_slug: normalizedWorkflowSlug,
+        required_tool_keys: normalizedRequiredToolKeys,
+        declared_scope_files: cleanList(declaredScopeFiles).length > 0
+          ? cleanList(declaredScopeFiles)
+          : [normalizedClaimedItemRef],
+        allowed_mutation_surfaces: cleanList(allowedMutationSurfaces).length > 0
+          ? cleanList(allowedMutationSurfaces)
+          : ['project_roadmap_task'],
+        success_criteria: successCriteria,
+        metadata,
+      });
+
+      let signedClaim = null;
+      const resolvedClaimId = cleanText(claimWorkItemResult?.claim_id) || normalizedClaimId;
+      if (autoSignoff && resolvedClaimId) {
+        const claimEnvelope = isPlainObject(claimWorkItemResult?.claim) ? claimWorkItemResult.claim : claimWorkItemResult;
+        const reminders = cleanList(acknowledgedReminders).length > 0
+          ? cleanList(acknowledgedReminders)
+          : reminderTokens(claimEnvelope?.required_reminders);
+        if (reminders.length > 0) {
+          signedClaim = await client.signoffClaim(resolvedClaimId, {
+            acknowledged_reminders: reminders,
+            intent_confirmation: cleanText(intentConfirmation) || 'I confirm this governed execution intent and scope.',
+            actor_signature: cleanText(actorSignature) || cleanText(actorId) || client.actorId,
+          });
+        }
+      }
+
+      return {
+        claim_id: resolvedClaimId,
+        context_session_id: lockedContextSessionId,
+        workflow_run_id: normalizedWorkflowRunId,
+        agent_session_id: normalizedAgentSessionId,
+        required_tool_keys: normalizedRequiredToolKeys,
+        workflow_registry: workflowRegistry,
+        lock_claim_result: lockClaimResult,
+        claim_work_item_result: claimWorkItemResult,
+        signed_claim: signedClaim,
+        approved_tool_keys: cleanList(
+          signedClaim?.approved_tool_keys ||
+          signedClaim?.claim?.approved_tool_keys ||
+          claimWorkItemResult?.approved_tool_keys ||
+          claimWorkItemResult?.claim?.approved_tool_keys
+        ),
+      };
+    },
+  };
+}

package/src/domains/workflow-turns.js

@@ -0,0 +1,6 @@
+export function createWorkflowTurnsDomain(client) {
+  return {
+    completeTurn: (body = {}) => client._request('/api/turns/complete', { method: 'POST', body }),
+    persistAssistantTurn: (body) => client._request('/api/v1/assistant-turns', { method: 'POST', body }),
+  };
+}

package/src/index.js

@@ -1,5 +1,5 @@
 export { AIEngineClient, createAIEngineClient } from './client.js';
-export const AI_ENGINE_CLIENT_VERSION = '1.1.88';
+export const AI_ENGINE_CLIENT_VERSION = '1.1.89';
 export { GOVERNED_MUTATION_REQUIRED_CAPABILITIES, AI_ENGINE_CLIENT_CAPABILITIES, TASK_BOUND_SUBSTRATE_EXECUTION_POLICY } from './constants/governance.js';
 export { LOGA_CONTRACT, LOGA_INTERACTION_CONTRACT, LOGA_NAVIGATION_CONTRACT, LOGA_PROJECTION_WORKFLOW } from './constants/loga.js';
 export {