@noetic-tools/core 0.0.1 → 0.1.0

package/dist/harness/agent-harness.js

@@ -0,0 +1,576 @@
+import { NoeticConfigError } from '../errors/noetic-config-error';
+import { SpanImpl } from '../observability/span-impl';
+import { NoopExporter } from '../observability/trace-exporter';
+import { ItemSchemaRegistry } from '../schemas/item';
+import { frameworkCast } from '../util/framework-cast';
+import { createInMemoryFsAdapter, createInMemoryShellAdapter, createInMemorySubprocessAdapter, OpenRouter, } from './deps/adapters';
+import { collectAllTools, deduplicateTools, dispatchStepThroughAdapter, execute, } from './deps/interpreter';
+import { afterModelCallLayers, assembleView, beforeToolCallLayers, contextToExecCtx, createLayerStateStore, disposeLayers, executeRerender, initLayers, projectHistoryLayers, recallLayers, resolveLayerBudgets, resolveLayerTools, runAppendPipeline, storeLayers, } from './deps/memory';
+import { buildItemStream, ChannelStore, ContextImpl, captureCheckpoint, createInMemoryStorage, filterReasoningStream, filterTextStream, restoreFromCheckpoint, SessionRunner, snapshotCwdState, } from './deps/runtime';
+import { SteeringAction } from './deps/types';
+import { AgentHarnessModelCaller } from './model-call';
+export { createStreamIdleWatchdog } from './model-call';
+import { buildItemSchemaRegistry } from './model-schema';
+//#endregion
+const DEFAULT_THREAD_ID = '__default__';
+/** Default idle-timeout for a single model call's streaming response. Chosen to be
+ *  long enough that slow models aren't falsely aborted, but short enough that a
+ *  stalled SSE becomes a visible error rather than a silent hang. */
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 120e3;
+//#region Helpers
+/**
+ * Pick the right `cwdState` for a new Context.
+ *
+ * - `cwdInit` explicitly overrides everything (worktree isolation).
+ * - Parent snapshot if present (snapshot, not shared reference — child `cd`
+ *   does not leak to parent).
+ * - Otherwise share the harness `rootCwdState` reference so successive root
+ *   contexts see TUI/agent `cd`s carry across runs.
+ */
+function resolveContextCwdState(rootCwdState, parent, cwdInit) {
+    if (cwdInit !== undefined) {
+        return {
+            cwd: cwdInit,
+        };
+    }
+    if (parent) {
+        return snapshotCwdState(parent);
+    }
+    return rootCwdState;
+}
+function createClient(config) {
+    const processValue = 'process' in globalThis ? globalThis.process : undefined;
+    const envValue = typeof processValue === 'object' && processValue !== null && 'env' in processValue
+        ? processValue.env
+        : undefined;
+    const openRouterApiKey = typeof envValue === 'object' && envValue !== null && 'OPENROUTER_API_KEY' in envValue
+        ? envValue.OPENROUTER_API_KEY
+        : undefined;
+    const apiKey = config?.apiKey ?? (typeof openRouterApiKey === 'string' ? openRouterApiKey : undefined);
+    if (!apiKey) {
+        return undefined;
+    }
+    return new OpenRouter({
+        apiKey,
+    });
+}
+//#region AgentHarness
+/**
+ * Default agent harness for executing agent steps with built-in channel, memory, and trace support.
+ * Provides channel store, memory layer lifecycle, and trace export with no external dependencies.
+ *
+ * Messages submitted via `execute()` are enqueued on a per-thread session and
+ * processed by a `SessionRunner`. Consumers observe responses via the session-
+ * scoped accessors: `getAgentResponse`, `getItemStream`, etc.
+ *
+ * @public
+ */
+export class AgentHarness {
+    config;
+    fs;
+    shell;
+    subprocess;
+    /**
+     * Optional durable-execution store. When present, `checkpoint(ctx)` writes
+     * a `CheckpointSnapshot`; when absent, it's a no-op.
+     * @internal
+     */
+    checkpointStore;
+    initialStep;
+    /** Harness-wide tool pool merged into every context's `unifiedTools`. */
+    harnessTools;
+    /** @internal Memory layers configured for this harness. Exposed non-private
+     *  so free functions in `runtime/durable/` (checkpoint/restore) can read it
+     *  without friend-class gymnastics. Do not access from outside core. */
+    _memory;
+    client;
+    channelStore;
+    callModelOverride;
+    defaultDeliveryMode;
+    streamIdleTimeoutMs;
+    sessions = new Map();
+    layerStateStore;
+    traceExporter;
+    /**
+     * Long-lived shared cwd state. The same reference is seeded into every
+     * root Context this harness creates, so successive `run()` calls — and the
+     * TUI — observe each other's `cd`s.
+     */
+    rootCwdState;
+    /** @internal Item schema registry. Exposed non-private so free functions
+     *  in `runtime/durable/` (restore) can parse persisted items. Do not
+     *  access from outside core. */
+    itemSchemas;
+    constructor(opts) {
+        const validatedParams = opts.paramsSchema ? opts.paramsSchema.parse(opts.params) : opts.params;
+        this.config = {
+            name: opts.name,
+            storage: opts.storage ?? createInMemoryStorage(),
+            hooks: opts.hooks,
+            params: validatedParams,
+            itemSchemas: opts.itemSchemas,
+            strictItemSchemas: opts.strictItemSchemas ?? true,
+        };
+        this.fs = opts.fs ?? createInMemoryFsAdapter();
+        this.shell = opts.shell ?? createInMemoryShellAdapter();
+        this.subprocess = opts.subprocess ?? createInMemorySubprocessAdapter();
+        this.checkpointStore = opts.checkpointStore;
+        this.initialStep = opts.initialStep;
+        this.harnessTools = opts.tools ?? [];
+        this._memory = opts.memory;
+        this.callModelOverride = opts._testCallModel;
+        this.client = opts._testCallModel ? undefined : createClient(opts.llm);
+        this.channelStore = new ChannelStore();
+        this.traceExporter = opts.traceExporter ?? new NoopExporter();
+        this.layerStateStore = opts.layerStateStore ?? createLayerStateStore();
+        this.defaultDeliveryMode = opts.defaultDeliveryMode ?? 'next-turn';
+        this.streamIdleTimeoutMs = opts.streamIdleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
+        this.itemSchemas = new ItemSchemaRegistry(opts.itemSchemas, {
+            strictUnknownExtensions: opts.strictItemSchemas ?? true,
+        });
+        this.rootCwdState = {
+            cwd: opts.initialCwd ?? '/',
+        };
+    }
+    /**
+     * Update the harness-wide root cwd. The TUI calls this in response to a
+     * user-issued `! cd`, so the next root Context (and any tool inspecting
+     * `harness.rootCwdState.cwd`) observes the new value. Caller is responsible
+     * for passing an absolute, validated path.
+     */
+    setRootCwd(nextCwd) {
+        if (nextCwd === this.rootCwdState.cwd) {
+            return;
+        }
+        this.rootCwdState.previousCwd = this.rootCwdState.cwd;
+        this.rootCwdState.cwd = nextCwd;
+    }
+    //#region Session Accessors
+    execute(input, options) {
+        if (!this.initialStep) {
+            return Promise.reject(new NoeticConfigError({
+                code: 'NO_STEP_CONFIGURED',
+                message: 'No initialStep configured on this harness.',
+                hint: 'Pass `initialStep` in constructor options, or use run() directly.',
+            }));
+        }
+        const threadId = options?.threadId ?? DEFAULT_THREAD_ID;
+        const deliveryMode = options?.deliveryMode ?? this.defaultDeliveryMode;
+        const session = this.getOrCreateSession(threadId);
+        const message = {
+            id: options?.messageId ?? `msg-${crypto.randomUUID()}`,
+            input,
+            deliveryMode,
+            options: options ?? {},
+            enqueuedAt: Date.now(),
+        };
+        if (deliveryMode === 'interrupt' && session.runner.getStatus().kind === 'generating') {
+            session.runner.queue.prepend(message);
+            // Abort kicks the runner via queue subscription after the in-flight turn settles.
+            void session.runner.abort('interrupt');
+            return Promise.resolve();
+        }
+        session.runner.queue.enqueue(message);
+        return Promise.resolve();
+    }
+    getAgentResponse(scope) {
+        const session = this.requireSession(scope);
+        return session.runner.getAgentResponse();
+    }
+    getItemStream(scope) {
+        const session = this.requireSession(scope);
+        return buildItemStream(session.runner.broadcaster, this.itemSchemas);
+    }
+    getTextStream(scope) {
+        const session = this.requireSession(scope);
+        return filterTextStream(session.runner.broadcaster);
+    }
+    getReasoningStream(scope) {
+        const session = this.requireSession(scope);
+        return filterReasoningStream(session.runner.broadcaster);
+    }
+    getFullStream(scope) {
+        const session = this.requireSession(scope);
+        return session.runner.broadcaster;
+    }
+    async abort(scope) {
+        const threadId = scope?.threadId ?? DEFAULT_THREAD_ID;
+        const session = this.sessions.get(threadId);
+        if (!session) {
+            return;
+        }
+        await session.runner.abort(scope?.reason);
+    }
+    getStatus(scope) {
+        const threadId = scope?.threadId ?? DEFAULT_THREAD_ID;
+        const session = this.sessions.get(threadId);
+        if (!session) {
+            return {
+                kind: 'idle',
+            };
+        }
+        return session.runner.getStatus();
+    }
+    getQueueSize(scope) {
+        const threadId = scope?.threadId ?? DEFAULT_THREAD_ID;
+        const session = this.sessions.get(threadId);
+        return session ? session.runner.queue.size : 0;
+    }
+    seedSessionHistory(threadId, items) {
+        const session = this.getOrCreateSession(threadId);
+        session.accumulatedItems = [
+            ...items,
+        ];
+    }
+    getOrCreateSession(threadId) {
+        const existing = this.sessions.get(threadId);
+        if (existing) {
+            return existing;
+        }
+        const session = {
+            accumulatedItems: [],
+            runner: new SessionRunner({
+                threadId,
+                agentName: this.config.name,
+                // The first queued message in a batch establishes `resourceId` /
+                // `state` / `memory` for the turn. If multiple messages are drained
+                // together (queue flush), later messages' values for these fields
+                // are ignored. `deliveryMode` is resolved per-message at enqueue
+                // time and doesn't apply here.
+                createContext: (items, _turnId, messages) => {
+                    const perTurnOptions = messages[0]?.options ?? {};
+                    const allItems = [
+                        ...session.accumulatedItems,
+                        ...items,
+                    ];
+                    const ctx = this.createContext({
+                        items: allItems,
+                        threadId,
+                        resourceId: perTurnOptions.resourceId,
+                        state: perTurnOptions.state,
+                        memory: perTurnOptions.memory,
+                        _broadcaster: session.runner.broadcaster,
+                    });
+                    const ext = frameworkCast(ctx);
+                    ext._sessionQueue = session.runner.queue;
+                    ext._sessionBetweenRounds = true;
+                    ext._sessionRunnerAgentName = this.config.name;
+                    if (this.initialStep || this.harnessTools.length > 0) {
+                        const stepTools = this.initialStep ? collectAllTools(this.initialStep) : [];
+                        this.setUnifiedTools(ctx, [
+                            ...stepTools,
+                            ...this.harnessTools,
+                        ]);
+                    }
+                    return ctx;
+                },
+                runTurn: async (ctx, _turn, signal) => {
+                    if (!this.initialStep) {
+                        throw new NoeticConfigError({
+                            code: 'NO_STEP_CONFIGURED',
+                            message: 'No initialStep configured on this harness.',
+                            hint: 'Pass `initialStep` in constructor options.',
+                        });
+                    }
+                    // Wire signal-abort to context-abort so the interpreter bails cleanly.
+                    if (signal.aborted) {
+                        ctx.abort(signal.reason ? String(signal.reason) : 'aborted');
+                    }
+                    else {
+                        signal.addEventListener('abort', () => {
+                            ctx.abort(signal.reason ? String(signal.reason) : 'aborted');
+                        }, {
+                            once: true,
+                        });
+                    }
+                    const result = await this.initAndRun(this.initialStep, '', ctx);
+                    // Snapshot final items into session history for the next turn.
+                    session.accumulatedItems = [
+                        ...ctx.itemLog.items,
+                    ];
+                    return result;
+                },
+            }),
+        };
+        this.sessions.set(threadId, session);
+        return session;
+    }
+    requireSession(scope) {
+        const threadId = scope?.threadId ?? DEFAULT_THREAD_ID;
+        let session = this.sessions.get(threadId);
+        if (session) {
+            return session;
+        }
+        // Lazily create so consumers can attach stream listeners before the first execute.
+        session = this.getOrCreateSession(threadId);
+        return session;
+    }
+    //#endregion
+    //#region callModel
+    async callModel(request) {
+        return new AgentHarnessModelCaller({
+            agentName: this.config.name,
+            itemSchemas: this.itemSchemas,
+            client: this.client,
+            callModelOverride: this.callModelOverride,
+            streamIdleTimeoutMs: this.streamIdleTimeoutMs,
+            harness: this,
+        }).callModel(request);
+    }
+    //#endregion
+    async run(s, input, ctx) {
+        return execute(s, input, ctx);
+    }
+    /** Run all layer `init` hooks before the first step executes. Per spec 11,
+     *  init MUST complete before any recall fires so layer state is populated. */
+    async initAndRun(s, input, ctx) {
+        const layers = ctx.layers;
+        const storage = this.config.storage;
+        if (layers && layers.length > 0 && storage) {
+            await this.initLayers(layers, ctx, storage);
+        }
+        return execute(s, input, ctx);
+    }
+    detachedSpawn(s, input, parentCtx, overrides) {
+        return dispatchStepThroughAdapter(this, s, input, parentCtx, overrides);
+    }
+    createContext(opts) {
+        const { memory: memoryLayers, cwdInit, ...rest } = opts ?? {};
+        const effectiveMemory = memoryLayers ?? this._memory;
+        const itemSchemas = buildItemSchemaRegistry({
+            base: this.itemSchemas,
+            layers: effectiveMemory,
+        });
+        return new ContextImpl({
+            ...rest,
+            harness: this,
+            channelStore: this.channelStore,
+            layers: effectiveMemory,
+            itemSchemas,
+            cwdState: resolveContextCwdState(this.rootCwdState, opts?.parent, cwdInit),
+        });
+    }
+    send(channel, value, _ctx) {
+        this.channelStore.send(channel, value);
+    }
+    recv(channel, _ctx, opts) {
+        return this.channelStore.recv(channel, opts?.timeout);
+    }
+    tryRecv(channel, _ctx) {
+        return this.channelStore.tryRecv(channel);
+    }
+    getChannelHandle(channel, executionId) {
+        return this.channelStore.getHandle(channel, executionId);
+    }
+    /** Resolves layer-provided tools and merges with step tools into ctx.unifiedTools. */
+    setUnifiedTools(ctx, stepTools) {
+        const layers = ctx.layers;
+        const layerTools = layers && layers.length > 0 ? resolveLayerTools(layers, this, ctx) : [];
+        const allTools = deduplicateTools([
+            ...stepTools,
+            ...layerTools,
+        ]);
+        if (allTools.length > 0) {
+            const impl = frameworkCast(ctx);
+            impl.unifiedTools = allTools;
+        }
+    }
+    toExecCtx(ctx) {
+        return contextToExecCtx(ctx, {
+            callModel: (request) => this.callModel(request),
+        });
+    }
+    async initLayers(layers, ctx, storage) {
+        await initLayers({
+            layers,
+            ctx: this.toExecCtx(ctx),
+            storage,
+            store: this.layerStateStore,
+        });
+    }
+    async recallLayers(layers, input, ctx) {
+        return recallLayers({
+            layers,
+            query: input,
+            ctx: this.toExecCtx(ctx),
+            log: ctx.itemLog,
+            budgets: resolveLayerBudgets(layers),
+            store: this.layerStateStore,
+            itemSchemas: this.itemSchemas,
+        });
+    }
+    /**
+     * Compute the items array that would be sent to the model on the next turn —
+     * the same arrangement `executeLLM` builds: harness-level memory layers'
+     * recall outputs concatenated with the session's accumulated history.
+     *
+     * Read-mostly: `recallLayers` writes layer-state snapshots to
+     * `layerStateStore` exactly as a real turn would, so successive previews
+     * remain consistent with what the next real turn produces.
+     */
+    async previewRequestItems(scope) {
+        const threadId = scope?.threadId ?? DEFAULT_THREAD_ID;
+        // Read-only: if the session doesn't exist, treat history as empty rather
+        // than allocating a SessionRunner for a debug/preview call.
+        const existingSession = this.sessions.get(threadId);
+        const historyItems = existingSession
+            ? [
+                ...existingSession.accumulatedItems,
+            ]
+            : [];
+        const ctx = this.createContext({
+            items: historyItems,
+            threadId,
+            memory: this._memory,
+        });
+        const layers = ctx.layers ?? [];
+        if (layers.length === 0) {
+            return historyItems;
+        }
+        const recallResults = await this.recallLayers(layers, '', ctx);
+        const layerOutputItems = recallResults.flatMap((r) => r.items);
+        if (layerOutputItems.length === 0) {
+            return historyItems;
+        }
+        return assembleView({
+            systemPromptItems: [],
+            layerOutputItems,
+            historyItems,
+        });
+    }
+    async storeLayers(layers, response, ctx) {
+        const storage = this.config.storage;
+        if (!storage) {
+            return;
+        }
+        await storeLayers({
+            layers,
+            response,
+            ctx: this.toExecCtx(ctx),
+            log: ctx.itemLog,
+            store: this.layerStateStore,
+            storage,
+        });
+    }
+    async disposeLayers(layers, ctx) {
+        await disposeLayers({
+            layers,
+            ctx: this.toExecCtx(ctx),
+            store: this.layerStateStore,
+        });
+    }
+    //#region Checkpoint boundaries
+    /**
+     * Snapshot the execution state at a checkpoint boundary.
+     *
+     * Fires at four well-defined points on the happy path:
+     *   1. End of every `execute()` that mutated the item log — so a crash
+     *      between turns lands on a snapshot that includes the user/assistant
+     *      items that actually flowed.
+     *   2. After `detachedSpawn()` settles (success or failure) — the parent's
+     *      record of running/completed children stays consistent with the
+     *      adapter's handle manifest.
+     *   3. After an ask-user enqueue — a restart can replay the pending modal
+     *      to the TUI.
+     *   4. After `runAppendPipeline` — layer state can mutate as items land,
+     *      so the snapshot must follow the mutation.
+     *
+     * Delegates to `captureCheckpoint` / `restoreFromCheckpoint` in
+     * `runtime/durable/harness-checkpoints` so the ~140 lines of snapshot
+     * logic live beside the other durability machinery.
+     */
+    async checkpoint(ctx) {
+        return captureCheckpoint(this, ctx);
+    }
+    /**
+     * Rebuild a `Context` from a previously-persisted snapshot. Returns `null`
+     * if no snapshot is recorded for `executionId`. Surface a typed
+     * `NoeticConfigError(CHECKPOINT_SCHEMA_MISMATCH)` when the snapshot's
+     * schema version is unrecognised — the caller is expected to discard the
+     * checkpoint via `CheckpointStore.clear()` and start a fresh execution.
+     */
+    async restore(executionId) {
+        return restoreFromCheckpoint(this, executionId);
+    }
+    //#endregion
+    async cancel(_ctx, _reason) { }
+    createSpan(name, parent) {
+        return new SpanImpl(name, parent);
+    }
+    getLayerState(executionId, layerId) {
+        return this.layerStateStore.get(executionId, layerId);
+    }
+    setLayerState(executionId, layerId, state) {
+        this.layerStateStore.set(executionId, layerId, state);
+    }
+    async beforeToolCall(layers, toolName, toolArgs, ctx) {
+        const hasHook = layers.some((l) => l.hooks.beforeToolCall);
+        if (!hasHook) {
+            return {
+                action: SteeringAction.Allow,
+            };
+        }
+        return beforeToolCallLayers({
+            layers,
+            toolName,
+            toolArgs,
+            ctx: this.toExecCtx(ctx),
+            store: this.layerStateStore,
+        });
+    }
+    async afterModelCall(layers, response, ctx) {
+        const hasHook = layers.some((l) => l.hooks.afterModelCall);
+        if (!hasHook) {
+            return {
+                action: SteeringAction.Allow,
+            };
+        }
+        return afterModelCallLayers({
+            layers,
+            response,
+            ctx: this.toExecCtx(ctx),
+            store: this.layerStateStore,
+        });
+    }
+    async projectHistory(layers, items, ctx) {
+        const hasHook = layers.some((l) => l.hooks.projectHistory);
+        if (!hasHook) {
+            return items;
+        }
+        return projectHistoryLayers({
+            layers,
+            items,
+            ctx: this.toExecCtx(ctx),
+            store: this.layerStateStore,
+        });
+    }
+    async runAppendPipeline(layers, items, ctx) {
+        const hasHook = layers.some((l) => l.hooks.onItemAppend);
+        if (!hasHook) {
+            return {
+                items,
+                rerenderRequests: [],
+            };
+        }
+        return runAppendPipeline({
+            layers,
+            items,
+            ctx: this.toExecCtx(ctx),
+            log: ctx.itemLog,
+            store: this.layerStateStore,
+        });
+    }
+    async executeRerender(requests, layers, ctx, budgets, query) {
+        return executeRerender({
+            requests,
+            layers,
+            ctx: this.toExecCtx(ctx),
+            log: ctx.itemLog,
+            budgets,
+            store: this.layerStateStore,
+            query,
+            itemSchemas: this.itemSchemas,
+        });
+    }
+}
+//#endregion

