@exellix/graph-engine 7.8.0 → 7.8.2

package/CHANGELOG.md

@@ -1,10 +1,38 @@
 # Changelog
 
+## 7.8.2
+
+### Fixed
+
+- **ai-tasks error propagation:** Node failures preserve upstream `error.code` and full `error.message` from `@exellix/ai-tasks` (no `TASK_RUN_FAILED: {skillKey}` message wrapper).
+- **Activix node fail records:** `failRecord` updates include `errorCode` alongside the upstream error message.
+
+### Changed
+
+- **Dependencies:** `@exellix/ai-tasks` ^8.8.0 (transitive: `@exellix/ai-skills` ≥6.5.0, `@exellix/xynthesis` ≥4.6.0, `@x12i/ai-profiles` ≥3.2.0).
+
+### Added
+
+- **Tests:** SubNets (`graph-qcrbz6t`) synthesis PRE alias pass-through; ai-tasks `SKILL_MODEL_RESOLUTION_FAILED` / `XYNTHESIS_*` error surfacing on `node:fail` and Activix `failRecord`.
+
+## 7.8.1
+
+### Changed
+
+- **Dependencies:** `@exellix/ai-tasks` ^8.7.0 (transitive floors: `@exellix/ai-skills` ≥6.3.7, `@exellix/xynthesis` ≥4.4.9, `@x12i/ai-gateway` ≥10.0.6, `@x12i/ai-profiles` ≥2.1.1).
+- **Synthesize finalizer:** outbound `runTask` includes `executionStrategies: []`.
+- **Step retry:** token-limit retries no longer mutate `llmCall` completion budget fields (Optimixer-owned).
+- **`buildMainLlmCallForRunTask`:** strips `maxTokens`, `maxTokensCap`, and legacy token keys from forwarded `llmCall`.
+- **`buildAiTasksRunTaskRequest`:** rejects provider API key passthrough on `taskConfiguration` (env-only).
+- **Default graph profile triplet:** `cheap/default`, `pro/default`, `cheap/default`.
+- **testkit:** removed `xynthesisModel` debug fallback in `RealTasksClient`.
+
 ## 7.7.9
 
 ### Changed
 
 - **Documentation:** Align README, [`.docs/exellix-graph-engine-format.md`](.docs/exellix-graph-engine-format.md), format docs, and [`.docs/ai-tasks-model-profile-aliases-7x.md`](.docs/ai-tasks-model-profile-aliases-7x.md) with ai-tasks **8.6.8** / funcx **4.4.4**: three-slot `modelConfig`, graph-only selection (7.7+), partial task overrides (7.7.8+), studio preflight via `@exellix/graph-composer`, funcx-for-runx vs xynthesis-for-execution-strategies.
+- **Cross-package boundary:** [`.docs/graph-engine-ai-tasks-boundary.md`](.docs/graph-engine-ai-tasks-boundary.md) — normative graph-engine ↔ ai-tasks contract; [upstream-doc-patches/@exellix/ai-tasks/](upstream-doc-patches/@exellix/ai-tasks/README.md) — copy-ready ai-tasks doc fixes (RUNTASK_REQUEST, flow-io xynthesis-pre/post, workplan status).
 
 ### Dependencies
 

package/README.md

@@ -32,7 +32,7 @@ A minimal, focused SDK for executing graphs in the exellix ecosystem.
 | Layer 01 / 08 graph entry & response contracts | [`.docs/graph-io-visibility.md`](.docs/graph-io-visibility.md) |
 | Graph entry `dataFilters` v1 / public evaluator | [`.docs/data-filters-evaluation.md`](.docs/data-filters-evaluation.md) |
 | Task-node `conditions` + conditional `modelConfig.cases` (runx) | [`.docs/task-node-conditions-evaluation.md`](.docs/task-node-conditions-evaluation.md) |
