@noetic-tools/core 2.0.0 → 2.2.0

package/dist/adapters/openrouter.d.ts

@@ -43,6 +43,8 @@ export interface ExecuteToolCallParams {
     context: Context;
     harness: AgentHarnessContract;
     layers?: MemoryLayer[];
+    /** The model's `function_call` id — keys this call's tool-UI region. */
+    callId?: string;
 }
 /** @internal Execute a single tool call with steering checks. */
 export declare function executeToolCall(params: ExecuteToolCallParams): Promise<{

package/dist/adapters/openrouter.js

@@ -1,6 +1,7 @@
 import { frameworkCast, isAssistantMessage, NoeticConfigError, SteeringAction, } from '@noetic-tools/types';
 import { z } from 'zod';
 import { buildToolExecutionContext } from '../runtime/tool-memory.js';
+import { emitToolUi } from '../runtime/tool-ui.js';
 const EmbeddingsResponseSchema = z.object({
     data: z.array(z.object({
         embedding: z.array(z.number()),
@@ -204,17 +205,6 @@ function isAsyncGenerator(value) {
     }
     return Symbol.asyncIterator in value;
 }
-async function consumeGenerator(generator) {
-    let result;
-    while (true) {
-        const next = await generator.next();
-        if (next.done) {
-            result = next.value;
-            break;
-        }
-    }
-    return result;
-}
 /** @internal Execute a single tool call with steering checks. */
 export async function executeToolCall(params) {
     // Model sees sanitised tool names (see `sanitizeToolNameForWire`). Match
@@ -245,18 +235,67 @@ export async function executeToolCall(params) {
         }
     }
     const toolCtx = buildToolExecutionContext(params.context, params.harness);
+    const callId = params.callId;
+    const uiBase = callId !== undefined
+        ? {
+            ctx: params.context,
+            tool: matchedTool,
+            callId,
+            args: params.args,
+        }
+        : undefined;
+    if (uiBase) {
+        emitToolUi({
+            ...uiBase,
+            phase: 'call',
+        });
+    }
     try {
         const executionResult = matchedTool.execute(params.args, toolCtx);
-        // Handle generator-based tools (like Bash) that return AsyncGenerator
-        const result = isAsyncGenerator(executionResult)
-            ? await consumeGenerator(executionResult)
-            : await executionResult;
+        // Generator tools stream progress; drive them here so tool-UI `progress`
+        // fragments emit per yield (the non-UI case just consumes to the return).
+        let result;
+        if (isAsyncGenerator(executionResult)) {
+            const events = [];
+            for (;;) {
+                const next = await executionResult.next();
+                if (next.done) {
+                    result = next.value;
+                    break;
+                }
+                events.push(next.value);
+                if (uiBase) {
+                    emitToolUi({
+                        ...uiBase,
+                        phase: 'progress',
+                        events,
+                    });
+                }
+            }
+        }
+        else {
+            result = await executionResult;
+        }
+        if (uiBase) {
+            emitToolUi({
+                ...uiBase,
+                phase: 'result',
+                output: result,
+            });
+        }
         return {
             output: typeof result === 'string' ? result : JSON.stringify(result),
             result,
         };
     }
     catch (e) {
+        if (uiBase) {
+            emitToolUi({
+                ...uiBase,
+                phase: 'error',
+                error: e,
+            });
+        }
         return {
             output: `Error: ${e instanceof Error ? e.message : String(e)}`,
             error: true,

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

@@ -1,5 +1,5 @@
 import type { ContextMemory } from '@noetic-tools/memory';
-import type { Context, Lazy, ModelParams, RetryPolicy, StepLLM, StepRun, StepSubHarness, StepTool, SubHarness, SubHarnessSessionPolicy, SubHarnessSettings, SubprocessAdapter, Tool } from '@noetic-tools/types';
+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';
 interface StepRunOpts<TMemory, I, O> {
     id: string;
@@ -18,9 +18,14 @@ interface StepLLMOpts<TMemory, O> {
     model: Lazy<string, TMemory>;
     /** Optional instructions; eager string or `(ctx) => string | undefined` getter. */
     instructions?: Lazy<string | undefined, TMemory>;
-    /** Optional tools; eager array or `(ctx) => Tool[] | undefined` getter. */
-    tools?: Lazy<Tool[] | undefined, TMemory>;
-    output?: ZodType<O>;
+    /**
+     * Optional tools; eager array or `(ctx) => (...)[] | undefined` getter. Each
+     * entry is either a client `Tool` or an inline `ServerToolSpec` (an OpenRouter
+     * server tool the provider executes, e.g. web search/fetch).
+     */
+    tools?: Lazy<(Tool | ServerToolSpec)[] | undefined, TMemory>;
+    /** Structured output: a Zod schema or a streaming `OutputCodec` (e.g. OpenUI Lang). */
+    output?: ZodType<O> | OutputCodec<O>;
     params?: ModelParams;
     emit?: boolean | ((eventType: string, data: Record<string, unknown>) => boolean);
 }

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

@@ -6,7 +6,7 @@
  * ones — they register in the step registry, carry retry policies, etc.
  */
 import type { ContextMemory, MemoryLayer } from '@noetic-tools/memory';
-import type { ExecuteStepFn, Step, SubHarness, SubHarnessKind, Tool } from '@noetic-tools/types';
+import type { ExecuteStepFn, OutputCodec, Step, SubHarness, SubHarnessKind, SubprocessAdapter, Tool } from '@noetic-tools/types';
 import type { WorkflowDocument, WorkflowNode } from '../schemas/workflow.js';
 /** @public Context required to hydrate a JSON workflow into live steps. */
 export interface HydrationContext {
@@ -15,6 +15,19 @@ export interface HydrationContext {
     layers?: ReadonlyMap<string, MemoryLayer>;
     /** 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
+     * 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
+     * `subprocess` field. When a node omits the ref, the step falls back to
+     * `ctx.subprocess` at execution time.
+     */
+    resolveSubprocess?: (ref: string) => SubprocessAdapter | undefined;
 }
 /**
  * Hydrates a single `WorkflowNode` into a live `Step`.

package/dist/builders/workflow-hydrator.js

@@ -5,7 +5,8 @@
  * `loop`, etc.) so hydrated steps are indistinguishable from programmatic
  * ones — they register in the step registry, carry retry policies, etc.
  */
-import { frameworkCast, NoeticConfigError } from '@noetic-tools/types';
+import { frameworkCast, isServerToolSpec, NoeticConfigError } from '@noetic-tools/types';
+import { DetachedHandleImpl } from '../runtime/detached-handle.js';
 import { all, any } from '../until/combinators.js';
 import { until } from '../until/predicates.js';
 import { branch, fork } from './control-flow-builders.js';
@@ -48,17 +49,73 @@ function hydrateUntilPredicate(pred) {
 }
 //#endregion
 //#region Node Hydrators
+/**
+ * Resolve an llm node's `tools` entries into a combined client+server list.
+ *
+ * Every entry is `{ type, parameters? }`. A reserved `openrouter:*` literal is
+ * a SERVER tool (flows through unchanged); any other `type` is a CLIENT tool
+ * whose `type` is the registered tool NAME (resolved from the registry). Both
+ * kinds combine into one `tools` array; the interpreter partitions them again
+ * at execution.
+ */
+function resolveLlmTools(entries, registry) {
+    const toolNames = [];
+    const serverSpecs = [];
+    for (const entry of entries ?? []) {
+        if (isServerToolSpec(entry)) {
+            serverSpecs.push(entry);
+        }
+        else {
+            toolNames.push(entry.type);
+        }
+    }
+    return [
+        ...resolveTools(toolNames, registry),
+        ...serverSpecs,
+    ];
+}
 function hydrateLlmNode(node, ctx) {
     if (node.kind !== 'llm') {
         return frameworkCast(undefined);
     }
-    const resolvedTools = resolveTools(node.tools, ctx.tools);
+    const combined = resolveLlmTools(node.tools, ctx.tools);
     return step.llm({
         id: node.id,
         model: node.model ?? 'openai/gpt-4o',
         instructions: node.instructions,
-        tools: resolvedTools.length > 0 ? resolvedTools : undefined,
+        tools: combined.length > 0 ? combined : undefined,
         params: node.params,
+        output: resolveOutputCodec(node.output, node.id, ctx),
+    });
+}
+/**
+ * Resolve an `llm` node's `output` codec reference to a live `OutputCodec`.
+ *
+ * Hydrated steps are typed `<string, string>` (the JSON boundary erases output
+ * types), so the resolved codec is cast to the step's erased output type — the
+ * runtime still returns the codec's real value. This is the same erasure the
+ * rest of the hydrator applies via `frameworkCast`.
+ */
+function availableLibraries(ctx) {
+    if (!ctx.uiLibraries || ctx.uiLibraries.size === 0) {
+        return '(none)';
+    }
+    return [
+        ...ctx.uiLibraries.keys(),
+    ].join(', ');
+}
+function resolveOutputCodec(ref, nodeId, ctx) {
+    if (!ref) {
+        return undefined;
+    }
+    const codec = ctx.uiLibraries?.get(ref.library);
+    if (codec) {
+        return frameworkCast(codec);
+    }
+    throw new NoeticConfigError({
+        code: 'UNKNOWN_UI_LIBRARY_REFERENCE',
+        message: `UI library '${ref.library}' referenced in workflow node '${nodeId}' is not registered.`,
+        hint: `Pass output codecs via HydrationContext.uiLibraries, e.g. new Map([['${ref.library}', openUi(myLibrary)]]) from @noetic-tools/openui. Available: ${availableLibraries(ctx)}`,
     });
 }
 function hydrateToolNode(node, ctx) {
@@ -106,6 +163,31 @@ function hydrateToolNode(node, ctx) {
         },
     }));
 }
+function hydrateRunNode(node, ctx) {
+    if (node.kind !== 'run') {
+        return frameworkCast(undefined);
+    }
+    const code = node.execute;
+    const subprocessRef = node.subprocess;
+    return frameworkCast(step.run({
+        id: node.id,
+        retry: node.retry,
+        execute: async (input, execCtx) => {
+            const adapter = resolveSubprocessAdapter({
+                ref: subprocessRef,
+                hydrationCtx: ctx,
+                execCtx,
+                nodeId: node.id,
+            });
+            return runCodeViaSubprocess({
+                adapter,
+                nodeId: node.id,
+                code,
+                input: stringifyResult(input),
+            });
+        },
+    }));
+}
 function hydrateBranchNode(node, ctx) {
     if (node.kind !== 'branch') {
         return frameworkCast(undefined);
@@ -137,14 +219,33 @@ function hydrateForkNode(node, ctx) {
     if (node.kind !== 'fork') {
         return frameworkCast(undefined);
     }
-    const hydratedPaths = node.paths.map((p) => hydrateNode(p, ctx));
+    // Static fork: paths are known at hydration time and feed the optimizer.
+    // Dynamic fork (`each`): paths are produced per fork-input at runtime, one
+    // child per array item, so they cannot be pre-computed or optimized.
+    const dynamic = node.each !== undefined;
+    const eachTemplate = node.each;
+    const staticPaths = dynamic ? [] : (node.paths ?? []).map((p) => hydrateNode(p, ctx));
+    const pathsFactory = (input) => {
+        if (!dynamic || !eachTemplate) {
+            return staticPaths;
+        }
+        const items = selectArray(input, node.over, node.id);
+        return items.map((item, i) => buildPerItemStep({
+            forkId: node.id,
+            eachTemplate,
+            item,
+            index: i,
+            ctx,
+        }));
+    };
+    const optimizable = dynamic ? undefined : frameworkCast(staticPaths);
     if (node.mode === 'race') {
         return fork({
             id: node.id,
             mode: 'race',
-            paths: () => hydratedPaths,
+            paths: pathsFactory,
             concurrency: node.concurrency,
-            _optimizable: frameworkCast(hydratedPaths),
+            _optimizable: optimizable,
         });
     }
     const mergeFn = buildMerge(node.merge ?? 'last');
@@ -152,22 +253,22 @@ function hydrateForkNode(node, ctx) {
         return fork({
             id: node.id,
             mode: 'settle',
-            paths: () => hydratedPaths,
+            paths: pathsFactory,
             merge: (results) => {
                 const values = results.filter((r) => r.status === 'fulfilled').map((r) => r.value ?? '');
                 return mergeFn(values);
             },
             concurrency: node.concurrency,
-            _optimizable: frameworkCast(hydratedPaths),
+            _optimizable: optimizable,
         });
     }
     return fork({
         id: node.id,
         mode: 'all',
-        paths: () => hydratedPaths,
+        paths: pathsFactory,
         merge: mergeFn,
         concurrency: node.concurrency,
-        _optimizable: frameworkCast(hydratedPaths),
+        _optimizable: optimizable,
     });
 }
 function hydrateSpawnNode(node, ctx) {
@@ -281,6 +382,7 @@ function hydrateSubHarnessNode(node, ctx) {
 const NODE_HYDRATORS = {
     llm: hydrateLlmNode,
     tool: hydrateToolNode,
+    run: hydrateRunNode,
     branch: hydrateBranchNode,
     fork: hydrateForkNode,
     spawn: hydrateSpawnNode,
@@ -332,6 +434,148 @@ function stringifyResult(value) {
     return JSON.stringify(value);
 }
 //#endregion
+//#region Dynamic Fork Helpers
+/**
+ * Parses the fork input (a JSON string) and locates the array to fan out over.
+ * When `over` is set, reads that property off the parsed object; otherwise the
+ * parsed value itself must be an array.
+ */
+function selectArray(input, over, nodeId) {
+    let parsed;
+    try {
+        parsed = JSON.parse(input);
+    }
+    catch {
+        throw new NoeticConfigError({
+            code: 'INVALID_FORK_INPUT',
+            message: `Dynamic fork '${nodeId}' could not parse its input as JSON.`,
+            hint: 'A dynamic fork (with `each`) expects its input to be a JSON array (or a JSON object when `over` is set).',
+        });
+    }
+    const candidate = over === undefined ? parsed : frameworkCast(parsed)?.[over];
+    if (!Array.isArray(candidate)) {
+        throw new NoeticConfigError({
+            code: 'INVALID_FORK_INPUT',
+            message: `Dynamic fork '${nodeId}' did not resolve an array${over ? ` at key '${over}'` : ''}.`,
+            hint: over
+                ? `Ensure the input JSON object has an array at '${over}'.`
+                : 'Ensure the input is a JSON array, or set `over` to select an array property.',
+        });
+    }
+    return candidate;
+}
+/**
+ * Builds one fork path for a single dynamic-fork item. The item is injected as
+ * the body's input (forks pass the same fork-input to every path), and the
+ * template's node ids are suffixed with `-${i}` so each instantiation has
+ * unique ids for tracing and step-registry uniqueness.
+ */
+function buildPerItemStep(opts) {
+    const { forkId, eachTemplate, item, index, ctx } = opts;
+    const hydratedEach = hydrateNode(suffixNodeIds(eachTemplate, `-${index}`), ctx);
+    return frameworkCast(step.run({
+        id: `${forkId}-item-${index}`,
+        execute: async (_input, execCtx) => {
+            const itemInput = JSON.stringify(item);
+            return stringifyResult(await ctx.executeStep(hydratedEach, itemInput, execCtx));
+        },
+    }));
+}
+/** Keys whose values are opaque data bags, never child workflow nodes. */
+const NON_NODE_KEYS = new Set([
+    'args',
+    'params',
+    'parameters',
+]);
+/**
+ * Deep-clones a workflow node template, appending `suffix` to the `id` of every
+ * nested node so a per-item instantiation has globally-unique step ids.
+ */
+function suffixNodeIds(node, suffix) {
+    const clone = structuredClone(node);
+    const walk = (value) => {
+        if (!value || typeof value !== 'object') {
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                walk(entry);
+            }
+            return;
+        }
+        const record = frameworkCast(value);
+        if (typeof record.kind === 'string' && typeof record.id === 'string') {
+            record.id = `${record.id}${suffix}`;
+        }
+        for (const [key, child] of Object.entries(record)) {
+            if (NON_NODE_KEYS.has(key)) {
+                continue;
+            }
+            walk(child);
+        }
+    };
+    walk(clone);
+    return clone;
+}
+//#endregion
+//#region Run Node Helpers
+/**
+ * Resolves the subprocess adapter for a `run` node. When the node names an
+ * adapter ref, the host must supply a `resolveSubprocess` resolver; otherwise
+ * the step falls back to the harness adapter on the execution context.
+ */
+function resolveSubprocessAdapter(opts) {
+    const { ref, hydrationCtx, execCtx, nodeId } = opts;
+    if (ref === undefined) {
+        return execCtx.subprocess;
+    }
+    const resolved = hydrationCtx.resolveSubprocess?.(ref);
+    if (!resolved) {
+        throw new NoeticConfigError({
+            code: 'UNKNOWN_SUBPROCESS_REFERENCE',
+            message: `Subprocess adapter '${ref}' referenced in run node '${nodeId}' could not be resolved.`,
+            hint: 'Pass a `resolveSubprocess(ref)` mapping in the HydrationContext, or omit `subprocess` to use the harness default (ctx.subprocess).',
+        });
+    }
+    return resolved;
+}
+/**
+ * Dispatches a `run` node's code string through a subprocess adapter: ships the
+ * code plus the JSON-stringified input as a process request (input on stdin),
+ * waits for the handle to settle, and returns the captured stdout as the step
+ * output. A non-zero exit / failed handle surfaces as a thrown error.
+ *
+ * The code is never eval'd in-process (Cloudflare Workers forbid eval). The
+ * adapter owns running the code and capturing stdout into `handle.metadata.result`.
+ */
+async function runCodeViaSubprocess(opts) {
+    const { adapter, nodeId, code, input } = opts;
+    const request = {
+        kind: 'process',
+        command: 'node',
+        args: [
+            '-e',
+            code,
+        ],
+        stdin: input,
+        metadata: {
+            noeticRun: true,
+            stepId: nodeId,
+            code,
+            input,
+        },
+    };
+    const spawnPromise = adapter.spawn(request);
+    const handle = new DetachedHandleImpl({
+        id: `run-${nodeId}`,
+        stepId: nodeId,
+        adapter,
+        spawnPromise,
+    });
+    const result = await handle.await();
+    return stringifyResult(result);
+}
+//#endregion
 //#region Public API
 /**
  * Hydrates a single `WorkflowNode` into a live `Step`.

package/dist/harness/model-call.js

@@ -1,4 +1,5 @@
 import { frameworkCast, NoeticConfigError } from '@noetic-tools/types';
+import { serverTool } from '@openrouter/agent';
 import { z } from 'zod';
 import { convertTools, executeToolCall, extractOutputItems, extractSystemInstruction, extractUsage, itemsToInput, sanitizeToolNameForWire, } from '../adapters/openrouter.js';
 import { isFunctionCall } from '../interpreter/typeguards.js';
@@ -188,15 +189,29 @@ function prepareModelRequest(request, agentName) {
         .join('\n\n') || undefined;
     const broadcaster = getBroadcaster(request.ctx);
     const filteredTools = filterAllowedTools(request);
+    // Client (function) tools convert to SDK tool definitions; OpenRouter server
+    // tools (web_search/web_fetch) are wrapped via the SDK's `serverTool()` so
+    // its convertToolsToAPIFormat accepts them — a raw `{type}` entry crashes it.
+    // `parameters` keys stay camelCase: the SDK's outbound zod schema strips
+    // unknown keys, so snake_case would be silently dropped.
+    const clientSdkTools = filteredTools && filteredTools.length > 0
+        ? convertTools({
+            tools: filteredTools,
+        })
+        : [];
+    const serverSdkTools = (request._serverTools ?? []).map((s) => serverTool(frameworkCast({
+        type: s.type,
+        parameters: s.parameters,
+    })));
+    const sdkTools = [
+        ...clientSdkTools,
+        ...frameworkCast(serverSdkTools),
+    ];
     return {
         instructions,
         remaining,
         broadcaster,
-        sdkTools: filteredTools && filteredTools.length > 0
-            ? convertTools({
-                tools: filteredTools,
-            })
-            : undefined,
+        sdkTools: sdkTools.length > 0 ? sdkTools : undefined,
         emitIfAllowed(eventType, data) {
             if (!shouldEmit(request.emit, eventType, data)) {
                 return;
@@ -670,6 +685,7 @@ export class AgentHarnessModelCaller {
             context: request.ctx,
             harness: this.opts.harness,
             layers: request.layers,
+            callId: fc.callId,
         });
         // Owner-scoped result validation: a tool's `toolResults` schemas apply
         // only to that tool's own result items. Harness-level `opts.itemSchemas`

package/dist/index.d.ts

@@ -115,7 +115,9 @@ export { MergeStrategySchema, UntilPredicateSchema, validateWorkflow, WorkflowDo
 export type { Channel, ChannelHandle, ExternalChannel } from '@noetic-tools/types';
 /** @public */
 /** @public */
-export type { LLMResponse, LlmProviderConfig, ModelParams, RetryPolicy, StepMeta, TokenUsage, Tool, ToolMemoryDeclaration, } from '@noetic-tools/types';
+export type { LLMResponse, LlmProviderConfig, ModelParams, RetryPolicy, ServerToolSpec, StepMeta, TokenUsage, Tool, ToolMemoryDeclaration, } from '@noetic-tools/types';
+/** @public */
+export { isServerToolSpec } from '@noetic-tools/types';
 /** @public */
 /** @public */
 /** @public */

package/dist/index.js

@@ -98,6 +98,8 @@ export { defaultItemSchemaRegistry, ItemSchema, ItemSchemaRegistry } from '@noet
 /** @public */
 export { MergeStrategySchema, UntilPredicateSchema, validateWorkflow, WorkflowDocumentSchema, WorkflowNodeSchema, walkWorkflow, workflowDepth, } from './schemas/workflow.js';
 /** @public */
+export { isServerToolSpec } from '@noetic-tools/types';
+/** @public */
 export { getToolCwd, setToolCwd, snapshotCwdState } from './runtime/cwd-helpers.js';
 /** @public */
 export { DetachedStatus } from '@noetic-tools/types';

package/dist/interpreter/action-deps.d.ts

@@ -2,7 +2,7 @@ export type { LayerStateStore } from '@noetic-tools/memory';
 export { allocateBudgets, assembleView, commitLayerUsage, computeLayerUsage, contextToExecCtx, DEFAULT_PROJECTION, resolveLayerTools, returnLayers, spawnLayers, } from '@noetic-tools/memory';
 export type { ItemSchemaRegistry } from '@noetic-tools/types';
 export { defaultItemSchemaRegistry } from '@noetic-tools/types';
-export { emitFrameworkEvent, getBroadcaster } from '../runtime/broadcaster-utils.js';
+export { emitFrameworkEvent, getBroadcaster, shouldEmit } from '../runtime/broadcaster-utils.js';
 export { ContextImpl } from '../runtime/context-impl.js';
 export { snapshotCwdState } from '../runtime/cwd-helpers.js';
 export { buildToolExecutionContext } from '../runtime/tool-memory.js';

package/dist/interpreter/action-deps.js

@@ -1,6 +1,6 @@
 export { allocateBudgets, assembleView, commitLayerUsage, computeLayerUsage, contextToExecCtx, DEFAULT_PROJECTION, resolveLayerTools, returnLayers, spawnLayers, } from '@noetic-tools/memory';
 export { defaultItemSchemaRegistry } from '@noetic-tools/types';
-export { emitFrameworkEvent, getBroadcaster } from '../runtime/broadcaster-utils.js';
+export { emitFrameworkEvent, getBroadcaster, shouldEmit } from '../runtime/broadcaster-utils.js';
 export { ContextImpl } from '../runtime/context-impl.js';
 export { snapshotCwdState } from '../runtime/cwd-helpers.js';
 export { buildToolExecutionContext } from '../runtime/tool-memory.js';

package/dist/interpreter/action-types.d.ts

@@ -1,3 +1,3 @@
 export type { ContextMemory, ExecutionContext, MemoryConfig, MemoryLayer, } from '@noetic-tools/memory';
-export type { AgentHarnessContract, Context, ContextRerenderRequest, ExecuteStepFn, FunctionCallItem, Item, ProjectionPolicy, RecallLayerOutput, RetryPolicy, StepLLM, StepMeta, StepProvide, StepRun, StepSpawn, StepTool, Tool, } from '@noetic-tools/types';
-export { SteeringAction } from '@noetic-tools/types';
+export type { AgentHarnessContract, Context, ContextRerenderRequest, ExecuteStepFn, FunctionCallItem, Item, ProjectionPolicy, RecallLayerOutput, RetryPolicy, ServerToolSpec, StepLLM, StepMeta, StepProvide, StepRun, StepSpawn, StepTool, Tool, } from '@noetic-tools/types';
+export { isServerToolSpec, SteeringAction } from '@noetic-tools/types';

package/dist/interpreter/action-types.js

@@ -1 +1 @@
-export { SteeringAction } from '@noetic-tools/types';
+export { isServerToolSpec, SteeringAction } from '@noetic-tools/types';

package/dist/interpreter/collect-tools.js

@@ -1,4 +1,4 @@
-import { frameworkCast } from '@noetic-tools/types';
+import { frameworkCast, isServerToolSpec } from '@noetic-tools/types';
 /**
  * Recursively walks a step tree and collects all Tool instances
  * declared on LLM steps. Used to build the unified tool set
@@ -31,9 +31,14 @@ function walkStep(step, out) {
             // Skip function-form tools: they're resolved per execution from `ctx`
             // and cannot contribute to the pre-computed unified set. Consumers that
             // need those tools in the pool should register them via
-            // `AgentHarness.tools` instead.
+            // `AgentHarness.tools` instead. Inline server-tool specs (web search/
+            // fetch) are not client `Tool`s — they never enter the unified pool.
             if (Array.isArray(step.tools)) {
-                out.push(...step.tools);
+                for (const entry of step.tools) {
+                    if (!isServerToolSpec(entry)) {
+                        out.push(entry);
+                    }
+                }
             }
             return;
         case 'run':