@noetic-tools/core 5.3.0 → 5.4.0

package/dist/builders/provide-builder.js

@@ -1,6 +1,5 @@
 import { NoeticConfigError } from '@noetic-tools/types';
 import { getDefaultRegistrar } from '../types/step-registrar.js';
-import { resolveContextOption } from './context-option.js';
 /**
  * Creates a provide step that attaches context layers to its child without creating an isolated context.
  * Like React's Context.Provider — layers are available to all descendant steps.
@@ -10,35 +9,35 @@ import { resolveContextOption } from './context-option.js';
  * @param opts.id - Unique step identifier used in traces and error messages.
  * @param opts.child - Step to execute with the provided layers.
  * @param opts.context - Context layers to provide to descendant steps.
- * @returns A `StepProvide` step.
+ * @returns A `StepWithContext` step.
  * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
  * @throws `NoeticConfigError` with code `MISSING_CHILD_STEP` if `child` is not provided.
  */
-export function provide(opts) {
+export function withContext(opts) {
     if (!opts.id?.trim()) {
         throw new NoeticConfigError({
             code: 'EMPTY_STEP_ID',
-            message: 'provide() requires a non-empty id.',
-            hint: 'Pass a unique string as the id field, e.g. provide({ id: "my-provider", ... }).',
+            message: 'withContext() requires a non-empty id.',
+            hint: 'Pass a unique string as the id field, e.g. withContext({ id: "my-provider", ... }).',
         });
     }
     if (!opts.child) {
         throw new NoeticConfigError({
             code: 'MISSING_CHILD_STEP',
-            message: 'provide() requires a child step.',
+            message: 'withContext() requires a child step.',
             hint: 'Provide a child step to execute with the provided context layers.',
         });
     }
-    const layers = resolveContextOption(opts);
+    const layers = opts.context;
     if (!layers) {
         throw new NoeticConfigError({
             code: 'MISSING_CONTEXT_LAYERS',
-            message: 'provide() requires context layers.',
-            hint: 'Pass context: [workingMemoryContext()]. The `memory` key is the deprecated spelling of `context`.',
+            message: 'withContext() requires context layers.',
+            hint: 'Pass context: [scratchpad()].',
         });
     }
     const built = {
-        kind: 'provide',
+        kind: 'withContext',
         id: opts.id,
         child: opts.child,
         context: layers,

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

@@ -4,8 +4,6 @@ interface SpawnOpts<TContext, I, O> {
     id: string;
     child: Step<TContext, I, O>;
     context?: ContextConfig | ContextLayer[];
-    /** @deprecated Renamed to `context`. */
-    memory?: ContextConfig | ContextLayer[];
     timeout?: number;
     /**
      * Optional per-step subprocess adapter override. The interpreter routes

package/dist/builders/spawn-builder.js

@@ -1,6 +1,5 @@
 import { NoeticConfigError } from '@noetic-tools/types';
 import { getDefaultRegistrar } from '../types/step-registrar.js';
-import { resolveContextOption } from './context-option.js';
 //#endregion
 //#region Public API
 /**
@@ -38,12 +37,12 @@ export function spawn(opts) {
         kind: 'spawn',
         id: opts.id,
         child: opts.child,
-        context: resolveContextOption(opts),
+        context: opts.context,
         timeout: opts.timeout,
         subprocess: opts.subprocess,
     };
     getDefaultRegistrar().register(built);
-    // Ensure the child is addressable by id — builders for `run`/`llm`/`tool`
+    // Ensure the child is addressable by id — builders for `runCode`/`callModel`/`invokeTool`
     // self-register, but a caller can construct a step literal and pass it as
     // `child` without going through a builder.
     getDefaultRegistrar().register(opts.child);

package/dist/builders/step-builders.d.ts

@@ -1,7 +1,6 @@
 import type { ContextData } from '@noetic-tools/context';
-import type { Context, Lazy, ModelParams, OutputCodec, RetryPolicy, ServerToolSpec, StepLLM, StepRun, StepSubHarness, StepTool, SubHarness, SubHarnessSessionPolicy, SubHarnessSettings, SubprocessAdapter, Tool } from '@noetic-tools/types';
-import type { ZodType } from 'zod';
-export interface StepRunOpts<TContext, I, O> {
+import type { Context, Lazy, ModelParams, OutputCodec, RetryPolicy, ServerToolSpec, StandardSchemaV1, StepCallModel, StepInvokeTool, StepRunCode, StepSubHarness, SubHarness, SubHarnessSessionPolicy, SubHarnessSettings, SubprocessAdapter, Tool } from '@noetic-tools/types';
+export interface RunCodeOpts<TContext, I, O> {
     id: string;
     execute: (input: I, ctx: Context<TContext>) => Promise<O>;
     retry?: RetryPolicy;
@@ -12,7 +11,7 @@ export interface StepRunOpts<TContext, I, O> {
      */
     subprocess?: SubprocessAdapter;
 }
-export interface StepLLMOpts<TContext, O> {
+export interface CallModelOpts<TContext, O> {
     id: string;
     /** Model id. Eager string or `(ctx) => string` getter (resolved at step execution). */
     model: Lazy<string, TContext>;
@@ -24,14 +23,19 @@ export interface StepLLMOpts<TContext, O> {
      * server tool the provider executes, e.g. web search/fetch).
      */
     tools?: Lazy<(Tool | ServerToolSpec)[] | undefined, TContext>;
-    /** Structured output: a Zod schema or a streaming `OutputCodec` (e.g. OpenUI Lang). */
-    output?: ZodType<O> | OutputCodec<O>;
+    /** Structured output: a Standard Schema (Zod, Valibot, …) or a streaming `OutputCodec` (e.g. OpenUI Lang). */
+    output?: StandardSchemaV1<unknown, O> | OutputCodec<O>;
+    /**
+     * Explicit raw JSON Schema override sent to the model. For non-Zod schemas,
+     * it takes precedence over StandardJSONSchemaV1 conversion.
+     */
+    outputJsonSchema?: Record<string, unknown>;
     params?: ModelParams;
     emit?: boolean | ((eventType: string, data: Record<string, unknown>) => boolean);
 }
-export interface StepToolOpts<I, O> {
+export interface InvokeToolOpts<I, O> {
     id: string;
-    tool: Tool<ZodType<I>, ZodType<O>>;
+    tool: Tool<StandardSchemaV1<unknown, I>, StandardSchemaV1<unknown, O>>;
     args?: Partial<I>;
 }
 export interface StepSubHarnessOpts<TContext, O> {
@@ -44,58 +48,65 @@ export interface StepSubHarnessOpts<TContext, O> {
     settings?: SubHarnessSettings;
     /** System instructions applied on the first message of a fresh session. */
     instructions?: Lazy<string | undefined, TContext>;
-    /** Optional Zod schema; when set the assistant text is JSON-parsed and validated. */
-    output?: ZodType<O>;
+    /** Optional Standard Schema; when set the assistant text is JSON-parsed and validated. */
+    output?: StandardSchemaV1<unknown, O>;
     /** Session reuse + teardown policy across steps. */
     session?: SubHarnessSessionPolicy;
     emit?: boolean | ((eventType: string, data: Record<string, unknown>) => boolean);
 }
+/**
+ * Creates a pure async computation step.
+ *
+ * @public
+ * @param opts.id - Unique step identifier used in traces and error messages.
+ * @param opts.execute - Async function `(input, ctx) => output` that performs the work.
+ * @param opts.retry - Optional retry policy controlling attempts, backoff, and delay.
+ * @param opts.subprocess - Optional per-step subprocess adapter override.
+ * @returns A `StepRunCode` that can be composed into larger pipelines. The step
+ *   is auto-registered in the shared step registry so the subprocess
+ *   adapter can dispatch it by id.
+ * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
+ * @throws `NoeticConfigError` with code `MISSING_EXECUTE_FUNCTION` if `execute` is not provided.
+ * @throws `NoeticConfigError` with code `DUPLICATE_STEP_ID` if another step with the same id is already registered with a different body.
+ */
+export declare function runCode<TContext = ContextData, I = unknown, O = unknown>(opts: RunCodeOpts<TContext, I, O>): StepRunCode<TContext, I, O>;
+/**
+ * Creates a model call step with optional tools and structured output.
+ *
+ * @public
+ * @param opts.id - Unique step identifier used in traces and error messages.
+ * @param opts.model - Model identifier, eager string or `(ctx) => string` getter (resolved at step execution time).
+ * @param opts.instructions - Optional system prompt; eager string or `(ctx) => string | undefined` getter.
+ * @param opts.tools - Optional tools; eager array or `(ctx) => Tool[] | undefined` getter.
+ * @param opts.output - Optional Zod schema enabling structured output parsing.
+ * @param opts.params - Optional model parameters (temperature, topP, maxTokens, stopSequences).
+ * @returns A `StepCallModel` that can be composed into larger pipelines. The step
+ *   is auto-registered in the shared step registry.
+ * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
+ * @throws `NoeticConfigError` with code `MISSING_MODEL` if an eager `model` string is empty. Function-form models are validated at step execution.
+ */
+export declare function callModel<TContext = ContextData, I = unknown, O = unknown>(opts: CallModelOpts<TContext, O>): StepCallModel<TContext, I, O>;
+/**
+ * Creates a tool execution step that invokes a typed tool definition.
+ *
+ * @public
+ * @param opts.id - Unique step identifier used in traces and error messages.
+ * @param opts.tool - The tool definition with typed input/output schemas.
+ * @param opts.args - Optional partial args that override or supplement model-provided arguments.
+ * @returns A `StepInvokeTool` that can be composed into larger pipelines. The step
+ *   is auto-registered in the shared step registry.
+ * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
+ * @throws `NoeticConfigError` with code `MISSING_TOOL` if `tool` is not provided.
+ */
+export declare function invokeTool<TContext = ContextData, I = unknown, O = unknown>(opts: InvokeToolOpts<I, O>): StepInvokeTool<TContext, I, O>;
+/**
+ * The sub-harness step builder namespace. Unlike the flattened base builders
+ * (`runCode`, `callModel`, `invokeTool`), the coding-agent harness builders
+ * stay grouped under `step` — their `step.<harness>()` API is unchanged.
+ *
+ * @public
+ */
 export declare const step: {
-    /**
-     * Creates a pure async computation step.
-     *
-     * @public
-     * @param opts.id - Unique step identifier used in traces and error messages.
-     * @param opts.execute - Async function `(input, ctx) => output` that performs the work.
-     * @param opts.retry - Optional retry policy controlling attempts, backoff, and delay.
-     * @param opts.subprocess - Optional per-step subprocess adapter override.
-     * @returns A `StepRun` that can be composed into larger pipelines. The step
-     *   is auto-registered in the shared step registry so the subprocess
-     *   adapter can dispatch it by id.
-     * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
-     * @throws `NoeticConfigError` with code `MISSING_EXECUTE_FUNCTION` if `execute` is not provided.
-     * @throws `NoeticConfigError` with code `DUPLICATE_STEP_ID` if another step with the same id is already registered with a different body.
-     */
-    run<TContext = ContextData, I = unknown, O = unknown>(opts: StepRunOpts<TContext, I, O>): StepRun<TContext, I, O>;
-    /**
-     * Creates an LLM model call step with optional tools and structured output.
-     *
-     * @public
-     * @param opts.id - Unique step identifier used in traces and error messages.
-     * @param opts.model - Model identifier, eager string or `(ctx) => string` getter (resolved at step execution time).
-     * @param opts.instructions - Optional system prompt; eager string or `(ctx) => string | undefined` getter.
-     * @param opts.tools - Optional tools; eager array or `(ctx) => Tool[] | undefined` getter.
-     * @param opts.output - Optional Zod schema enabling structured output parsing.
-     * @param opts.params - Optional model parameters (temperature, topP, maxTokens, stopSequences).
-     * @returns A `StepLLM` that can be composed into larger pipelines. The step
-     *   is auto-registered in the shared step registry.
-     * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
-     * @throws `NoeticConfigError` with code `MISSING_MODEL` if an eager `model` string is empty. Function-form models are validated at step execution.
-     */
-    llm<TContext = ContextData, I = unknown, O = unknown>(opts: StepLLMOpts<TContext, O>): StepLLM<TContext, I, O>;
-    /**
-     * Creates a tool execution step that invokes a typed tool definition.
-     *
-     * @public
-     * @param opts.id - Unique step identifier used in traces and error messages.
-     * @param opts.tool - The tool definition with typed input/output schemas.
-     * @param opts.args - Optional partial args that override or supplement LLM-provided arguments.
-     * @returns A `StepTool` that can be composed into larger pipelines. The step
-     *   is auto-registered in the shared step registry.
-     * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
-     * @throws `NoeticConfigError` with code `MISSING_TOOL` if `tool` is not provided.
-     */
-    tool<TContext = ContextData, I = unknown, O = unknown>(opts: StepToolOpts<I, O>): StepTool<TContext, I, O>;
     /**
      * Creates a step that delegates a turn to the Claude Code harness.
      *

package/dist/builders/step-builders.js

@@ -41,118 +41,125 @@ function buildSubHarnessStep(kind, builderName, opts) {
 }
 //#endregion
 //#region Builders
+/**
+ * Creates a pure async computation step.
+ *
+ * @public
+ * @param opts.id - Unique step identifier used in traces and error messages.
+ * @param opts.execute - Async function `(input, ctx) => output` that performs the work.
+ * @param opts.retry - Optional retry policy controlling attempts, backoff, and delay.
+ * @param opts.subprocess - Optional per-step subprocess adapter override.
+ * @returns A `StepRunCode` that can be composed into larger pipelines. The step
+ *   is auto-registered in the shared step registry so the subprocess
+ *   adapter can dispatch it by id.
+ * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
+ * @throws `NoeticConfigError` with code `MISSING_EXECUTE_FUNCTION` if `execute` is not provided.
+ * @throws `NoeticConfigError` with code `DUPLICATE_STEP_ID` if another step with the same id is already registered with a different body.
+ */
+export function runCode(opts) {
+    if (!opts.id || opts.id.trim() === '') {
+        throw new NoeticConfigError({
+            code: 'EMPTY_STEP_ID',
+            message: 'runCode() requires a non-empty id.',
+            hint: 'Pass a unique string as the id field, e.g. runCode({ id: "my-step", ... }).',
+        });
+    }
+    if (!opts.execute) {
+        throw new NoeticConfigError({
+            code: 'MISSING_EXECUTE_FUNCTION',
+            message: 'runCode() requires an execute function.',
+            hint: 'Provide an async execute function, e.g. execute: async (input, ctx) => result.',
+        });
+    }
+    const built = {
+        kind: 'runCode',
+        ...opts,
+    };
+    getDefaultRegistrar().register(built);
+    return built;
+}
+/**
+ * Creates a model call step with optional tools and structured output.
+ *
+ * @public
+ * @param opts.id - Unique step identifier used in traces and error messages.
+ * @param opts.model - Model identifier, eager string or `(ctx) => string` getter (resolved at step execution time).
+ * @param opts.instructions - Optional system prompt; eager string or `(ctx) => string | undefined` getter.
+ * @param opts.tools - Optional tools; eager array or `(ctx) => Tool[] | undefined` getter.
+ * @param opts.output - Optional Zod schema enabling structured output parsing.
+ * @param opts.params - Optional model parameters (temperature, topP, maxTokens, stopSequences).
+ * @returns A `StepCallModel` that can be composed into larger pipelines. The step
+ *   is auto-registered in the shared step registry.
+ * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
+ * @throws `NoeticConfigError` with code `MISSING_MODEL` if an eager `model` string is empty. Function-form models are validated at step execution.
+ */
+export function callModel(opts) {
+    if (!opts.id || opts.id.trim() === '') {
+        throw new NoeticConfigError({
+            code: 'EMPTY_STEP_ID',
+            message: 'callModel() requires a non-empty id.',
+            hint: 'Pass a unique string as the id field, e.g. callModel({ id: "my-llm", ... }).',
+        });
+    }
+    // Only validate eager models here. Function-form models are validated
+    // post-resolution in executeCallModel so the same MISSING_MODEL error surfaces
+    // whether the caller passes a string or a getter.
+    if (typeof opts.model === 'string' && opts.model.trim() === '') {
+        throw new NoeticConfigError({
+            code: 'MISSING_MODEL',
+            message: 'callModel() requires a non-empty model.',
+            hint: "Pass a model identifier, e.g. model: 'anthropic/claude-sonnet-4-20250514'.",
+        });
+    }
+    const built = {
+        kind: 'callModel',
+        ...opts,
+    };
+    getDefaultRegistrar().register(built);
+    return built;
+}
+/**
+ * Creates a tool execution step that invokes a typed tool definition.
+ *
+ * @public
+ * @param opts.id - Unique step identifier used in traces and error messages.
+ * @param opts.tool - The tool definition with typed input/output schemas.
+ * @param opts.args - Optional partial args that override or supplement model-provided arguments.
+ * @returns A `StepInvokeTool` that can be composed into larger pipelines. The step
+ *   is auto-registered in the shared step registry.
+ * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
+ * @throws `NoeticConfigError` with code `MISSING_TOOL` if `tool` is not provided.
+ */
+export function invokeTool(opts) {
+    if (!opts.id || opts.id.trim() === '') {
+        throw new NoeticConfigError({
+            code: 'EMPTY_STEP_ID',
+            message: 'invokeTool() requires a non-empty id.',
+            hint: 'Pass a unique string as the id field, e.g. invokeTool({ id: "my-tool", ... }).',
+        });
+    }
+    if (!opts.tool) {
+        throw new NoeticConfigError({
+            code: 'MISSING_TOOL',
+            message: 'invokeTool() requires a tool.',
+            hint: 'Provide a tool definition created with the tool() builder.',
+        });
+    }
+    const built = {
+        kind: 'invokeTool',
+        ...opts,
+    };
+    getDefaultRegistrar().register(built);
+    return built;
+}
+/**
+ * The sub-harness step builder namespace. Unlike the flattened base builders
+ * (`runCode`, `callModel`, `invokeTool`), the coding-agent harness builders
+ * stay grouped under `step` — their `step.<harness>()` API is unchanged.
+ *
+ * @public
+ */
 export const step = {
-    /**
-     * Creates a pure async computation step.
-     *
-     * @public
-     * @param opts.id - Unique step identifier used in traces and error messages.
-     * @param opts.execute - Async function `(input, ctx) => output` that performs the work.
-     * @param opts.retry - Optional retry policy controlling attempts, backoff, and delay.
-     * @param opts.subprocess - Optional per-step subprocess adapter override.
-     * @returns A `StepRun` that can be composed into larger pipelines. The step
-     *   is auto-registered in the shared step registry so the subprocess
-     *   adapter can dispatch it by id.
-     * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
-     * @throws `NoeticConfigError` with code `MISSING_EXECUTE_FUNCTION` if `execute` is not provided.
-     * @throws `NoeticConfigError` with code `DUPLICATE_STEP_ID` if another step with the same id is already registered with a different body.
-     */
-    run(opts) {
-        if (!opts.id || opts.id.trim() === '') {
-            throw new NoeticConfigError({
-                code: 'EMPTY_STEP_ID',
-                message: 'step.run() requires a non-empty id.',
-                hint: 'Pass a unique string as the id field, e.g. step.run({ id: "my-step", ... }).',
-            });
-        }
-        if (!opts.execute) {
-            throw new NoeticConfigError({
-                code: 'MISSING_EXECUTE_FUNCTION',
-                message: 'step.run() requires an execute function.',
-                hint: 'Provide an async execute function, e.g. execute: async (input, ctx) => result.',
-            });
-        }
-        const built = {
-            kind: 'run',
-            ...opts,
-        };
-        getDefaultRegistrar().register(built);
-        return built;
-    },
-    /**
-     * Creates an LLM model call step with optional tools and structured output.
-     *
-     * @public
-     * @param opts.id - Unique step identifier used in traces and error messages.
-     * @param opts.model - Model identifier, eager string or `(ctx) => string` getter (resolved at step execution time).
-     * @param opts.instructions - Optional system prompt; eager string or `(ctx) => string | undefined` getter.
-     * @param opts.tools - Optional tools; eager array or `(ctx) => Tool[] | undefined` getter.
-     * @param opts.output - Optional Zod schema enabling structured output parsing.
-     * @param opts.params - Optional model parameters (temperature, topP, maxTokens, stopSequences).
-     * @returns A `StepLLM` that can be composed into larger pipelines. The step
-     *   is auto-registered in the shared step registry.
-     * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
-     * @throws `NoeticConfigError` with code `MISSING_MODEL` if an eager `model` string is empty. Function-form models are validated at step execution.
-     */
-    llm(opts) {
-        if (!opts.id || opts.id.trim() === '') {
-            throw new NoeticConfigError({
-                code: 'EMPTY_STEP_ID',
-                message: 'step.llm() requires a non-empty id.',
-                hint: 'Pass a unique string as the id field, e.g. step.llm({ id: "my-llm", ... }).',
-            });
-        }
-        // Only validate eager models here. Function-form models are validated
-        // post-resolution in executeLLM so the same MISSING_MODEL error surfaces
-        // whether the caller passes a string or a getter.
-        if (typeof opts.model === 'string' && opts.model.trim() === '') {
-            throw new NoeticConfigError({
-                code: 'MISSING_MODEL',
-                message: 'step.llm() requires a non-empty model.',
-                hint: "Pass a model identifier, e.g. model: 'anthropic/claude-sonnet-4-20250514'.",
-            });
-        }
-        const built = {
-            kind: 'llm',
-            ...opts,
-        };
-        getDefaultRegistrar().register(built);
-        return built;
-    },
-    /**
-     * Creates a tool execution step that invokes a typed tool definition.
-     *
-     * @public
-     * @param opts.id - Unique step identifier used in traces and error messages.
-     * @param opts.tool - The tool definition with typed input/output schemas.
-     * @param opts.args - Optional partial args that override or supplement LLM-provided arguments.
-     * @returns A `StepTool` that can be composed into larger pipelines. The step
-     *   is auto-registered in the shared step registry.
-     * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
-     * @throws `NoeticConfigError` with code `MISSING_TOOL` if `tool` is not provided.
-     */
-    tool(opts) {
-        if (!opts.id || opts.id.trim() === '') {
-            throw new NoeticConfigError({
-                code: 'EMPTY_STEP_ID',
-                message: 'step.tool() requires a non-empty id.',
-                hint: 'Pass a unique string as the id field, e.g. step.tool({ id: "my-tool", ... }).',
-            });
-        }
-        if (!opts.tool) {
-            throw new NoeticConfigError({
-                code: 'MISSING_TOOL',
-                message: 'step.tool() requires a tool.',
-                hint: 'Provide a tool definition created with the tool() builder.',
-            });
-        }
-        const built = {
-            kind: 'tool',
-            ...opts,
-        };
-        getDefaultRegistrar().register(built);
-        return built;
-    },
     /**
      * Creates a step that delegates a turn to the Claude Code harness.
      *

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

@@ -1,6 +1,5 @@
-import type { FunctionCallItem, FunctionCallOutputItem, Item, ItemSchemaExtensions, Tool, ToolContextDeclaration, ToolExecutionContext, ToolResultExtensionItem, ToolUiDeclaration } from '@noetic-tools/types';
-import type { ZodTypeAny, z } from 'zod';
-interface ToolConfig<I extends ZodTypeAny, O extends ZodTypeAny> {
+import type { FunctionCallItem, FunctionCallOutputItem, InferSchemaOutput, InputSchemaConfig, Item, ItemSchemaExtensions, StandardSchemaV1, Tool, ToolContextDeclaration, ToolExecutionContext, ToolResultExtensionItem, ToolUiDeclaration } from '@noetic-tools/types';
+type ToolConfig<I extends StandardSchemaV1, O extends StandardSchemaV1> = {
     name: string;
     description: string;
     input: I;
@@ -9,21 +8,19 @@ interface ToolConfig<I extends ZodTypeAny, O extends ZodTypeAny> {
     decorateResultItem?: (params: {
         baseItem: FunctionCallOutputItem;
         callItem: FunctionCallItem;
-        args: z.infer<I>;
-        result: z.infer<O> | undefined;
+        args: InferSchemaOutput<I>;
+        result: InferSchemaOutput<O> | undefined;
         output: string;
         error?: boolean;
     }) => Item | ToolResultExtensionItem;
-    execute: (args: z.infer<I>, toolCtx: ToolExecutionContext) => Promise<z.infer<O>>;
+    execute: (args: InferSchemaOutput<I>, toolCtx: ToolExecutionContext) => Promise<InferSchemaOutput<O>>;
     needsApproval?: boolean;
-    /** Optional context declaration — the runtime generates a ContextLayer from this via toolContextLayer(). */
+    /** Optional context declaration — the runtime generates a ContextLayer from this via toolCalls(). */
     context?: ToolContextDeclaration;
-    /** @deprecated Renamed to `context`. */
-    memory?: ToolContextDeclaration;
     /** Optional UI declaration — the runtime emits the rendered fragments at call/progress/result points. */
     ui?: ToolUiDeclaration<I, O>;
-}
-interface GeneratorToolConfig<I extends ZodTypeAny, E extends ZodTypeAny, O extends ZodTypeAny> {
+} & InputSchemaConfig<I>;
+type GeneratorToolConfig<I extends StandardSchemaV1, E extends StandardSchemaV1, O extends StandardSchemaV1> = {
     name: string;
     description: string;
     input: I;
@@ -33,30 +30,29 @@ interface GeneratorToolConfig<I extends ZodTypeAny, E extends ZodTypeAny, O exte
     decorateResultItem?: (params: {
         baseItem: FunctionCallOutputItem;
         callItem: FunctionCallItem;
-        args: z.infer<I>;
-        result: z.infer<O> | undefined;
+        args: InferSchemaOutput<I>;
+        result: InferSchemaOutput<O> | undefined;
         output: string;
         error?: boolean;
     }) => Item | ToolResultExtensionItem;
-    execute: (args: z.infer<I>, toolCtx: ToolExecutionContext) => AsyncGenerator<z.infer<E>, z.infer<O>>;
+    execute: (args: InferSchemaOutput<I>, toolCtx: ToolExecutionContext) => AsyncGenerator<InferSchemaOutput<E>, InferSchemaOutput<O>>;
     needsApproval?: boolean;
-    /** Optional context declaration — the runtime generates a ContextLayer from this via toolContextLayer(). */
+    /** Optional context declaration — the runtime generates a ContextLayer from this via toolCalls(). */
     context?: ToolContextDeclaration;
-    /** @deprecated Renamed to `context`. */
-    memory?: ToolContextDeclaration;
     /** Optional UI declaration — the runtime emits the rendered fragments at call/progress/result points. */
-    ui?: ToolUiDeclaration<I, O, z.infer<E>>;
-}
+    ui?: ToolUiDeclaration<I, O, InferSchemaOutput<E>>;
+} & InputSchemaConfig<I>;
 /**
- * Creates a typed Tool with Zod schema inference for input and output.
+ * Creates a typed Tool with Standard Schema inference for input and output.
+ * Accepts Zod, Valibot, or any Standard Schema v1 implementation.
  *
  * @public
  */
-export declare function tool<I extends ZodTypeAny, O extends ZodTypeAny>(config: ToolConfig<I, O>): Tool<I, O>;
+export declare function tool<I extends StandardSchemaV1, O extends StandardSchemaV1>(config: ToolConfig<I, O>): Tool<I, O>;
 /**
  * Creates a typed Tool that can stream progress events before returning a final output.
  *
  * @public
  */
-export declare function toolWithGenerator<I extends ZodTypeAny, E extends ZodTypeAny, O extends ZodTypeAny>(config: GeneratorToolConfig<I, E, O>): Tool<I, O>;
+export declare function toolWithGenerator<I extends StandardSchemaV1, E extends StandardSchemaV1, O extends StandardSchemaV1>(config: GeneratorToolConfig<I, E, O>): Tool<I, O>;
 export {};

package/dist/builders/tool-builder.js

@@ -1,5 +1,4 @@
 import { NoeticConfigError } from '@noetic-tools/types';
-import { resolveContextOption } from './context-option.js';
 //#endregion
 //#region Helpers
 function validateToolConfig(name, execute) {
@@ -21,7 +20,8 @@ function validateToolConfig(name, execute) {
 //#endregion
 //#region Public API
 /**
- * Creates a typed Tool with Zod schema inference for input and output.
+ * Creates a typed Tool with Standard Schema inference for input and output.
+ * Accepts Zod, Valibot, or any Standard Schema v1 implementation.
  *
  * @public
  */
@@ -32,11 +32,12 @@ export function tool(config) {
         description: config.description,
         input: config.input,
         output: config.output,
+        inputJsonSchema: config.inputJsonSchema,
         itemSchemas: config.itemSchemas,
         decorateResultItem: config.decorateResultItem,
         execute: config.execute,
         needsApproval: config.needsApproval,
-        context: resolveContextOption(config),
+        context: config.context,
         ui: config.ui,
     };
 }
@@ -53,11 +54,12 @@ export function toolWithGenerator(config) {
         input: config.input,
         event: config.event,
         output: config.output,
+        inputJsonSchema: config.inputJsonSchema,
         itemSchemas: config.itemSchemas,
         decorateResultItem: config.decorateResultItem,
         execute: config.execute,
         needsApproval: config.needsApproval,
-        context: resolveContextOption(config),
+        context: config.context,
         ui: config.ui,
     };
 }

package/dist/builders/workflow-hydrator.d.ts

@@ -1,7 +1,7 @@
 /**
  * Converts a validated `WorkflowDocument` into a live `Step` tree.
  *
- * Each node kind maps to the corresponding builder (`step.llm`, `fork`,
+ * Each node kind maps to the corresponding builder (`callModel`, `inParallel`,
  * `loop`, etc.) so hydrated steps are indistinguishable from programmatic
  * ones — they register in the step registry, carry retry policies, etc.
  */
@@ -16,14 +16,14 @@ export interface HydrationContext {
     /** SubHarness adapters keyed by harness id, resolving `claude-code`/`codex`/… nodes. */
     subHarnesses?: ReadonlyMap<SubHarnessKind, SubHarness>;
     /**
-     * Output codecs keyed by the `library` ref an `llm` node's `output` codec
+     * Output codecs keyed by the `library` ref a `callModel` node's `output` codec
      * reference names — the live codec built from a component library, e.g.
      * `new Map([['dashboard-lib', openUi(dashboardLibrary)]])` from
      * `@noetic-tools/openui`. Resolved the same way sub-harness adapters are.
      */
     uiLibraries?: ReadonlyMap<string, OutputCodec>;
     /**
-     * Resolves a named subprocess adapter ref declared on a `run` node's
+     * Resolves a named subprocess adapter ref declared on a `runCode` node's
      * `subprocess` field. When a node omits the ref, the step falls back to
      * `ctx.subprocess` at execution time.
      */