-| **Model profile aliases** (7.x+: graph = aliases / `profile/choice`; ai-tasks resolves per phase) | [`BREAKING-CHANGES.md`](BREAKING-CHANGES.md) §7.6 / §7.7, [`.docs/ai-tasks-model-profile-aliases-7x.md`](.docs/ai-tasks-model-profile-aliases-7x.md) |
+| **Model profile aliases** (7.x+: graph = aliases / `profile/choice`; ai-tasks resolves per phase) | [`BREAKING-CHANGES.md`](BREAKING-CHANGES.md) §7.6 / §7.7, [`.docs/ai-tasks-model-profile-aliases-7x.md`](.docs/ai-tasks-model-profile-aliases-7x.md), [`.docs/graph-engine-ai-tasks-boundary.md`](.docs/graph-engine-ai-tasks-boundary.md) |
 | Platform vs implementation (no domain operators in schema) | [`.docs/platform-generic-vs-implementation.md`](.docs/platform-generic-vs-implementation.md) |
 | Activix records, `runContext`, collection tracking (`@x12i/activix` 8.4+) | [`.docs/activix-records.md`](.docs/activix-records.md) |
 | Bundled graph examples & bundle README | [`graphs/README.md`](graphs/README.md) |

package/dist/src/integrations/ActivixNodeActivityIntegration.js

