@smithers-orchestrator/graph 0.24.0 → 0.24.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/graph",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "description": "Framework-neutral Smithers workflow graph model and extraction helpers",
   "type": "module",
   "sideEffects": false,
@@ -22,7 +22,7 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/errors": "0.24.0"
+    "@smithers-orchestrator/errors": "0.24.2"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/TaskAspects.ts

@@ -0,0 +1 @@
+export type { TaskAspects } from "./types";

package/src/extract.js

@@ -248,6 +248,49 @@ function approvalAutoApprove(value) {
             : {}),
     };
 }
+/**
+ * Normalize the `__aspects` element prop attached by `<Task>` into the
+ * `TaskAspects` budget metadata the engine enforces. Only the budget configs
+ * are kept; the render-time accumulator and tracking flags are dropped (the
+ * engine keeps its own durable per-run accumulator and budgets enforce
+ * regardless of tracking).
+ *
+ * @param {unknown} value
+ * @returns {import("./types").TaskAspects | undefined}
+ */
+function aspects(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const raw = /** @type {Record<string, unknown>} */ (value);
+    /** @type {import("./types").TaskAspects} */
+    const out = {};
+    const token = raw.tokenBudget;
+    if (token && typeof token === "object" && !Array.isArray(token) &&
+        typeof (/** @type {Record<string, unknown>} */ (token).max) === "number") {
+        const t = /** @type {Record<string, unknown>} */ (token);
+        out.tokenBudget = {
+            max: /** @type {number} */ (t.max),
+            ...(typeof t.perTask === "number" ? { perTask: t.perTask } : {}),
+            ...(t.onExceeded === "warn" || t.onExceeded === "skip-remaining" || t.onExceeded === "fail"
+                ? { onExceeded: /** @type {"fail" | "warn" | "skip-remaining"} */ (t.onExceeded) }
+                : {}),
+        };
+    }
+    const latency = raw.latencySlo;
+    if (latency && typeof latency === "object" && !Array.isArray(latency) &&
+        typeof (/** @type {Record<string, unknown>} */ (latency).maxMs) === "number") {
+        const l = /** @type {Record<string, unknown>} */ (latency);
+        out.latencySlo = {
+            maxMs: /** @type {number} */ (l.maxMs),
+            ...(typeof l.perTask === "number" ? { perTask: l.perTask } : {}),
+            ...(l.onExceeded === "warn" || l.onExceeded === "fail"
+                ? { onExceeded: /** @type {"fail" | "warn"} */ (l.onExceeded) }
+                : {}),
+        };
+    }
+    return out.tokenBudget || out.latencySlo ? out : undefined;
+}
 /**
  * @param {"parallel" | "merge-queue"} tag
  * @param {Record<string, unknown>} raw
@@ -628,6 +671,7 @@ export function extractGraph(root, opts) {
                 memoryConfig: raw.memory && typeof raw.memory === "object" && !Array.isArray(raw.memory)
                     ? raw.memory
                     : undefined,
+                aspects: aspects(raw.__aspects),
             });
         }
         let elementIndex = 0;

package/src/index.d.ts

@@ -109,6 +109,18 @@ type ApprovalOption$1 = {
     summary?: string;
     metadata?: Record<string, unknown>;
 };
+type TaskAspects$1 = {
+    tokenBudget?: {
+        max: number;
+        perTask?: number;
+        onExceeded?: "fail" | "warn" | "skip-remaining";
+    };
+    latencySlo?: {
+        maxMs: number;
+        perTask?: number;
+        onExceeded?: "fail" | "warn";
+    };
+};
 type TaskDescriptor$1 = {
     nodeId: string;
     ordinal: number;
@@ -156,6 +168,7 @@ type TaskDescriptor$1 = {
     meta?: Record<string, unknown>;
     scorers?: ScorersMap$1;
     memoryConfig?: TaskMemoryConfig$1;
+    aspects?: TaskAspects$1;
 };
 type WorkflowGraph$2 = {
     readonly xml: XmlNode$1 | null;
@@ -222,6 +235,7 @@ type ScorerBinding = ScorerBinding$1;
 type ScorerFn = ScorerFn$1;
 type ScorerInput = ScorerInput$1;
 type ScorersMap = ScorersMap$1;
+type TaskAspects = TaskAspects$1;
 type TaskDescriptor = TaskDescriptor$1;
 type TaskMemoryConfig = TaskMemoryConfig$1;
 type WorkflowGraph = WorkflowGraph$2;
@@ -229,4 +243,4 @@ type XmlElement = XmlElement$1;
 type XmlNode = XmlNode$1;
 type XmlText = XmlText$1;
 
-export { type AgentLike, type ApprovalOption, type CachePolicy, type ExtractGraph, type ExtractOptions, type GraphSnapshot, type HostElement, type HostNode, type HostText, type MemoryNamespace, type MemoryNamespaceKind, type RetryPolicy, type SamplingConfig, type ScoreResult, type Scorer, type ScorerBinding, type ScorerFn, type ScorerInput, type ScorersMap, type TaskDescriptor, type TaskMemoryConfig, type WorkflowGraph, type XmlElement, type XmlNode, type XmlText, extractFromHost, extractGraph, resolveWorktreePath };
+export { type AgentLike, type ApprovalOption, type CachePolicy, type ExtractGraph, type ExtractOptions, type GraphSnapshot, type HostElement, type HostNode, type HostText, type MemoryNamespace, type MemoryNamespaceKind, type RetryPolicy, type SamplingConfig, type ScoreResult, type Scorer, type ScorerBinding, type ScorerFn, type ScorerInput, type ScorersMap, type TaskAspects, type TaskDescriptor, type TaskMemoryConfig, type WorkflowGraph, type XmlElement, type XmlNode, type XmlText, extractFromHost, extractGraph, resolveWorktreePath };

package/src/types.ts

@@ -123,6 +123,26 @@ export type ApprovalOption = {
   metadata?: Record<string, unknown>;
 };
 
+/**
+ * Resolved `<Aspects>` budget configuration that applies to a task, extracted
+ * from the `__aspects` element prop. The engine reads this at task-dispatch
+ * time to enforce per-run token and latency budgets. The render-time
+ * accumulator carried alongside the budgets in the component tree is dropped
+ * here; the engine keeps its own durable accumulator.
+ */
+export type TaskAspects = {
+  tokenBudget?: {
+    max: number;
+    perTask?: number;
+    onExceeded?: "fail" | "warn" | "skip-remaining";
+  };
+  latencySlo?: {
+    maxMs: number;
+    perTask?: number;
+    onExceeded?: "fail" | "warn";
+  };
+};
+
 export type TaskDescriptor = {
   nodeId: string;
   ordinal: number;
@@ -173,6 +193,8 @@ export type TaskDescriptor = {
   scorers?: ScorersMap;
 
   memoryConfig?: TaskMemoryConfig;
+  /** Resolved `<Aspects>` budget configuration enforced by the engine at dispatch. */
+  aspects?: TaskAspects;
 };
 
 export type WorkflowGraph = {