@noetic-tools/core 3.2.0 → 5.0.0

package/dist/schemas/workflow.js

@@ -1,378 +1,6 @@
 /**
- * Zod schemas for JSON-serialisable workflow definitions.
- *
- * A `WorkflowDocument` is a portable, JSON-safe representation of a noetic
- * step tree. It covers every step kind. The `run` node carries its body as a
- * code STRING (not an in-process closure) dispatched through a subprocess
- * adapter, keeping the document JSON-safe. The hydrator in
- * `builders/workflow-hydrator.ts` converts a validated document back into live
- * `Step` objects via the existing builders.
+ * The JSON workflow schema lives in `@noetic-tools/types` so the memory
+ * package (which must not import core) can validate workflow documents.
+ * This barrel keeps core's public and intra-core import paths unchanged.
  */
-import { z } from 'zod';
-//#endregion
-//#region Until Predicate Schemas
-const MaxStepsPredicateSchema = z.object({
-    kind: z.literal('maxSteps'),
-    n: z.number().int().positive(),
-});
-const MaxCostPredicateSchema = z.object({
-    kind: z.literal('maxCost'),
-    usd: z.number().positive(),
-});
-const MaxDurationPredicateSchema = z.object({
-    kind: z.literal('maxDuration'),
-    ms: z.number().positive(),
-});
-const NoToolCallsPredicateSchema = z.object({
-    kind: z.literal('noToolCalls'),
-});
-const OutputContainsPredicateSchema = z.object({
-    kind: z.literal('outputContains'),
-    marker: z.string().min(1),
-});
-const OutputEqualsPredicateSchema = z.object({
-    kind: z.literal('outputEquals'),
-    sentinel: z.string().min(1),
-});
-const ConvergedPredicateSchema = z.object({
-    kind: z.literal('converged'),
-    threshold: z.number().min(0).max(1).optional(),
-});
-const UntilPredicateRef = z.lazy(() => UntilPredicateSchema);
-const AnyPredicateSchema = z.object({
-    kind: z.literal('any'),
-    predicates: z.array(UntilPredicateRef).min(1),
-});
-const AllPredicateSchema = z.object({
-    kind: z.literal('all'),
-    predicates: z.array(UntilPredicateRef).min(1),
-});
-/** @public Zod schema validating a named `until` predicate (including `any`/`all` combinators). */
-export const UntilPredicateSchema = z
-    .union([
-    MaxStepsPredicateSchema,
-    MaxCostPredicateSchema,
-    MaxDurationPredicateSchema,
-    NoToolCallsPredicateSchema,
-    OutputContainsPredicateSchema,
-    OutputEqualsPredicateSchema,
-    ConvergedPredicateSchema,
-    AnyPredicateSchema,
-    AllPredicateSchema,
-])
-    .meta({
-    id: 'UntilPredicate',
-    title: 'UntilPredicate',
-});
-//#endregion
-//#region Merge Strategy
-/** @public ESM literal enum for merge strategies. */
-export const MergeStrategy = {
-    Last: 'last',
-    First: 'first',
-    Concat: 'concat',
-};
-/** @public Zod schema for the named merge strategy used by `fork` nodes. */
-export const MergeStrategySchema = z.enum([
-    'last',
-    'first',
-    'concat',
-]);
-//#endregion
-//#region Model Params
-const ModelParamsSchema = z.object({
-    temperature: z.number().min(0).optional(),
-    topP: z.number().min(0).max(1).optional(),
-    maxTokens: z.number().int().positive().optional(),
-    stopSequences: z.array(z.string()).optional(),
-});
-//#endregion
-//#region Tool Entries
-/**
- * A uniform tool entry on an `llm` node. Every entry is an object keyed by
- * `type`:
- *   - A CLIENT tool is `{ type: "<registered-tool-name>" }`. The hydrator
- *     resolves `type` against the tool registry; `parameters` (if present) is
- *     ignored — client tools receive their call args from the model at runtime.
- *   - A SERVER tool is `{ type: "openrouter:web_search" | "openrouter:web_fetch",
- *     parameters?: {...} }`. The provider executes it; `parameters` keys are
- *     camelCase (e.g. `maxResults`, `searchContextSize`) — the SDK re-serialises
- *     them and silently drops unknown keys.
- *
- * Server vs client is decided by the `type` value (a reserved `openrouter:*`
- * server-tool literal vs an arbitrary tool name), not by the entry's shape.
- */
-const LlmToolEntrySchema = z.object({
-    type: z.string().min(1),
-    parameters: z.record(z.string(), z.unknown()).optional(),
-});
-//#endregion
-//#region Retry Policy
-/** Retry policy for a `run` node, mirroring `RetryPolicy` in `@noetic-tools/types`. */
-const RetryPolicySchema = z.object({
-    maxAttempts: z.number().int().positive(),
-    backoff: z.enum([
-        'fixed',
-        'linear',
-        'exponential',
-    ]),
-    initialDelay: z.number().nonnegative(),
-    maxDelay: z.number().nonnegative().optional(),
-});
-//#endregion
-//#region SubHarness Settings
-const HarnessSettingsSchema = z.object({
-    model: z.string().optional(),
-    permissionMode: z
-        .enum([
-        'default',
-        'plan',
-        'acceptEdits',
-        'bypassPermissions',
-    ])
-        .optional(),
-    maxTurns: z.number().int().positive().optional(),
-    allowedTools: z.array(z.string()).optional(),
-    extra: z.record(z.string(), z.unknown()).optional(),
-});
-const HarnessSessionPolicySchema = z.object({
-    reuse: z.string().min(1).optional(),
-    onComplete: z
-        .enum([
-        'stop',
-        'detach',
-        'destroy',
-    ])
-        .optional(),
-});
-//#endregion
-//#region Workflow Node Schema
-const WorkflowNodeRef = z.lazy(() => WorkflowNodeSchema);
-const SHARED_FIELDS = {
-    id: z.string().min(1),
-};
-const OutputCodecRefSchema = z.object({
-    codec: z.literal('openui'),
-    library: z.string().min(1),
-});
-const LlmNodeSchema = z.object({
-    kind: z.literal('llm'),
-    ...SHARED_FIELDS,
-    model: z.string().optional(),
-    instructions: z.string(),
-    tools: z.array(LlmToolEntrySchema).optional(),
-    params: ModelParamsSchema.optional(),
-    output: OutputCodecRefSchema.optional(),
-});
-const ToolNodeSchema = z.object({
-    kind: z.literal('tool'),
-    ...SHARED_FIELDS,
-    toolName: z.string().min(1),
-    args: z.record(z.string(), z.unknown()).optional(),
-});
-const RunNodeSchema = z.object({
-    kind: z.literal('run'),
-    ...SHARED_FIELDS,
-    execute: z.string().min(1),
-    retry: RetryPolicySchema.optional(),
-    subprocess: z.string().min(1).optional(),
-});
-const BranchRouteSchema = z.object({
-    match: z.string().min(1),
-    target: z.lazy(() => WorkflowNodeSchema),
-});
-const BranchNodeSchema = z.object({
-    kind: z.literal('branch'),
-    ...SHARED_FIELDS,
-    routes: z.array(BranchRouteSchema).min(1),
-    default: WorkflowNodeRef.optional(),
-});
-const ForkNodeSchema = z
-    .object({
-    kind: z.literal('fork'),
-    ...SHARED_FIELDS,
-    mode: z.enum([
-        'race',
-        'all',
-        'settle',
-    ]),
-    paths: z.array(WorkflowNodeRef).min(1).optional(),
-    each: WorkflowNodeRef.optional(),
-    over: z.string().min(1).optional(),
-    merge: MergeStrategySchema.optional(),
-    concurrency: z.number().int().positive().optional(),
-})
-    .refine((node) => (node.paths === undefined) !== (node.each === undefined), {
-    message: "fork node requires exactly one of 'paths' (static) or 'each' (dynamic).",
-});
-const SpawnNodeSchema = z.object({
-    kind: z.literal('spawn'),
-    ...SHARED_FIELDS,
-    child: WorkflowNodeRef,
-    timeout: z.number().positive().optional(),
-    layers: z.array(z.string().min(1)).min(1).optional(),
-});
-const ProvideNodeSchema = z.object({
-    kind: z.literal('provide'),
-    ...SHARED_FIELDS,
-    child: WorkflowNodeRef,
-    layers: z.array(z.string().min(1)).min(1),
-});
-const LoopNodeSchema = z.object({
-    kind: z.literal('loop'),
-    ...SHARED_FIELDS,
-    body: WorkflowNodeRef,
-    until: UntilPredicateSchema,
-    maxIterations: z.number().int().positive().optional(),
-});
-const SequenceNodeSchema = z.object({
-    kind: z.literal('sequence'),
-    ...SHARED_FIELDS,
-    steps: z.array(WorkflowNodeRef).min(1),
-});
-const EveryNodeSchema = z.object({
-    kind: z.literal('every'),
-    ...SHARED_FIELDS,
-    step: WorkflowNodeRef,
-    ms: z.number().nonnegative(),
-    onError: z
-        .enum([
-        'continue',
-        'fail',
-    ])
-        .optional(),
-});
-/** Builds the schema for a single harness node kind (`claude-code`, `codex`, …). */
-function subHarnessNodeSchema(kind) {
-    return z.object({
-        kind: z.literal(kind),
-        ...SHARED_FIELDS,
-        prompt: z.string().min(1),
-        instructions: z.string().optional(),
-        settings: HarnessSettingsSchema.optional(),
-        session: HarnessSessionPolicySchema.optional(),
-    });
-}
-const ClaudeCodeNodeSchema = subHarnessNodeSchema('claude-code');
-const CodexNodeSchema = subHarnessNodeSchema('codex');
-const OpencodeNodeSchema = subHarnessNodeSchema('opencode');
-const PiNodeSchema = subHarnessNodeSchema('pi');
-/** @public Zod schema validating a single `WorkflowNode` (any JSON-safe kind). */
-export const WorkflowNodeSchema = z
-    .discriminatedUnion('kind', [
-    LlmNodeSchema,
-    ToolNodeSchema,
-    RunNodeSchema,
-    BranchNodeSchema,
-    ForkNodeSchema,
-    SpawnNodeSchema,
-    ProvideNodeSchema,
-    LoopNodeSchema,
-    SequenceNodeSchema,
-    EveryNodeSchema,
-    ClaudeCodeNodeSchema,
-    CodexNodeSchema,
-    OpencodeNodeSchema,
-    PiNodeSchema,
-])
-    .meta({
-    id: 'WorkflowNode',
-    title: 'WorkflowNode',
-});
-/** @public Zod schema validating a complete `WorkflowDocument`. */
-export const WorkflowDocumentSchema = z
-    .object({
-    version: z.literal(1),
-    root: WorkflowNodeSchema,
-})
-    .meta({
-    id: 'WorkflowDocument',
-    title: 'WorkflowDocument',
-    description: 'A portable, JSON-safe representation of a Noetic step tree.',
-});
-//#endregion
-//#region Helpers
-/** Returns the direct child nodes of a workflow node. Leaf nodes return an empty array. */
-function childNodes(node) {
-    switch (node.kind) {
-        case 'sequence':
-            return node.steps;
-        case 'fork':
-            if (node.each) {
-                return [
-                    node.each,
-                ];
-            }
-            return node.paths ?? [];
-        case 'spawn':
-        case 'provide':
-            return [
-                node.child,
-            ];
-        case 'loop':
-            return [
-                node.body,
-            ];
-        case 'every':
-            return [
-                node.step,
-            ];
-        case 'branch': {
-            const children = node.routes.map((r) => r.target);
-            if (node.default) {
-                children.push(node.default);
-            }
-            return children;
-        }
-        default:
-            return [];
-    }
-}
-/** Validates a candidate workflow document. Throws `ZodError` on invalid input. */
-export function validateWorkflow(input) {
-    return WorkflowDocumentSchema.parse(input);
-}
-/** Walks a workflow tree depth-first, yielding each node. */
-export function* walkWorkflow(node) {
-    yield node;
-    for (const child of childNodes(node)) {
-        yield* walkWorkflow(child);
-    }
-}
-/**
- * Flattens a workflow tree into a node + edge list — the static "potential
- * paths" of the DAG, suitable for attaching to a trace span so observers can
- * reconstruct the declared graph independent of which branches actually ran.
- */
-export function workflowGraph(root) {
-    const nodes = [];
-    const edges = [];
-    for (const node of walkWorkflow(root)) {
-        nodes.push({
-            id: node.id,
-            kind: node.kind,
-        });
-        for (const child of childNodes(node)) {
-            edges.push({
-                from: node.id,
-                to: child.id,
-            });
-        }
-    }
-    return {
-        nodes,
-        edges,
-    };
-}
-/**
- * Returns the maximum depth of a workflow tree.
- * Leaf nodes (`llm`, `tool`) have depth 0. Structural nodes add +1.
- */
-export function workflowDepth(node) {
-    const children = childNodes(node);
-    if (children.length === 0) {
-        return 0;
-    }
-    return 1 + Math.max(0, ...children.map(workflowDepth));
-}
-//#endregion
+export { MergeStrategy, MergeStrategySchema, UntilPredicateSchema, validateWorkflow, WorkflowDocumentSchema, WorkflowNodeSchema, walkWorkflow, workflowDepth, workflowGraph, } from '@noetic-tools/types';

