@noetic-tools/core 3.2.0 → 4.0.0

package/dist/runtime/step-registry.d.ts

@@ -1,10 +1,10 @@
-import type { ContextMemory } from '@noetic-tools/memory';
+import type { ContextData } from '@noetic-tools/context';
 import type { Step } from '@noetic-tools/types';
 /** Registry-wide step type — stored at the widest generic parameters so
  *  callers can register steps with narrower input/output types without
  *  fighting variance. The public `Step` default already uses `unknown` for
  *  the input and output parameters, matching this shape. */
-type RegisteredStep = Step<ContextMemory, unknown, unknown>;
+type RegisteredStep = Step<ContextData, unknown, unknown>;
 /**
  * @public
  * Registers a step so the subprocess adapter can look it up by id.
@@ -18,7 +18,7 @@ type RegisteredStep = Step<ContextMemory, unknown, unknown>;
  * `clearRegistry` wiring is deferred — see the tracked follow-up task on
  * the team's board (strict-registry-plus-test-clear).
  */
-export declare function registerStep<TMemory, I, O>(step: Step<TMemory, I, O>): void;
+export declare function registerStep<TContext, I, O>(step: Step<TContext, I, O>): void;
 /**
  * @public
  * Looks up a registered step by id. Returns `null` when the id is not known

package/dist/runtime/{tool-memory.d.ts → tool-context.d.ts}

@@ -1,4 +1,3 @@
-import type { AgentHarnessContract, Context, ToolExecutionContext, ToolMemory } from '@noetic-tools/types';
+import type { AgentHarnessContract, Context, ToolExecutionContext } from '@noetic-tools/types';
 import type { TurnContext } from '@openrouter/agent';
-export declare function buildToolMemory(harness: AgentHarnessContract, ctx: Context): ToolMemory;
 export declare function buildToolExecutionContext(ctx: Context, harness: AgentHarnessContract, turnContext?: TurnContext): ToolExecutionContext;

package/dist/runtime/{tool-memory.js → tool-context.js}

@@ -1,4 +1,4 @@
-export function buildToolMemory(harness, ctx) {
+function buildToolContext(harness, ctx) {
     return {
         get(layerId) {
             return harness.getLayerState(ctx.id, layerId);
@@ -9,12 +9,15 @@ export function buildToolMemory(harness, ctx) {
     };
 }
 export function buildToolExecutionContext(ctx, harness, turnContext) {
+    const toolContext = buildToolContext(harness, ctx);
     return {
         ctx,
         harness,
         fs: harness.fs,
         shell: harness.shell,
-        memory: buildToolMemory(harness, ctx),
+        context: toolContext,
+        // Deprecated alias — same accessor object, not a copy.
+        memory: toolContext,
         assembledView: ctx.itemLog.items,
         lastStepMeta: ctx.lastStepMeta,
         turnContext,

package/dist/runtime/tool-ui.d.ts

@@ -5,7 +5,7 @@
  * render functions at the call / progress / result / error lifecycle points and
  * forwards each returned `UiFragment` as an `openui.fragment` framework event
  * (namespaced `${agentName}:openui.fragment`). The framework never interprets
- * the fragment source — a UI surface (memory layer + transport) composes it.
+ * the fragment source — a UI surface (context layer + transport) composes it.
  *
  * The `ui` methods are declared bivariantly on `ToolUiDeclaration`, so the
  * erased `Tool` handle the runtime holds can call them with runtime values.

package/dist/runtime/tool-ui.js

@@ -5,7 +5,7 @@
  * render functions at the call / progress / result / error lifecycle points and
  * forwards each returned `UiFragment` as an `openui.fragment` framework event
  * (namespaced `${agentName}:openui.fragment`). The framework never interprets
- * the fragment source — a UI surface (memory layer + transport) composes it.
+ * the fragment source — a UI surface (context layer + transport) composes it.
  *
  * The `ui` methods are declared bivariantly on `ToolUiDeclaration`, so the
  * erased `Tool` handle the runtime holds can call them with runtime values.

package/dist/schemas/workflow.d.ts

@@ -1,281 +1,7 @@
 /**
- * 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 type { SubHarnessKind } from '@noetic-tools/types';
-import { z } from 'zod';
-interface UntilAnyPredicate {
-    kind: 'any';
-    predicates: UntilPredicate[];
-}
-interface UntilAllPredicate {
-    kind: 'all';
-    predicates: UntilPredicate[];
-}
-/** @public Discriminated union of named until predicates usable in JSON workflows. */
-export type UntilPredicate = {
-    kind: 'maxSteps';
-    n: number;
-} | {
-    kind: 'maxCost';
-    usd: number;
-} | {
-    kind: 'maxDuration';
-    ms: number;
-} | {
-    kind: 'noToolCalls';
-} | {
-    kind: 'outputContains';
-    marker: string;
-} | {
-    kind: 'outputEquals';
-    sentinel: string;
-} | {
-    kind: 'converged';
-    threshold?: number;
-} | UntilAnyPredicate | UntilAllPredicate;
-/** @public Zod schema validating a named `until` predicate (including `any`/`all` combinators). */
-export declare const UntilPredicateSchema: z.ZodType<UntilPredicate>;
-/** @public ESM literal enum for merge strategies. */
-export declare const MergeStrategy: {
-    readonly Last: 'last';
-    readonly First: 'first';
-    readonly Concat: 'concat';
-};
-/** @public Named merge strategy for fork nodes. */
-export type MergeStrategy = (typeof MergeStrategy)[keyof typeof MergeStrategy];
-/** @public Zod schema for the named merge strategy used by `fork` nodes. */
-export declare const MergeStrategySchema: z.ZodEnum<{
-    concat: "concat";
-    first: "first";
-    last: "last";
-}>;
-declare const ModelParamsSchema: z.ZodObject<{
-    temperature: z.ZodOptional<z.ZodNumber>;
-    topP: z.ZodOptional<z.ZodNumber>;
-    maxTokens: z.ZodOptional<z.ZodNumber>;
-    stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-/**
- * 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.
- */
-declare const LlmToolEntrySchema: z.ZodObject<{
-    type: z.ZodString;
-    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-/** Retry policy for a `run` node, mirroring `RetryPolicy` in `@noetic-tools/types`. */
-declare const RetryPolicySchema: z.ZodObject<{
-    maxAttempts: z.ZodNumber;
-    backoff: z.ZodEnum<{
-        exponential: "exponential";
-        fixed: "fixed";
-        linear: "linear";
-    }>;
-    initialDelay: z.ZodNumber;
-    maxDelay: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-declare const HarnessSettingsSchema: z.ZodObject<{
-    model: z.ZodOptional<z.ZodString>;
-    permissionMode: z.ZodOptional<z.ZodEnum<{
-        acceptEdits: "acceptEdits";
-        bypassPermissions: "bypassPermissions";
-        default: "default";
-        plan: "plan";
-    }>>;
-    maxTurns: z.ZodOptional<z.ZodNumber>;
-    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-declare const HarnessSessionPolicySchema: z.ZodObject<{
-    reuse: z.ZodOptional<z.ZodString>;
-    onComplete: z.ZodOptional<z.ZodEnum<{
-        destroy: "destroy";
-        detach: "detach";
-        stop: "stop";
-    }>>;
-}, z.core.$strip>;
-interface WorkflowNodeBase {
-    id: string;
-}
-/**
- * A reference to a streaming `OutputCodec` for an `llm` node's structured
- * output. The hydrator resolves `library` from `HydrationContext.uiLibraries`
- * to a live codec (e.g. `openUi(myLibrary)` from `@noetic-tools/openui`), the
- * same registry-resolution pattern sub-harness nodes use for adapters. Kept a
- * *reference* because a codec is a runtime object, not JSON-expressible.
- */
-export interface OutputCodecRef {
-    /** The codec dialect. Only `'openui'` is defined today. */
-    codec: 'openui';
-    /** Registry key resolved from `HydrationContext.uiLibraries`. */
-    library: string;
-}
-export interface LlmWorkflowNode extends WorkflowNodeBase {
-    kind: 'llm';
-    model?: string;
-    instructions: string;
-    /**
-     * Tool entries. Every entry is an object `{ type, parameters? }`. A CLIENT
-     * tool is `{ type: "<registered-tool-name>" }` (resolved from the registry);
-     * a SERVER tool is `{ type: "openrouter:web_search" | "openrouter:web_fetch",
-     * parameters?: {...} }` (executed by the provider). Client vs server is
-     * decided by the `type` value.
-     */
-    tools?: z.infer<typeof LlmToolEntrySchema>[];
-    params?: z.infer<typeof ModelParamsSchema>;
-    /** Streaming output-codec reference, resolved from `HydrationContext.uiLibraries`. */
-    output?: OutputCodecRef;
-}
-export interface ToolWorkflowNode extends WorkflowNodeBase {
-    kind: 'tool';
-    toolName: string;
-    args?: Record<string, unknown>;
-}
-/**
- * A node that runs a serialised code body. Unlike the programmatic `step.run`
- * (which carries a closure), the JSON form carries `execute` as a code STRING.
- * The code is never eval'd in-process (Cloudflare Workers forbid eval); it is
- * dispatched through a subprocess adapter (`ctx.subprocess`, or a named adapter
- * resolved by ref). Execution therefore requires a subprocess adapter capable
- * of running the code and returning its stdout.
- */
-export interface RunWorkflowNode extends WorkflowNodeBase {
-    kind: 'run';
-    /** Source code executed in the subprocess. Receives the step input on stdin. */
-    execute: string;
-    /** Optional retry policy applied to the step. */
-    retry?: z.infer<typeof RetryPolicySchema>;
-    /** Named subprocess adapter ref; defaults to `ctx.subprocess` when omitted. */
-    subprocess?: string;
-}
-export interface BranchRoute {
-    match: string;
-    target: WorkflowNode;
-}
-export interface BranchWorkflowNode extends WorkflowNodeBase {
-    kind: 'branch';
-    routes: BranchRoute[];
-    default?: WorkflowNode;
-}
-export interface ForkWorkflowNode extends WorkflowNodeBase {
-    kind: 'fork';
-    mode: 'race' | 'all' | 'settle';
-    /**
-     * Static fan-out: one child per entry. Mutually exclusive with `each` —
-     * supply exactly one.
-     */
-    paths?: WorkflowNode[];
-    /**
-     * Dynamic fan-out: instantiate this body template once per item of a
-     * runtime-produced array (data-dependent N). Mutually exclusive with `paths`.
-     */
-    each?: WorkflowNode;
-    /**
-     * Selector key into the fork input (parsed as JSON) locating the array to
-     * fan out over. When omitted, the input string itself is parsed as a JSON
-     * array. Only meaningful with `each`.
-     */
-    over?: string;
-    merge?: MergeStrategy;
-    concurrency?: number;
-}
-export interface SpawnWorkflowNode extends WorkflowNodeBase {
-    kind: 'spawn';
-    child: WorkflowNode;
-    timeout?: number;
-    /**
-     * Memory layers the child runs with, by registered name (resolved from
-     * `HydrationContext.layers`, like `provide`). Omit to inherit the parent's
-     * layers — the default spawn behaviour. Naming layers here REPLACES the
-     * inherited set for the child, so list every layer the child needs.
-     */
-    layers?: string[];
-}
-export interface ProvideWorkflowNode extends WorkflowNodeBase {
-    kind: 'provide';
-    child: WorkflowNode;
-    layers: string[];
-}
-export interface LoopWorkflowNode extends WorkflowNodeBase {
-    kind: 'loop';
-    body: WorkflowNode;
-    until: UntilPredicate;
-    maxIterations?: number;
-}
-export interface SequenceWorkflowNode extends WorkflowNodeBase {
-    kind: 'sequence';
-    steps: WorkflowNode[];
-}
-export interface EveryWorkflowNode extends WorkflowNodeBase {
-    kind: 'every';
-    step: WorkflowNode;
-    ms: number;
-    onError?: 'continue' | 'fail';
-}
-/**
- * A node that delegates a turn to a coding-agent harness. `kind` is the harness
- * id (e.g. `claude-code`); the hydrator resolves the matching adapter from the
- * workflow's harness registry.
- */
-export interface SubHarnessWorkflowNode extends WorkflowNodeBase {
-    kind: SubHarnessKind;
-    prompt: string;
-    instructions?: string;
-    settings?: z.infer<typeof HarnessSettingsSchema>;
-    session?: z.infer<typeof HarnessSessionPolicySchema>;
-}
-/** @public Discriminated union of all JSON-serialisable workflow node kinds. */
-export type WorkflowNode = LlmWorkflowNode | ToolWorkflowNode | RunWorkflowNode | BranchWorkflowNode | ForkWorkflowNode | SpawnWorkflowNode | ProvideWorkflowNode | LoopWorkflowNode | SequenceWorkflowNode | EveryWorkflowNode | SubHarnessWorkflowNode;
-/** @public Zod schema validating a single `WorkflowNode` (any JSON-safe kind). */
-export declare const WorkflowNodeSchema: z.ZodType<WorkflowNode>;
-/** @public Top-level envelope for a JSON workflow definition. */
-export interface WorkflowDocument {
-    version: 1;
-    root: WorkflowNode;
-}
-/** @public Zod schema validating a complete `WorkflowDocument`. */
-export declare const WorkflowDocumentSchema: z.ZodType<WorkflowDocument>;
-/** Validates a candidate workflow document. Throws `ZodError` on invalid input. */
-export declare function validateWorkflow(input: unknown): WorkflowDocument;
-/** Walks a workflow tree depth-first, yielding each node. */
-export declare function walkWorkflow(node: WorkflowNode): Iterable<WorkflowNode>;
-/** A flattened, JSON-safe view of a workflow tree: its nodes and parent→child edges. */
-export interface WorkflowGraph {
-    nodes: Array<{
-        id: string;
-        kind: WorkflowNode['kind'];
-    }>;
-    edges: Array<{
-        from: string;
-        to: string;
-    }>;
-}
-/**
- * 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 declare function workflowGraph(root: WorkflowNode): WorkflowGraph;
-/**
- * Returns the maximum depth of a workflow tree.
- * Leaf nodes (`llm`, `tool`) have depth 0. Structural nodes add +1.
- */
-export declare function workflowDepth(node: WorkflowNode): number;
-export {};
+export type { BranchRoute, BranchWorkflowNode, EveryWorkflowNode, ForkWorkflowNode, LlmWorkflowNode, LoopWorkflowNode, OutputCodecRef, ProvideWorkflowNode, RunWorkflowNode, SequenceWorkflowNode, SpawnWorkflowNode, SubflowWorkflowNode, SubHarnessWorkflowNode, ToolWorkflowNode, UntilPredicate, WorkflowDocument, WorkflowGraph, WorkflowNode, } from '@noetic-tools/types';
+export { MergeStrategy, MergeStrategySchema, UntilPredicateSchema, validateWorkflow, WorkflowDocumentSchema, WorkflowNodeSchema, walkWorkflow, workflowDepth, workflowGraph, } from '@noetic-tools/types';