package/dist/harness/deps/adapters.d.ts

@@ -0,0 +1,4 @@
+export { OpenRouter } from '@openrouter/agent';
+export { createInMemoryFsAdapter } from '../../adapters/in-memory-fs-adapter';
+export { createInMemoryShellAdapter } from '../../adapters/in-memory-shell-adapter';
+export { createInMemorySubprocessAdapter } from '../../adapters/in-memory-subprocess-adapter';

package/dist/harness/deps/adapters.js

@@ -0,0 +1,4 @@
+export { OpenRouter } from '@openrouter/agent';
+export { createInMemoryFsAdapter } from '../../adapters/in-memory-fs-adapter';
+export { createInMemoryShellAdapter } from '../../adapters/in-memory-shell-adapter';
+export { createInMemorySubprocessAdapter } from '../../adapters/in-memory-subprocess-adapter';

package/dist/harness/deps/interpreter.d.ts

@@ -0,0 +1,5 @@
+export { collectAllTools, deduplicateTools } from '../../interpreter/collect-tools';
+export { execute } from '../../interpreter/execute';
+export type { DetachedSpawnOverrides } from '../../interpreter/step-dispatcher';
+export { dispatchStepThroughAdapter } from '../../interpreter/step-dispatcher';
+export { isFunctionCall } from '../../interpreter/typeguards';