package/dist/types/mutable-context.d.ts

@@ -1,10 +1,10 @@
-import type { ContextMemory } from '@noetic-tools/memory';
+import type { ContextData } from '@noetic-tools/context';
 import type { Context, StepMeta, TokenUsage } from '@noetic-tools/types';
 /**
  * Internal-only interface for interpreter code that needs to mutate Context fields.
  * NOT exported from the package public API.
  */
-export interface MutableContext extends Context<ContextMemory> {
+export interface MutableContext extends Context<ContextData> {
     stepCount: number;
     tokens: TokenUsage;
     cost: number;

package/dist/types/step-registrar.d.ts

@@ -21,7 +21,7 @@ import type { Step } from '@noetic-tools/types';
  * typically call the runtime's underlying `registerStep` function.
  */
 export interface StepRegistrar {
-    register<TMemory, I, O>(step: Step<TMemory, I, O>): void;
+    register<TContext, I, O>(step: Step<TContext, I, O>): void;
 }
 /**
  * @public

package/dist/unstable.d.ts

@@ -3,17 +3,17 @@
  * Unstable exports for framework extenders.
  *
  * Symbols exported from this module may change in any minor release.
- * They are intended for authors of custom memory layers, runtime backends,
+ * They are intended for authors of custom context layers, runtime backends,
  * and other framework extensions. Do not depend on them in application code.
  */
-/** @unstable Budget allocation algorithm for memory layer token budgets. */
+/** @unstable Budget allocation algorithm for context layer token budgets. */
 /** @unstable Layer state store type for managing per-layer state during execution. */
-export type { BudgetAllocation, BudgetLimits, LayerStateStore } from '@noetic-tools/memory';
+export type { BudgetAllocation, BudgetLimits, LayerStateStore } from '@noetic-tools/context';
 /** @unstable Budget allocation and checking utilities. */
 /** @unstable Factory for creating layer state stores. */
-/** @unstable View assembly algorithm that converges memory layer outputs into the LLM context. */
+/** @unstable View assembly algorithm that converges context layer outputs into the LLM context. */
 /** @unstable Factory for creating scoped storage wrappers around a StorageAdapter. */
-export { allocateBudgets, assembleView, checkBudget, createLayerStateStore, createScopedStorage, } from '@noetic-tools/memory';
+export { allocateBudgets, assembleView, checkBudget, createLayerStateStore, createScopedStorage, } from '@noetic-tools/context';
 /** @unstable Unsafe cast utility for bridging internal type boundaries. */
 export { frameworkCast } from '@noetic-tools/types';
 /**

package/dist/unstable.js

@@ -3,14 +3,14 @@
  * Unstable exports for framework extenders.
  *
  * Symbols exported from this module may change in any minor release.
- * They are intended for authors of custom memory layers, runtime backends,
+ * They are intended for authors of custom context layers, runtime backends,
  * and other framework extensions. Do not depend on them in application code.
  */
 /** @unstable Budget allocation and checking utilities. */
 /** @unstable Factory for creating layer state stores. */
-/** @unstable View assembly algorithm that converges memory layer outputs into the LLM context. */
+/** @unstable View assembly algorithm that converges context layer outputs into the LLM context. */
 /** @unstable Factory for creating scoped storage wrappers around a StorageAdapter. */
-export { allocateBudgets, assembleView, checkBudget, createLayerStateStore, createScopedStorage, } from '@noetic-tools/memory';
+export { allocateBudgets, assembleView, checkBudget, createLayerStateStore, createScopedStorage, } from '@noetic-tools/context';
 /** @unstable Unsafe cast utility for bridging internal type boundaries. */
 export { frameworkCast } from '@noetic-tools/types';
 /**

package/dist/until/predicates.d.ts

@@ -1,4 +1,4 @@
-import type { StorageAdapter } from '@noetic-tools/memory';
+import type { StorageAdapter } from '@noetic-tools/context';
 import type { Until } from '@noetic-tools/types';
 import type { EmbedFn } from '../types/embed.js';
 import { never } from './never.js';

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@noetic-tools/core",
-  "version": "3.2.0",
+  "version": "5.0.0",
   "type": "module",
-  "description": "Step primitives, interpreter, runtime, and memory layer contract for Noetic agents.",
+  "description": "Step primitives, interpreter, runtime, and context layer contract for Noetic agents.",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -66,8 +66,8 @@
     }
   },
   "dependencies": {
-    "@noetic-tools/memory": "^2.0.0",
-    "@noetic-tools/types": "^2.1.0",
+    "@noetic-tools/context": "^1.0.0",
+    "@noetic-tools/types": "^3.0.0",
     "@openrouter/agent": "^0.6.0",
     "zod": "^4.0.0"
   },

package/schema/noetic-workflow.schema.json

@@ -455,6 +455,34 @@
           ],
           "additionalProperties": false
         },
+        {
+          "type": "object",
+          "properties": {
+            "kind": {
+              "type": "string",
+              "const": "subflow"
+            },
+            "id": {
+              "type": "string",
+              "minLength": 1
+            },
+            "document": {
+              "$ref": "#"
+            },
+            "ref": {
+              "type": "string",
+              "minLength": 1
+            },
+            "input": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "kind",
+            "id"
+          ],
+          "additionalProperties": false
+        },
         {
           "type": "object",
           "properties": {

package/dist/builders/memory-builder.d.ts

@@ -1,11 +0,0 @@
-import type { MemoryConfig, MemoryLayer } from '@noetic-tools/memory';
-/**
- * Creates a type-safe memory configuration from a tuple of memory layers.
- * The returned config preserves literal layer types for compile-time inference
- * via `InferMemory<typeof config>`.
- *
- * @public
- * @param layers - Tuple of memory layers to include in the configuration.
- * @returns A `MemoryConfig` carrying the inferred memory shape as a phantom type.
- */
-export declare function memory<const T extends readonly MemoryLayer[]>(layers: T): MemoryConfig<T>;

package/dist/builders/memory-builder.js

@@ -1,15 +0,0 @@
-import { frameworkCast } from '@noetic-tools/types';
-/**
- * Creates a type-safe memory configuration from a tuple of memory layers.
- * The returned config preserves literal layer types for compile-time inference
- * via `InferMemory<typeof config>`.
- *
- * @public
- * @param layers - Tuple of memory layers to include in the configuration.
- * @returns A `MemoryConfig` carrying the inferred memory shape as a phantom type.
- */
-export function memory(layers) {
-    return frameworkCast({
-        layers,
-    });
-}

package/dist/patterns/flow.d.ts

@@ -1,2 +0,0 @@
-export type { FlowNode, ForkFlowNode, LlmFlowNode, SequenceFlowNode, SpawnFlowNode, SubagentFlowNode, } from '@noetic-tools/memory';
-export { FlowSchema, flowDepth, validateFlow, walkFlow } from '@noetic-tools/memory';

package/dist/patterns/flow.js

@@ -1 +0,0 @@
-export { FlowSchema, flowDepth, validateFlow, walkFlow } from '@noetic-tools/memory';

package/dist/portable/memory-layers.d.ts

@@ -1,8 +0,0 @@
-/** @public */
-/** @public */
-/** @public */
-/** @public */
-/** @public */
-/** @public */
-/** @public */
-export { durableTaskState, historyWindow, observationalMemory, planMemory, temporalMemory, toolMemoryLayer, workingMemory, } from '@noetic-tools/memory';

package/dist/portable/memory-layers.js

@@ -1,8 +0,0 @@
-/** @public */
-/** @public */
-/** @public */
-/** @public */
-/** @public */
-/** @public */
-/** @public */
-export { durableTaskState, historyWindow, observationalMemory, planMemory, temporalMemory, toolMemoryLayer, workingMemory, } from '@noetic-tools/memory';