@noetic-tools/core 0.0.1 → 0.1.0

package/dist/memory/layers/working-memory.js

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { layerData, layerFn } from '../../builders/layer-provides-builders';
-import { createMessage, estimateTokens } from '../../interpreter/message-helpers';
 import { Slot } from '../../types/memory';
+import { createMessage, estimateTokens } from '../../util/message-helpers';
 import { findFunctionCall } from '../function-call-utils';
+import { layerData, layerFn } from '../layer-provides';
 function safeMerge(state, args) {
     const { __proto__: _p, constructor: _c, ...safeArgs } = args;
     if (typeof state === 'object' && state !== null) {

package/dist/patterns/dynamic-workflow.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Pattern that lets an LLM generate a workflow as JSON during execution,
+ * then hydrates and runs it within the same harness session.
+ */
+import type { Context } from '../types/context';
+import type { ContextMemory } from '../types/memory';
+import type { AgentHarnessContract } from '../types/runtime';
+import type { Step } from '../types/step';
+import type { Tool } from '../types/tool';
+/** @public Options for creating a dynamic workflow step. */
+export interface DynamicWorkflowOpts {
+    model?: string;
+    instructions?: string;
+    tools: Tool[];
+    maxDepth?: number;
+    maxRevisions?: number;
+}
+/**
+ * Creates a step that uses an LLM to generate a workflow as JSON, then
+ * hydrates and executes it. The entire plan-and-execute cycle happens
+ * within a single harness run.
+ *
+ * @public
+ * @param opts.model - Model for the planner LLM. Default: `openai/gpt-4o`.
+ * @param opts.instructions - Additional instructions prepended to the planner prompt.
+ * @param opts.tools - Tools the generated workflow may reference by name.
+ * @param opts.maxDepth - Maximum workflow tree depth. Default: 5.
+ * @param opts.maxRevisions - Retries with error feedback on validation failure. Default: 3.
+ * @returns A `Step` that dynamically plans and executes.
+ */
+export declare function dynamicWorkflow(opts: DynamicWorkflowOpts): Step<ContextMemory, string, string>;
+/** @public Options for `parseAndRunWorkflow`. */
+export interface ParseAndRunWorkflowOpts {
+    json: unknown;
+    harness: AgentHarnessContract;
+    ctx: Context;
+    tools: Tool[];
+    input?: string;
+    maxDepth?: number;
+}
+/**
+ * Parses raw JSON into a `WorkflowDocument`, hydrates it into a live step
+ * tree, and executes it via the harness.
+ *
+ * @public
+ * @param opts.json - Raw JSON (string or parsed object) representing a workflow.
+ * @param opts.harness - The agent harness to execute the workflow with.
+ * @param opts.ctx - Execution context.
+ * @param opts.tools - Available tools the workflow may reference.
+ * @param opts.maxDepth - Maximum workflow tree depth. Default: 5.
+ * @returns The string output of the executed workflow.
+ * @throws `NoeticConfigError` with code `WORKFLOW_VALIDATION_FAILED` if JSON is invalid.
+ * @throws `NoeticConfigError` with code `UNKNOWN_TOOL_REFERENCE` if a tool reference cannot be resolved.
+ */
+export declare function parseAndRunWorkflow(opts: ParseAndRunWorkflowOpts): Promise<string>;

package/dist/patterns/dynamic-workflow.js

@@ -0,0 +1,194 @@
+/**
+ * Pattern that lets an LLM generate a workflow as JSON during execution,
+ * then hydrates and runs it within the same harness session.
+ */
+import { step } from '../builders/step-builders';
+import { hydrateWorkflow } from '../builders/workflow-hydrator';
+import { NoeticConfigError } from '../errors/noetic-config-error';
+import { WorkflowDocumentSchema, workflowDepth } from '../schemas/workflow';
+import { frameworkCast } from '../util/framework-cast';
+//#endregion
+//#region Constants
+const DEFAULT_MAX_DEPTH = 5;
+const DEFAULT_MAX_REVISIONS = 3;
+const DEFAULT_MODEL = 'openai/gpt-4o';
+const PLANNER_INSTRUCTIONS = `You are a workflow planner. Given a task, generate a JSON workflow document that describes how to accomplish it.
+
+The workflow document must be valid JSON with this structure:
+{
+  "version": 1,
+  "root": <WorkflowNode>
+}
+
+A WorkflowNode is one of:
+- { "kind": "llm", "id": "<unique>", "instructions": "<prompt>", "model": "<optional>", "tools": ["<tool-name>", ...] }
+- { "kind": "tool", "id": "<unique>", "toolName": "<name>", "args": { ... } }
+- { "kind": "sequence", "id": "<unique>", "steps": [<WorkflowNode>, ...] }
+- { "kind": "fork", "id": "<unique>", "mode": "all"|"race"|"settle", "paths": [<WorkflowNode>, ...], "merge": "last"|"first"|"concat" }
+- { "kind": "loop", "id": "<unique>", "body": <WorkflowNode>, "until": { "kind": "maxSteps", "n": <number> } }
+- { "kind": "branch", "id": "<unique>", "routes": [{ "match": "<substring>", "target": <WorkflowNode> }], "default": <WorkflowNode> }
+- { "kind": "spawn", "id": "<unique>", "child": <WorkflowNode> }
+
+Until predicates: maxSteps, maxCost, maxDuration, noToolCalls, outputContains, outputEquals, converged, any, all.
+
+Respond with ONLY the JSON document, no markdown fences or explanation.`;
+//#endregion
+//#region Public API
+/**
+ * Creates a step that uses an LLM to generate a workflow as JSON, then
+ * hydrates and executes it. The entire plan-and-execute cycle happens
+ * within a single harness run.
+ *
+ * @public
+ * @param opts.model - Model for the planner LLM. Default: `openai/gpt-4o`.
+ * @param opts.instructions - Additional instructions prepended to the planner prompt.
+ * @param opts.tools - Tools the generated workflow may reference by name.
+ * @param opts.maxDepth - Maximum workflow tree depth. Default: 5.
+ * @param opts.maxRevisions - Retries with error feedback on validation failure. Default: 3.
+ * @returns A `Step` that dynamically plans and executes.
+ */
+export function dynamicWorkflow(opts) {
+    const model = opts.model ?? DEFAULT_MODEL;
+    const maxDepth = opts.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const maxRevisions = opts.maxRevisions ?? DEFAULT_MAX_REVISIONS;
+    const toolMap = buildToolMap(opts.tools);
+    return step.run({
+        id: 'dynamic-workflow',
+        execute: async (input, ctx) => {
+            const harness = ctx.harness;
+            if (!harness) {
+                throw new NoeticConfigError({
+                    code: 'MISSING_HARNESS_CONTEXT',
+                    message: 'dynamicWorkflow requires a harness on the execution context.',
+                    hint: 'Execute this step via AgentHarness.run() or ensure ctx.harness is set.',
+                });
+            }
+            const toolList = opts.tools.map((t) => `- ${t.name}: ${t.description}`).join('\n');
+            const basePrompt = [
+                opts.instructions,
+                PLANNER_INSTRUCTIONS,
+                `\nAvailable tools:\n${toolList}`,
+                `\nTask: ${input}`,
+            ]
+                .filter(Boolean)
+                .join('\n\n');
+            let lastError;
+            for (let revision = 0; revision < maxRevisions; revision++) {
+                const prompt = lastError
+                    ? `${basePrompt}\n\nPrevious attempt failed with error: ${lastError}\nPlease fix the workflow and try again.`
+                    : basePrompt;
+                const plannerStep = step.llm({
+                    id: `dynamic-workflow-planner-${revision}`,
+                    model,
+                    instructions: prompt,
+                });
+                const executeStep = frameworkCast(harness.run.bind(harness));
+                const rawOutput = await executeStep(plannerStep, input, ctx);
+                const text = coerceToString(rawOutput);
+                const parseResult = tryParseWorkflow(text, maxDepth);
+                if (!parseResult.ok) {
+                    lastError = parseResult.error;
+                    if (revision === maxRevisions - 1) {
+                        throw new NoeticConfigError({
+                            code: 'WORKFLOW_VALIDATION_FAILED',
+                            message: `Failed to generate valid workflow after ${maxRevisions} attempts: ${lastError}`,
+                            hint: 'The planner model may need clearer instructions or a more capable model.',
+                        });
+                    }
+                    continue;
+                }
+                const hydrationCtx = {
+                    tools: toolMap,
+                    executeStep,
+                };
+                const hydrated = hydrateWorkflow(parseResult.doc, hydrationCtx);
+                return frameworkCast(await executeStep(hydrated, input, ctx));
+            }
+            throw new NoeticConfigError({
+                code: 'WORKFLOW_VALIDATION_FAILED',
+                message: `Failed to generate valid workflow after ${maxRevisions} attempts.`,
+                hint: 'The planner model may need clearer instructions or a more capable model.',
+            });
+        },
+    });
+}
+/**
+ * Parses raw JSON into a `WorkflowDocument`, hydrates it into a live step
+ * tree, and executes it via the harness.
+ *
+ * @public
+ * @param opts.json - Raw JSON (string or parsed object) representing a workflow.
+ * @param opts.harness - The agent harness to execute the workflow with.
+ * @param opts.ctx - Execution context.
+ * @param opts.tools - Available tools the workflow may reference.
+ * @param opts.maxDepth - Maximum workflow tree depth. Default: 5.
+ * @returns The string output of the executed workflow.
+ * @throws `NoeticConfigError` with code `WORKFLOW_VALIDATION_FAILED` if JSON is invalid.
+ * @throws `NoeticConfigError` with code `UNKNOWN_TOOL_REFERENCE` if a tool reference cannot be resolved.
+ */
+export async function parseAndRunWorkflow(opts) {
+    const parseResult = tryParseWorkflow(opts.json, opts.maxDepth ?? DEFAULT_MAX_DEPTH);
+    if (!parseResult.ok) {
+        throw new NoeticConfigError({
+            code: 'WORKFLOW_VALIDATION_FAILED',
+            message: `Invalid workflow document: ${parseResult.error}`,
+            hint: 'Ensure the JSON matches the WorkflowDocumentSchema.',
+        });
+    }
+    const executeStep = frameworkCast(opts.harness.run.bind(opts.harness));
+    const hydrationCtx = {
+        tools: buildToolMap(opts.tools),
+        executeStep,
+    };
+    const hydrated = hydrateWorkflow(parseResult.doc, hydrationCtx);
+    const result = await executeStep(hydrated, opts.input ?? '', opts.ctx);
+    return coerceToString(result);
+}
+function buildToolMap(tools) {
+    return new Map(tools.map((t) => [
+        t.name,
+        t,
+    ]));
+}
+function coerceToString(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    return String(value ?? '');
+}
+function tryParseWorkflow(raw, maxDepth) {
+    const parsed = typeof raw === 'string' ? safeParse(raw) : raw;
+    if (parsed === null) {
+        return {
+            ok: false,
+            error: 'Input is not valid JSON.',
+        };
+    }
+    const result = WorkflowDocumentSchema.safeParse(parsed);
+    if (!result.success) {
+        return {
+            ok: false,
+            error: result.error.message,
+        };
+    }
+    const depth = workflowDepth(result.data.root);
+    if (depth > maxDepth) {
+        return {
+            ok: false,
+            error: `Workflow tree depth ${depth} exceeds maximum ${maxDepth}.`,
+        };
+    }
+    return {
+        ok: true,
+        doc: result.data,
+    };
+}
+function safeParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+//#endregion

package/dist/patterns/flow.d.ts

@@ -1,52 +1,2 @@
-/**
- * Zod schema for plan-mode flow JSON.
- *
- * A "flow" is a JSON-serialisable subset of noetic's `Step` shape that the model
- * may emit during plan mode. The runtime expands each node into a concrete `Step`
- * via the existing builders (`step.llm`, `fork`, `spawn`) at execute time.
- *
- * Tool references inside `llm` nodes are name strings — they get resolved against
- * the harness's live tool registry when the flow runs.
- */
-import { z } from 'zod';
-interface NodeBase {
-    id: string;
-    subPlanRef?: string;
-}
-export interface LlmFlowNode extends NodeBase {
-    kind: 'llm';
-    model?: string;
-    instructions: string;
-    tools?: string[];
-}
-export interface SubagentFlowNode extends NodeBase {
-    kind: 'subagent';
-    preset: string;
-    prompt: string;
-}
-export interface ForkFlowNode extends NodeBase {
-    kind: 'fork';
-    mode: 'all' | 'race' | 'settle';
-    paths: FlowNode[];
-}
-export interface SpawnFlowNode extends NodeBase {
-    kind: 'spawn';
-    child: FlowNode;
-}
-export interface SequenceFlowNode extends NodeBase {
-    kind: 'sequence';
-    steps: FlowNode[];
-}
-export type FlowNode = LlmFlowNode | SubagentFlowNode | ForkFlowNode | SpawnFlowNode | SequenceFlowNode;
-/** Top-level flow document — a single root node. */
-export declare const FlowSchema: z.ZodType<FlowNode, unknown, z.core.$ZodTypeInternals<FlowNode, unknown>>;
-/** Validates a candidate flow document. Throws `ZodError` on invalid input. */
-export declare function validateFlow(input: unknown): FlowNode;
-/** Walks a flow tree depth-first, yielding each node. */
-export declare function walkFlow(root: FlowNode): Iterable<FlowNode>;
-/**
- * Returns the maximum depth of a flow tree. A leaf (llm/subagent) is depth 0.
- * Structural nodes (sequence/fork/spawn) contribute +1 over their deepest child.
- */
-export declare function flowDepth(node: FlowNode): number;
-export {};
+export type { FlowNode, ForkFlowNode, LlmFlowNode, SequenceFlowNode, SpawnFlowNode, SubagentFlowNode, } from '../memory/flow-schema';
+export { FlowSchema, flowDepth, validateFlow, walkFlow } from '../memory/flow-schema';

package/dist/patterns/flow.js

@@ -1,103 +1 @@
-/**
- * Zod schema for plan-mode flow JSON.
- *
- * A "flow" is a JSON-serialisable subset of noetic's `Step` shape that the model
- * may emit during plan mode. The runtime expands each node into a concrete `Step`
- * via the existing builders (`step.llm`, `fork`, `spawn`) at execute time.
- *
- * Tool references inside `llm` nodes are name strings — they get resolved against
- * the harness's live tool registry when the flow runs.
- */
-import { z } from 'zod';
-//#endregion
-//#region Schema
-const FlowNodeRef = z.lazy(() => FlowNodeSchema);
-const SHARED_FIELDS = {
-    id: z.string().min(1),
-    subPlanRef: z.string().optional(),
-};
-const LlmNodeSchema = z.object({
-    kind: z.literal('llm'),
-    ...SHARED_FIELDS,
-    model: z.string().optional(),
-    instructions: z.string(),
-    tools: z.array(z.string()).optional(),
-});
-const SubagentNodeSchema = z.object({
-    kind: z.literal('subagent'),
-    ...SHARED_FIELDS,
-    preset: z.string().min(1),
-    prompt: z.string(),
-});
-const ForkNodeSchema = z.object({
-    kind: z.literal('fork'),
-    ...SHARED_FIELDS,
-    mode: z.enum([
-        'all',
-        'race',
-        'settle',
-    ]),
-    paths: z.array(FlowNodeRef).min(1),
-});
-const SpawnNodeSchema = z.object({
-    kind: z.literal('spawn'),
-    ...SHARED_FIELDS,
-    child: FlowNodeRef,
-});
-const SequenceNodeSchema = z.object({
-    kind: z.literal('sequence'),
-    ...SHARED_FIELDS,
-    steps: z.array(FlowNodeRef).min(1),
-});
-const FlowNodeSchema = z.discriminatedUnion('kind', [
-    LlmNodeSchema,
-    SubagentNodeSchema,
-    ForkNodeSchema,
-    SpawnNodeSchema,
-    SequenceNodeSchema,
-]);
-/** Top-level flow document — a single root node. */
-export const FlowSchema = FlowNodeSchema;
-//#endregion
-//#region Public API
-/** Validates a candidate flow document. Throws `ZodError` on invalid input. */
-export function validateFlow(input) {
-    return FlowSchema.parse(input);
-}
-/** Walks a flow tree depth-first, yielding each node. */
-export function* walkFlow(root) {
-    yield root;
-    if (root.kind === 'fork') {
-        for (const path of root.paths) {
-            yield* walkFlow(path);
-        }
-        return;
-    }
-    if (root.kind === 'sequence') {
-        for (const step of root.steps) {
-            yield* walkFlow(step);
-        }
-        return;
-    }
-    if (root.kind === 'spawn') {
-        yield* walkFlow(root.child);
-        return;
-    }
-}
-/**
- * Returns the maximum depth of a flow tree. A leaf (llm/subagent) is depth 0.
- * Structural nodes (sequence/fork/spawn) contribute +1 over their deepest child.
- */
-export function flowDepth(node) {
-    if (node.kind === 'sequence') {
-        return 1 + Math.max(0, ...node.steps.map(flowDepth));
-    }
-    if (node.kind === 'fork') {
-        return 1 + Math.max(0, ...node.paths.map(flowDepth));
-    }
-    if (node.kind === 'spawn') {
-        return 1 + flowDepth(node.child);
-    }
-    return 0;
-}
-//#endregion
+export { FlowSchema, flowDepth, validateFlow, walkFlow } from '../memory/flow-schema';

package/dist/patterns/interview.js

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { loop } from '../builders/loop-builder';
 import { step } from '../builders/step-builders';
-import { frameworkCast } from '../interpreter/framework-cast';
 import { any } from '../until/combinators';
 import { until } from '../until/predicates';
+import { frameworkCast } from '../util/framework-cast';
 //#endregion
 //#region Helpers
 const DEFAULT_MAX_QUESTIONS = 8;

package/dist/patterns/plans.d.ts

@@ -27,7 +27,7 @@ export interface PlanConstraints {
  * @param executeStep - Optional step executor for non-run step kinds.
  * @returns A compiled `Step` ready for execution.
  */
-export declare function compilePlan<O>(plan: PlanNode, agents: Record<string, (prompt: string) => Step<ContextMemory, string, unknown>>, constraints?: PlanConstraints, executeStep?: ExecuteStepFn): Step<ContextMemory, string, O>;
+export declare function compilePlan<O, A = unknown>(plan: PlanNode, agents: Record<string, (prompt: string) => Step<ContextMemory, string, A>>, constraints?: PlanConstraints, executeStep?: ExecuteStepFn): Step<ContextMemory, string, O>;
 /**
  * Creates a step that dynamically generates a plan via a planner step and executes it,
  * retrying with error feedback up to `maxRevisions` times on failure.
@@ -36,9 +36,9 @@ export declare function compilePlan<O>(plan: PlanNode, agents: Record<string, (p
  * @param opts - Planner step, agent factories, optional constraints, max revision count, and step executor.
  * @returns A `Step` that adaptively plans and executes.
  */
-export declare function adaptivePlan<O>(opts: {
+export declare function adaptivePlan<O, A = unknown>(opts: {
     planner: Step<ContextMemory, string, PlanNode>;
-    agents: Record<string, (prompt: string) => Step<ContextMemory, string, unknown>>;
+    agents: Record<string, (prompt: string) => Step<ContextMemory, string, A>>;
     constraints?: PlanConstraints;
     maxRevisions: number;
     executeStep?: ExecuteStepFn;

package/dist/patterns/plans.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { fork } from '../builders/control-flow-builders';
-import { frameworkCast } from '../interpreter/framework-cast';
+import { frameworkCast } from '../util/framework-cast';
 // PlanNode schema — the variable annotation provides the recursive type;
 // z.lazy() returns a compatible type that TypeScript checks against it.
 /** @public Zod schema for recursive `PlanNode` validation. */
@@ -47,7 +47,7 @@ function compileNode(node, opts) {
             id: `plan-fork-${node.id}`,
             mode: 'all',
             paths: () => childSteps,
-            merge: (results) => results[results.length - 1],
+            merge: (results) => frameworkCast(results[results.length - 1]),
         });
     }
     // Sequential - chain steps via a run step that uses executeStep
@@ -68,7 +68,7 @@ function compileNode(node, opts) {
                     throw new Error(`No executeStep provided and child step kind '${child.kind}' cannot be executed directly`);
                 }
             }
-            return currentOutput;
+            return frameworkCast(currentOutput);
         },
     };
 }

package/dist/patterns/ralph-wiggum.d.ts

@@ -1,6 +1,6 @@
-import type { Tool } from '../types/common';
 import type { ContextMemory } from '../types/memory';
 import type { StepLoop } from '../types/step';
+import type { Tool } from '../types/tool';
 import type { VerifyFn } from '../until/predicates';
 /**
  * Creates a retry-with-feedback loop wrapping a ReAct agent. Each iteration spawns an inner agent

package/dist/patterns/react.d.ts

@@ -1,6 +1,6 @@
-import type { Tool } from '../types/common';
 import type { ContextMemory, MemoryConfig, MemoryLayer } from '../types/memory';
 import type { StepLoop, StepSpawn } from '../types/step';
+import type { Tool } from '../types/tool';
 /**
  * Creates a ReAct (Reason + Act) agent loop: an LLM step with tools iterated until no tool calls or limits are hit.
  *

package/dist/portable/adapters.d.ts

@@ -0,0 +1,6 @@
+/** @public */
+export { createInMemoryFsAdapter } from '../adapters/in-memory-fs-adapter';
+/** @public */
+export { createInMemoryShellAdapter } from '../adapters/in-memory-shell-adapter';
+/** @public */
+export { createInMemorySubprocessAdapter } from '../adapters/in-memory-subprocess-adapter';

package/dist/portable/adapters.js

@@ -0,0 +1,6 @@
+/** @public */
+export { createInMemoryFsAdapter } from '../adapters/in-memory-fs-adapter';
+/** @public */
+export { createInMemoryShellAdapter } from '../adapters/in-memory-shell-adapter';
+/** @public */
+export { createInMemorySubprocessAdapter } from '../adapters/in-memory-subprocess-adapter';

package/dist/portable/ask-user.d.ts

@@ -0,0 +1,4 @@
+/** @public */
+export type { AskUserAnnotation, AskUserInput, AskUserOption, AskUserOutput, AskUserQuestion, } from '../types/ask-user-types';
+/** @public */
+export { AskUserAnnotationSchema, AskUserInputSchema, AskUserOptionSchema, AskUserOutputSchema, AskUserQuestionSchema, } from '../types/ask-user-types';

package/dist/portable/ask-user.js

@@ -0,0 +1,2 @@
+/** @public */
+export { AskUserAnnotationSchema, AskUserInputSchema, AskUserOptionSchema, AskUserOutputSchema, AskUserQuestionSchema, } from '../types/ask-user-types';

package/dist/portable/builders.d.ts

@@ -0,0 +1,12 @@
+/** @public */
+export { branch, fork } from '../builders/control-flow-builders';
+/** @public */
+export { layerData, layerFn } from '../builders/layer-provides-builders';
+/** @public */
+export { loop } from '../builders/loop-builder';
+/** @public */
+export { spawn } from '../builders/spawn-builder';
+/** @public */
+export { step } from '../builders/step-builders';
+/** @public */
+export { tool, toolWithGenerator } from '../builders/tool-builder';

package/dist/portable/builders.js

@@ -0,0 +1,12 @@
+/** @public */
+export { branch, fork } from '../builders/control-flow-builders';
+/** @public */
+export { layerData, layerFn } from '../builders/layer-provides-builders';
+/** @public */
+export { loop } from '../builders/loop-builder';
+/** @public */
+export { spawn } from '../builders/spawn-builder';
+/** @public */
+export { step } from '../builders/step-builders';
+/** @public */
+export { tool, toolWithGenerator } from '../builders/tool-builder';

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

@@ -0,0 +1,12 @@
+/** @public */
+export { durableTaskState } from '../memory/layers/durable-task-state';
+/** @public */
+export { historyWindow } from '../memory/layers/history-window';
+/** @public */
+export { observationalMemory } from '../memory/layers/observational-memory';
+/** @public */
+export { planMemory } from '../memory/layers/plan';
+/** @public */
+export { toolMemoryLayer } from '../memory/layers/tool-memory-layer';
+/** @public */
+export { workingMemory } from '../memory/layers/working-memory';

package/dist/portable/memory-layers.js

@@ -0,0 +1,12 @@
+/** @public */
+export { durableTaskState } from '../memory/layers/durable-task-state';
+/** @public */
+export { historyWindow } from '../memory/layers/history-window';
+/** @public */
+export { observationalMemory } from '../memory/layers/observational-memory';
+/** @public */
+export { planMemory } from '../memory/layers/plan';
+/** @public */
+export { toolMemoryLayer } from '../memory/layers/tool-memory-layer';
+/** @public */
+export { workingMemory } from '../memory/layers/working-memory';

package/dist/portable/runtime.d.ts

@@ -0,0 +1,4 @@
+/** @public */
+export { AgentHarness } from '../harness/agent-harness';
+/** @public */
+export { createInMemoryStorage } from '../runtime/in-memory-storage';

package/dist/portable/runtime.js

@@ -0,0 +1,4 @@
+/** @public */
+export { AgentHarness } from '../harness/agent-harness';
+/** @public */
+export { createInMemoryStorage } from '../runtime/in-memory-storage';

package/dist/portable/until.d.ts

@@ -0,0 +1,4 @@
+/** @public */
+export { all, any } from '../until/combinators';
+/** @public */
+export { until } from '../until/predicates';

package/dist/portable/until.js

@@ -0,0 +1,4 @@
+/** @public */
+export { all, any } from '../until/combinators';
+/** @public */
+export { until } from '../until/predicates';

package/dist/portable.d.ts

@@ -1,26 +1,8 @@
-/** @public */
-export { createInMemoryFsAdapter } from './adapters/in-memory-fs-adapter';
-/** @public */
-export { createInMemoryShellAdapter } from './adapters/in-memory-shell-adapter';
-/** @public */
-export { createInMemorySubprocessAdapter } from './adapters/in-memory-subprocess-adapter';
-/** @public */
-export { step } from './builders/step-builders';
-/** @public */
-export { tool, toolWithGenerator } from './builders/tool-builder';
-/** @public */
-export { durableTaskState } from './memory/layers/durable-task-state';
-/** @public */
-export { historyWindow } from './memory/layers/history-window';
-/** @public */
-export { observationalMemory } from './memory/layers/observational-memory';
-/** @public */
-export { planMemory } from './memory/layers/plan';
-/** @public */
-export { toolMemoryLayer } from './memory/layers/tool-memory-layer';
-/** @public */
-export { workingMemory } from './memory/layers/working-memory';
-/** @public */
-export { AgentHarness } from './runtime/agent-harness';
-/** @public */
-export { createInMemoryStorage } from './runtime/in-memory-storage';
+export * from './portable/adapters';
+export * from './portable/ask-user';
+export * from './portable/builders';
+export * from './portable/memory-layers';
+export * from './portable/runtime';
+export * from './portable/until';
+/** @public */
+export { Slot } from './types/memory';