package/dist/harness/deps/interpreter.js

@@ -0,0 +1,4 @@
+export { collectAllTools, deduplicateTools } from '../../interpreter/collect-tools';
+export { execute } from '../../interpreter/execute';
+export { dispatchStepThroughAdapter } from '../../interpreter/step-dispatcher';
+export { isFunctionCall } from '../../interpreter/typeguards';

package/dist/harness/deps/memory.d.ts

@@ -0,0 +1,5 @@
+export { contextToExecCtx } from '../../memory/exec-context-factory';
+export { resolveLayerTools } from '../../memory/layer-api';
+export type { LayerStateStore } from '../../memory/layer-lifecycle';
+export { afterModelCallLayers, beforeToolCallLayers, createLayerStateStore, disposeLayers, executeRerender, initLayers, projectHistoryLayers, recallLayers, resolveLayerBudgets, runAppendPipeline, storeLayers, } from '../../memory/layer-lifecycle';
+export { assembleView } from '../../memory/projector';

package/dist/harness/deps/memory.js

@@ -0,0 +1,4 @@
+export { contextToExecCtx } from '../../memory/exec-context-factory';
+export { resolveLayerTools } from '../../memory/layer-api';
+export { afterModelCallLayers, beforeToolCallLayers, createLayerStateStore, disposeLayers, executeRerender, initLayers, projectHistoryLayers, recallLayers, resolveLayerBudgets, runAppendPipeline, storeLayers, } from '../../memory/layer-lifecycle';
+export { assembleView } from '../../memory/projector';

