@relayflows/sdk 2.0.1 → 2.0.2

package/src/validate.ts

@@ -203,28 +203,69 @@ class Validator {
     }
   }
 
-  private validateBudget(b: unknown): void {
+  private validateBudget(b: unknown, at = 'spec.budget'): void {
     if (!isObject(b)) {
-      this.fail('spec.budget: expected an object');
+      this.fail(`${at}: expected an object`);
       return;
     }
-    this.checkKeys(b, BUDGET_KEYS, 'spec.budget');
+    this.checkKeys(b, BUDGET_KEYS, at);
     const budget = b as BudgetSpec;
     if (
       budget.maxTokensIn !== undefined &&
       !isNonNegInt(budget.maxTokensIn)
     ) {
-      this.fail('spec.budget.maxTokensIn: expected a non-negative integer');
+      this.fail(`${at}.maxTokensIn: expected a non-negative integer`);
     }
     if (
       budget.maxTokensOut !== undefined &&
       !isNonNegInt(budget.maxTokensOut)
     ) {
-      this.fail('spec.budget.maxTokensOut: expected a non-negative integer');
+      this.fail(`${at}.maxTokensOut: expected a non-negative integer`);
     }
     if (budget.maxDollars !== undefined) {
       if (typeof budget.maxDollars !== 'string' || !DECIMAL_RE.test(budget.maxDollars)) {
-        this.fail('spec.budget.maxDollars: expected a decimal string, e.g. "1.50"');
+        this.fail(`${at}.maxDollars: expected a decimal string, e.g. "1.50"`);
+      }
+    }
+  }
+
+  private validateRequirements(value: unknown, at: string): void {
+    if (!isObject(value)) { this.fail(`${at}: expected an object`); return; }
+    this.checkKeys(value, ['execution', 'workspace', 'network', 'expectedDurationMs', 'preference'], at);
+    for (const field of ['workspace', 'network']) {
+      if (value[field] !== undefined && typeof value[field] !== 'boolean') this.fail(`${at}.${field}: expected a boolean`);
+    }
+    if (value['execution'] !== undefined && !['batch', 'interactive'].includes(value['execution'] as string)) {
+      this.fail(`${at}.execution: expected batch | interactive`);
+    }
+    if (value['preference'] !== undefined && !['cost', 'latency', 'reliability', 'balanced'].includes(value['preference'] as string)) {
+      this.fail(`${at}.preference: expected cost | latency | reliability | balanced`);
+    }
+    if (value['expectedDurationMs'] !== undefined &&
+        (!Number.isSafeInteger(value['expectedDurationMs']) || (value['expectedDurationMs'] as number) <= 0)) {
+      this.fail(`${at}.expectedDurationMs: expected a positive safe integer`);
+    }
+  }
+
+  private validateMemory(value: unknown, at: string): void {
+    if (!isObject(value)) {
+      this.fail(`${at}: expected an object`);
+      return;
+    }
+    this.checkKeys(value, ['scope', 'query', 'budget'], at);
+    if (value['scope'] !== 'script' && value['scope'] !== 'agent') {
+      this.fail(`${at}.scope: expected script | agent`);
+    }
+    if (typeof value['query'] !== 'string' || value['query'].trim().length === 0) {
+      this.fail(`${at}.query: expected a non-empty string`);
+    }
+    this.validateBudget(value['budget'], `${at}.budget`);
+    if (isObject(value['budget'])) {
+      for (const key of ['maxTokensIn', 'maxTokensOut']) {
+        const limit = value['budget'][key];
+        if (limit !== undefined && !Number.isSafeInteger(limit)) {
+          this.fail(`${at}.budget.${key}: expected a safe integer`);
+        }
       }
     }
   }
@@ -305,6 +346,9 @@ class Validator {
     const type = st['type'] as StepType;
     this.checkKeys(st, [...STEP_COMMON_FIELDS, ...STEP_FIELDS_BY_TYPE[type]], at);
 
+    if (st['requirements'] !== undefined) this.validateRequirements(st['requirements'], `${at}.requirements`);
+    if (st['memory'] !== undefined) this.validateMemory(st['memory'], `${at}.memory`);
+
     if (st['dependsOn'] !== undefined) {
       if (!Array.isArray(st['dependsOn']) || !(st['dependsOn'] as unknown[]).every(isNonEmptyString)) {
         this.fail(`${at}.dependsOn: expected an array of step ids`);

package/src/worker.ts

@@ -91,7 +91,7 @@ export class AgentWorker extends EventEmitter {
   private async execute(dispatch: StepDispatchEvent): Promise<void> {
     const spec = dispatch.spec as Partial<KernelAgentStep>;
     const result = typeof spec.cli === 'string' && typeof spec.instruction === 'string'
-      ? await runAgentCli(spec.cli, spec.instruction, dispatch.wake_context, spec.model)
+      ? await runAgentCli(spec.cli, memoryInstruction(spec.instruction, dispatch.memory), dispatch.wake_context, spec.model)
       : { exit_code: null, stdout_tail: '', stderr_tail: 'agent step has no declared CLI' };
     const completionReason = result.exit_code === 0 ? 'success' : 'worker_error';
 
@@ -148,3 +148,9 @@ export function parseJsonOutput(stdout: string): Record<string, unknown> | null
   }
   return parsed as Record<string, unknown>;
 }
+
+/** Pass the journaled pack to both raw CLI and wrapper execution paths. */
+function memoryInstruction(instruction: string, memory: StepDispatchEvent['memory']): string {
+  return memory === undefined ? instruction
+    : `${instruction}\n\nMemory context (journaled):\n${JSON.stringify(memory.pack)}`;
+}