@@ -149,11 +149,18 @@ export function createActivixNodeActivityIntegration(ax, options) {
                             : typeof err === 'object' && err && 'message' in err
                                 ? String(err.message)
                                 : String(err ?? 'unknown error');
+                        const errorCode = (() => {
+                            if (err == null || typeof err !== 'object')
+                                return undefined;
+                            const code = err.code;
+                            return code != null ? String(code) : undefined;
+                        })();
                         const outerResponse = nodeEvent.data?.response;
                         const outerMemoryEnd = nodeEvent.data?.memoryAfter;
                         const recordId = await recordPromise;
                         await ax.failRecord(recordId, message, {
                             failedAt: nodeEvent.timestamp,
+                            ...(errorCode != null ? { errorCode } : {}),
                             outer: {
                                 output: {
                                     response: outerResponse,

package/dist/src/runtime/ExellixGraphRuntime.js

@@ -422,6 +422,7 @@ export function createExellixGraphRuntime(opts) {
                             },
                             modelConfig: wireModelConfig,
                             llmCall: effectiveLlmCall,
+                            executionStrategies: [],
                             ...(forwardRunTaskTrace ? { executionMode: "trace" } : {}),
                             ...((input.runTaskDiagnostics ?? opts.runTaskDiagnostics) != null
                                 ? { diagnostics: input.runTaskDiagnostics ?? opts.runTaskDiagnostics }
@@ -962,8 +963,10 @@ export function createExellixGraphRuntime(opts) {
             const resMeta = res.metadata ?? res.meta;
             const taskRunLog = [...retryOutcome.syntheticRunLog, ...extractTaskRunLogFromMetadata(resMeta)];
             const logxerCorrelationId = extractLogxerCorrelationFromMetadata(resMeta);
-            const err = new Error(`TASK_RUN_FAILED: ${skillKey}`);
-            err.code = res.error?.code ?? "TASK_RUN_FAILED";
+            const taskErrorMessage = res.error?.message ?? "Task run failed";
+            const taskErrorCode = res.error?.code ?? "TASK_RUN_FAILED";
+            const err = new Error(taskErrorMessage);
+            err.code = taskErrorCode;
             err.skillKey = skillKey;
             err.diagnostics = res.diagnostics;
             err.nodeId = input.node?.id;

package/dist/src/runtime/buildAiTasksRunTaskRequest.d.ts

@@ -13,6 +13,8 @@ import type { Job } from '../types/refs.js';
 import type { RunTaskModelConfigWire } from './graphAiModelConfig.js';
 import type { ExecutionStepOption } from '../types/options.js';
 import type { ResolvedNarrixWirePayload } from '../types/narrix.js';
+/** Request/metadata keys that must never carry provider API secrets (env-only). */
+export declare const FORBIDDEN_RUN_TASK_SECRET_KEYS: readonly ["openrouterApiKey", "OPENROUTER_API_KEY", "OPEN_ROUTER_KEY", "apiKey", "api_key", "openRouterApiKey"];
 /** Reads task-node `taskConfiguration` keys forwarded to `@exellix/ai-tasks` `RunTaskRequest` (runtime strategy / Narrix wiring). */
 export declare function extractRunTaskStrategyOverrides(taskConfiguration: Record<string, unknown> | undefined | null): Partial<Pick<BuildAiTasksRunTaskRequestArgs, 'narrixMode' | 'inputStrategyKey' | 'narrixInput'>>;
 /** Optional `RunTaskRequest` fields commonly authored on task-node `taskConfiguration` (whitelist — closed merge order). */

package/dist/src/runtime/buildAiTasksRunTaskRequest.js

@@ -1,7 +1,27 @@
 import { buildRunTaskTaskConfigurationForward } from './buildRunTaskTaskConfigurationForward.js';
 import { normalizeSmartInputConfigForRunTask } from './smartInputPaths.js';
+/** Request/metadata keys that must never carry provider API secrets (env-only). */
+export const FORBIDDEN_RUN_TASK_SECRET_KEYS = [
+    'openrouterApiKey',
+    'OPENROUTER_API_KEY',
+    'OPEN_ROUTER_KEY',
+    'apiKey',
+    'api_key',
+    'openRouterApiKey',
+];
+function assertNoSecretPassthrough(taskConfiguration, context) {
+    if (taskConfiguration == null || typeof taskConfiguration !== 'object' || Array.isArray(taskConfiguration)) {
+        return;
+    }
+    for (const key of FORBIDDEN_RUN_TASK_SECRET_KEYS) {
+        if (key in taskConfiguration && taskConfiguration[key] !== undefined) {
+            throw new Error(`${context}: taskConfiguration.${key} is forbidden — provider API keys belong in process environment only (e.g. OPENROUTER_API_KEY).`);
+        }
+    }
+}
 /** Reads task-node `taskConfiguration` keys forwarded to `@exellix/ai-tasks` `RunTaskRequest` (runtime strategy / Narrix wiring). */
 export function extractRunTaskStrategyOverrides(taskConfiguration) {
+    assertNoSecretPassthrough(taskConfiguration, 'extractRunTaskStrategyOverrides');
     if (taskConfiguration == null || typeof taskConfiguration !== 'object' || Array.isArray(taskConfiguration))
         return {};
     const m = taskConfiguration;
@@ -25,6 +45,7 @@ export function extractRunTaskStrategyOverrides(taskConfiguration) {
  * (`RunSkillRequest` / `RunTaskRequest` extras not covered by {@link extractRunTaskStrategyOverrides}).
  */
 export function extractRunTaskMetadataPassthrough(taskConfiguration) {
+    assertNoSecretPassthrough(taskConfiguration, 'extractRunTaskMetadataPassthrough');
     if (taskConfiguration == null || typeof taskConfiguration !== 'object' || Array.isArray(taskConfiguration))
         return {};
     const m = taskConfiguration;

package/dist/src/runtime/graphAiModelConfig.js

@@ -3,9 +3,9 @@ import { ExellixGraphErrorCode } from '../errors/exellixGraphErrorCodes.js';
 import { isGraphAiModelConfig } from './modelConfigSelection.js';
 /** Profile alias names used when no modelConfig tier resolves. */
 export const DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG = {
-    preActionModel: 'cheap',
-    skillModel: 'balanced',
-    postActionModel: 'cheap',
+    preActionModel: 'cheap/default',
+    skillModel: 'pro/default',
+    postActionModel: 'cheap/default',
 };
 /**
  * Illustrative concrete ids for {@link DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG}.

package/dist/src/runtime/runTaskAugments.d.ts

@@ -3,6 +3,9 @@
  */
 import type { LlmCallConfig } from '@exellix/ai-tasks';
 import type { RunTaskModelConfigWire } from './graphAiModelConfig.js';
+/** Completion budget fields removed from outbound runTask wires (ai-tasks 8.6+ / Optimixer-owned). */
+export declare const STRIPPED_LLM_CALL_TOKEN_KEYS: readonly ["maxTokens", "maxTokensCap", "max_tokens", "max_completion_tokens", "max_output_tokens"];
+export declare function stripLlmCallTokenCapFields(llmCall: Record<string, unknown> | undefined | null): Record<string, unknown> | undefined;
 export declare function mergeDefinedLlmCallParts(...parts: Array<Record<string, unknown> | undefined | null>): Record<string, unknown> | undefined;
 /**
  * MAIN-only `llmCall` for ai-tasks 8.4+: `model` is always {@link RunTaskModelConfigWire.skillModel};

package/dist/src/runtime/runTaskAugments.js

@@ -1,3 +1,20 @@
+/** Completion budget fields removed from outbound runTask wires (ai-tasks 8.6+ / Optimixer-owned). */
+export const STRIPPED_LLM_CALL_TOKEN_KEYS = [
+    'maxTokens',
+    'maxTokensCap',
+    'max_tokens',
+    'max_completion_tokens',
+    'max_output_tokens',
+];
+export function stripLlmCallTokenCapFields(llmCall) {
+    if (!llmCall || typeof llmCall !== 'object' || Array.isArray(llmCall))
+        return undefined;
+    const out = { ...llmCall };
+    for (const key of STRIPPED_LLM_CALL_TOKEN_KEYS) {
+        delete out[key];
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
 export function mergeDefinedLlmCallParts(...parts) {
     const out = {};
     for (const p of parts) {
@@ -8,6 +25,9 @@ export function mergeDefinedLlmCallParts(...parts) {
                 out[k] = v;
         }
     }
+    for (const key of STRIPPED_LLM_CALL_TOKEN_KEYS) {
+        delete out[key];
+    }
     return Object.keys(out).length > 0 ? out : undefined;
 }
 /**

package/dist/src/runtime/stepRetry.d.ts

@@ -2,13 +2,8 @@ import type { RunLogEntry } from '../types/runLog.js';
 import type { RunTaskRequest, RunTaskResponse, StepRetryPolicy } from '../types/options.js';
 import type { TaskNode } from '../types/refs.js';
 import type { StepAttemptRecord } from '../types/results.js';
-export type ResolvedStepRetryPolicy = Required<Pick<StepRetryPolicy, 'maxAttempts' | 'retryOnTimeout' | 'retryOnTokenLimit' | 'tokenBumpMultiplier' | 'tokenBumpCap' | 'baseMaxTokensFallback'>>;
+export type ResolvedStepRetryPolicy = Required<Pick<StepRetryPolicy, 'maxAttempts' | 'retryOnTimeout' | 'retryOnTokenLimit'>>;
 export declare function resolveStepRetryPolicy(graphPolicy: StepRetryPolicy | undefined, node: Pick<TaskNode, 'taskConfiguration'> | undefined): ResolvedStepRetryPolicy;
-/**
- * Reads the effective completion cap from outbound `llmCall`.
- * ai-tasks v8 canonical field is `maxTokensCap`; legacy `maxTokens` / `max_tokens` still honored.
- */
-export declare function readMaxTokensFromRunTaskRequest(req: RunTaskRequest): number | undefined;
 export type RunTaskWithRetryResult = {
     response: RunTaskResponse;
     attempts: StepAttemptRecord[];

package/dist/src/runtime/stepRetry.js

@@ -4,9 +4,6 @@ const DEFAULT_POLICY = {
     maxAttempts: 3,
     retryOnTimeout: true,
     retryOnTokenLimit: true,
-    tokenBumpMultiplier: 2,
-    tokenBumpCap: 16_000,
-    baseMaxTokensFallback: 2000,
 };
 export function resolveStepRetryPolicy(graphPolicy, node) {
     const nodeRaw = node?.taskConfiguration?.stepRetryPolicy;
@@ -17,24 +14,8 @@ export function resolveStepRetryPolicy(graphPolicy, node) {
         maxAttempts,
         retryOnTimeout: merged.retryOnTimeout !== false,
         retryOnTokenLimit: merged.retryOnTokenLimit !== false,
-        tokenBumpMultiplier: Math.max(1, merged.tokenBumpMultiplier ?? DEFAULT_POLICY.tokenBumpMultiplier),
-        tokenBumpCap: Math.max(1, merged.tokenBumpCap ?? DEFAULT_POLICY.tokenBumpCap),
-        baseMaxTokensFallback: Math.max(1, merged.baseMaxTokensFallback ?? DEFAULT_POLICY.baseMaxTokensFallback),
     };
 }
-function readNum(v) {
-    return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
-}
-/**
- * Reads the effective completion cap from outbound `llmCall`.
- * ai-tasks v8 canonical field is `maxTokensCap`; legacy `maxTokens` / `max_tokens` still honored.
- */
-export function readMaxTokensFromRunTaskRequest(req) {
-    const llm = req.llmCall;
-    return (readNum(llm?.maxTokensCap) ??
-        readNum(llm?.maxTokens) ??
-        readNum(llm?.max_tokens));
-}
 function shallowCloneRunTaskRequest(req) {
     return {
         ...req,
@@ -49,16 +30,6 @@ function shallowCloneRunTaskRequest(req) {
             : {}),
     };
 }
-function applyTokenBump(workingReq, policy) {
-    const current = readMaxTokensFromRunTaskRequest(workingReq) ?? policy.baseMaxTokensFallback;
-    const after = Math.min(policy.tokenBumpCap, Math.floor(current * policy.tokenBumpMultiplier));
-    const bumped = workingReq.llmCall != null && typeof workingReq.llmCall === 'object' && !Array.isArray(workingReq.llmCall)
-        ? { ...workingReq.llmCall }
-        : {};
-    bumped.maxTokensCap = after;
-    workingReq.llmCall = bumped;
-    return { before: current, after };
-}
 function classifyThrownError(err) {
     if (err == null || typeof err !== 'object')
         return 'other';
@@ -140,7 +111,6 @@ export async function runRunTaskWithRetry(args) {
         }
         const endedAt = Date.now();
         const durationMs = endedAt - startedAt;
-        const maxTok = readMaxTokensFromRunTaskRequest(workingReq);
         if (thrown != null) {
             const c = classifyThrownError(thrown);
             attempts.push({
@@ -152,7 +122,6 @@ export async function runRunTaskWithRetry(args) {
                 classification: c,
                 errorCode: thrown?.code,
                 errorMessage: thrown?.message,
-                maxTokensRequested: maxTok,
             });
             pushSyntheticRunLog(syntheticRunLog, {
                 nodeId,
@@ -162,7 +131,6 @@ export async function runRunTaskWithRetry(args) {
                 data: {
                     classification: c,
                     errorCode: thrown?.code,
-                    maxTokensRequested: maxTok,
                 },
             });
             if (!shouldRetryClassification(c, policy, attemptIndex)) {
@@ -172,13 +140,12 @@ export async function runRunTaskWithRetry(args) {
                 throw err;
             }
             if (c === 'token-limit' && policy.retryOnTokenLimit) {
-                const { before, after } = applyTokenBump(workingReq, policy);
                 pushSyntheticRunLog(syntheticRunLog, {
                     nodeId,
                     skillKey,
                     level: 'info',
-                    message: `step retry ${attemptIndex + 2}/${policy.maxAttempts}: token-limit bump maxTokensCap ${before} -> ${after}`,
-                    data: { classification: c, maxTokensBefore: before, maxTokensAfter: after, attempt: attemptIndex + 1 },
+                    message: `step retry ${attemptIndex + 2}/${policy.maxAttempts}: token-limit (completion budget is Optimixer-owned; request unchanged)`,
+                    data: { classification: c, attempt: attemptIndex + 1 },
                 });
             }
             continue;
@@ -196,7 +163,6 @@ export async function runRunTaskWithRetry(args) {
                 startedAt,
                 endedAt,
                 durationMs,
-                maxTokensRequested: maxTok,
             });
             return { response, attempts, syntheticRunLog, lastRequest: workingReq };
         }
@@ -210,7 +176,6 @@ export async function runRunTaskWithRetry(args) {
             classification: c,
             errorCode: response.error?.code,
             errorMessage: response.error?.message,
-            maxTokensRequested: maxTok,
         });
         pushSyntheticRunLog(syntheticRunLog, {
             nodeId,
@@ -220,20 +185,18 @@ export async function runRunTaskWithRetry(args) {
             data: {
                 classification: c,
                 errorCode: response.error?.code,
-                maxTokensRequested: maxTok,
             },
         });
         if (!shouldRetryClassification(c, policy, attemptIndex)) {
             return { response, attempts, syntheticRunLog, lastRequest: workingReq };
         }
         if (c === 'token-limit' && policy.retryOnTokenLimit) {
-            const { before, after } = applyTokenBump(workingReq, policy);
             pushSyntheticRunLog(syntheticRunLog, {
                 nodeId,
                 skillKey,
                 level: 'info',
-                message: `step retry ${attemptIndex + 2}/${policy.maxAttempts}: token-limit bump maxTokensCap ${before} -> ${after}`,
-                data: { classification: c, maxTokensBefore: before, maxTokensAfter: after, attempt: attemptIndex + 1 },
+                message: `step retry ${attemptIndex + 2}/${policy.maxAttempts}: token-limit (completion budget is Optimixer-owned; request unchanged)`,
+                data: { classification: c, attempt: attemptIndex + 1 },
             });
         }
     }

package/dist/src/types/options.d.ts

@@ -31,17 +31,8 @@ export interface StepRetryPolicy {
     maxAttempts?: number;
     /** When false, timeouts do not trigger an automatic retry. Default **true**. */
     retryOnTimeout?: boolean;
-    /** When false, token-limit signals do not trigger retry / bump. Default **true**. */
+    /** When false, token-limit signals do not trigger retry. Default **true**. Completion budget is Optimixer-owned — retries re-run unchanged. */
     retryOnTokenLimit?: boolean;
-    /** Applied to effective max tokens before each token-limit retry (default **2**). */
-    tokenBumpMultiplier?: number;
-    /** Upper bound for `maxTokens` after bump (default **16000**). */
-    tokenBumpCap?: number;
-    /**
-     * Used when `llmCall.maxTokensCap` (or legacy `maxTokens` / `max_tokens`) is unset on the outbound request
-     * before the first token-limit retry bump (default **2000**).
-     */
-    baseMaxTokensFallback?: number;
 }
 /** MAIN gate before `runTask`: empty execution input / synthesis context (graphs-studio G1, G4). */
 export type MainReadinessPolicy = 'fail' | 'warn' | 'off';

package/dist/testkit/RealTasksClient.js

@@ -83,16 +83,11 @@ export class RealTasksClient {
                 const mc = aiTasksRequest.modelConfig;
                 const effective = mc
                     ? {
-                        preActionModel: mc.preActionModel ?? mc.xynthesisModel,
+                        preActionModel: mc.preActionModel,
                         skillModel: mc.skillModel,
-                        postActionModel: mc.postActionModel ?? mc.skillModel,
+                        postActionModel: mc.postActionModel,
                     }
-                    : aiTasksRequest.config
-                        ? {
-                            provider: aiTasksRequest.config.provider,
-                            model: aiTasksRequest.config.model,
-                        }
-                        : { provider: '(none)', model: '(none)' };
+                    : { preActionModel: '(none)', skillModel: '(none)', postActionModel: '(none)' };
                 console.log('[AI_PROVIDER] RealTasksClient → ai-tasks:', effective);
             }
             const sdk = await getPackagedClientPromise();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exellix/graph-engine",
-  "version": "7.8.0",
+  "version": "7.8.2",
   "type": "module",
   "description": "Graph executor SDK",
   "main": "dist/src/index.js",
@@ -25,7 +25,7 @@
   "scripts": {
     "prebuild": "node scripts/clean-dist.mjs",
     "build": "tsc",
-    "test": "npm run build && npm run check:no-legacy && tsx --test --test-force-exit tests/model-alias-contract.test.ts tests/reports-fixtures-pre-synthesis.test.ts tests/passthrough-parity.test.ts tests/step-retry-llm-call.test.ts tests/run-log-diagnostics.test.ts",
+    "test": "npm run build && npm run check:no-legacy && tsx --test --test-force-exit tests/model-alias-contract.test.ts tests/ai-tasks-error-propagation.test.ts tests/reports-fixtures-pre-synthesis.test.ts tests/passthrough-parity.test.ts tests/step-retry-llm-call.test.ts tests/run-log-diagnostics.test.ts",
     "test:full": "npm run build && npm run check:no-legacy && tsx --test --test-force-exit tests/graph-engine.test.ts tests/passthrough-parity.test.ts tests/task-node-run-task-preflight.test.ts tests/reports-fixtures-pre-synthesis.test.ts tests/model-alias-contract.test.ts tests/step-retry-llm-call.test.ts",
     "test:live": "npm run run:pre-synthesis",
     "test:subnets-graph-fixture": "npm run build && node --test tests/subnets-graph.fixture.test.mjs",
@@ -52,7 +52,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@exellix/ai-tasks": "^8.6.8",
+    "@exellix/ai-tasks": "^8.8.0",
     "@x12i/activix": "8.5.0",
     "@x12i/catalox": "5.1.3",
     "@x12i/env": "4.0.1",