package/dist/harness/deps/runtime.d.ts

@@ -0,0 +1,10 @@
+export { ChannelStore } from '../../runtime/channel-store';
+export { ContextImpl } from '../../runtime/context-impl';
+export { snapshotCwdState } from '../../runtime/cwd-helpers';
+export type { CheckpointStore } from '../../runtime/durable';
+export { captureCheckpoint, restoreFromCheckpoint, } from '../../runtime/durable/harness-checkpoints';
+export type { EventBroadcaster } from '../../runtime/event-broadcaster';
+export { createInMemoryStorage } from '../../runtime/in-memory-storage';
+export type { QueuedMessage } from '../../runtime/message-queue';
+export { SessionRunner } from '../../runtime/session-runner';
+export { buildItemStream, filterReasoningStream, filterTextStream, } from '../../runtime/session-streams';

package/dist/harness/deps/runtime.js

@@ -0,0 +1,7 @@
+export { ChannelStore } from '../../runtime/channel-store';
+export { ContextImpl } from '../../runtime/context-impl';
+export { snapshotCwdState } from '../../runtime/cwd-helpers';
+export { captureCheckpoint, restoreFromCheckpoint, } from '../../runtime/durable/harness-checkpoints';
+export { createInMemoryStorage } from '../../runtime/in-memory-storage';
+export { SessionRunner } from '../../runtime/session-runner';
+export { buildItemStream, filterReasoningStream, filterTextStream, } from '../../runtime/session-streams';

package/dist/harness/deps/types.d.ts

@@ -0,0 +1,17 @@
+export type { ZodType } from 'zod';
+export type { Channel, ChannelHandle, ExternalChannel } from '../../types/channel';
+export type { LLMResponse, LlmProviderConfig } from '../../types/common';
+export type { Context, CwdState } from '../../types/context';
+export type { DetachedHandle } from '../../types/detached';
+export type { FsAdapter } from '../../types/fs-adapter';
+export type { HarnessResponse, StreamEvent, StreamingItem } from '../../types/harness-result';
+export type { ExecuteInput, Item, ItemSchemaExtensions } from '../../types/items';
+export type { ContextMemory, ExecutionContext, MemoryLayer, StorageAdapter, } from '../../types/memory';
+export type { Span, TraceExporter } from '../../types/observability';
+export type { AgentConfig, AgentHarnessContract, AgentHooks, CallModelRequest, DeliveryMode, ExecuteOptions, HarnessStatus, RecallLayerOutput, SessionScope, } from '../../types/runtime';
+export type { ShellAdapter } from '../../types/shell-adapter';
+export type { SteeringDecision } from '../../types/steering';
+export { SteeringAction } from '../../types/steering';
+export type { Step } from '../../types/step';
+export type { SubprocessAdapter } from '../../types/subprocess-adapter';
+export type { Tool } from '../../types/tool';

package/dist/harness/deps/types.js

@@ -0,0 +1 @@
+export { SteeringAction } from '../../types/steering';