@noetic-tools/core 0.2.0 → 0.3.0

package/dist/memory/layer-provides.d.ts

@@ -1,32 +0,0 @@
-import type { ZodType } from 'zod';
-import type { ExecutionContext, LayerDataDecl, LayerFunctionDecl } from '../types/memory.js';
-/**
- * Creates a read-only data declaration for a memory layer's `provides` map.
- *
- * @public
- * @param opts.read - Function that projects a value from the layer's current state.
- * @returns A `LayerDataDecl` to include in a layer's `provides`.
- */
-export declare function layerData<T, TState>(opts: {
-    read: (state: TState) => T;
-}): LayerDataDecl<T, TState>;
-/**
- * Creates a callable function declaration for a memory layer's `provides` map.
- * Functions are accessible via `ctx.memory['layerId'].fn()` and automatically exposed as LLM tools.
- *
- * @public
- * @param opts.description - Human-readable description used as tool description for LLM.
- * @param opts.input - Zod schema validating input arguments.
- * @param opts.output - Zod schema validating the return value.
- * @param opts.execute - Async function receiving args, current state, and execution context.
- * @returns A `LayerFunctionDecl` to include in a layer's `provides`.
- */
-export declare function layerFn<TInput, TOutput, TState>(opts: {
-    description: string;
-    input: ZodType<TInput>;
-    output: ZodType<TOutput>;
-    execute: (args: TInput, state: TState, ctx: ExecutionContext) => Promise<{
-        result: TOutput;
-        state?: TState;
-    }>;
-}): LayerFunctionDecl<TInput, TOutput, TState>;

package/dist/memory/layer-provides.js

@@ -1,33 +0,0 @@
-/**
- * Creates a read-only data declaration for a memory layer's `provides` map.
- *
- * @public
- * @param opts.read - Function that projects a value from the layer's current state.
- * @returns A `LayerDataDecl` to include in a layer's `provides`.
- */
-export function layerData(opts) {
-    return {
-        kind: 'data',
-        read: opts.read,
-    };
-}
-/**
- * Creates a callable function declaration for a memory layer's `provides` map.
- * Functions are accessible via `ctx.memory['layerId'].fn()` and automatically exposed as LLM tools.
- *
- * @public
- * @param opts.description - Human-readable description used as tool description for LLM.
- * @param opts.input - Zod schema validating input arguments.
- * @param opts.output - Zod schema validating the return value.
- * @param opts.execute - Async function receiving args, current state, and execution context.
- * @returns A `LayerFunctionDecl` to include in a layer's `provides`.
- */
-export function layerFn(opts) {
-    return {
-        kind: 'function',
-        description: opts.description,
-        input: opts.input,
-        output: opts.output,
-        execute: opts.execute,
-    };
-}

package/dist/memory/layer-usage.d.ts

@@ -1,16 +0,0 @@
-import type { Context } from '../types/context.js';
-import type { LastLayerUsage } from '../types/context-parts/layer-usage.js';
-import type { RecallLayerOutput } from '../types/runtime.js';
-import type { Tool } from '../types/tool.js';
-interface ComputeLayerUsageParams {
-    ctx: Context;
-    modelId: string;
-    instructions?: string;
-    tools?: ReadonlyArray<Tool>;
-    /** Per-layer recall output assembled into the context view for this LLM call. */
-    recallResults: ReadonlyArray<RecallLayerOutput>;
-}
-export declare function computeLayerUsage({ ctx, modelId, instructions, tools, recallResults, }: ComputeLayerUsageParams): LastLayerUsage;
-/** Commit computed usage to the Context, replacing any prior snapshot. */
-export declare function commitLayerUsage(ctx: Context, usage: LastLayerUsage): void;
-export {};

package/dist/memory/layer-usage.js

@@ -1,54 +0,0 @@
-import { estimateTokens } from '../util/message-helpers.js';
-function canWriteLayerUsage(ctx) {
-    const desc = Object.getOwnPropertyDescriptor(ctx, 'lastLayerUsage');
-    if (desc === undefined) {
-        return false;
-    }
-    return desc.writable !== false;
-}
-//#endregion
-//#region Helpers
-function estimateJsonTokens(value) {
-    try {
-        return estimateTokens(JSON.stringify(value));
-    }
-    catch {
-        return 0;
-    }
-}
-//#endregion
-//#region Public API
-export function computeLayerUsage({ ctx, modelId, instructions, tools, recallResults, }) {
-    const layers = recallResults
-        .map((r) => ({
-        layerId: r.layerId,
-        tokenCount: r.tokenCount,
-        items: r.items,
-    }))
-        .sort((a, b) => a.layerId.localeCompare(b.layerId));
-    let historyTokens = 0;
-    for (const item of ctx.itemLog.items) {
-        historyTokens += estimateJsonTokens(item);
-    }
-    const systemPromptTokens = instructions ? estimateTokens(instructions) : 0;
-    const toolsTokens = tools && tools.length > 0 ? estimateJsonTokens(tools) : 0;
-    const layerTotal = layers.reduce((sum, l) => sum + l.tokenCount, 0);
-    const totalUsedTokens = systemPromptTokens + toolsTokens + historyTokens + layerTotal;
-    return {
-        executionId: ctx.id,
-        modelId,
-        layers,
-        systemPromptTokens,
-        toolsTokens,
-        historyTokens,
-        totalUsedTokens,
-    };
-}
-/** Commit computed usage to the Context, replacing any prior snapshot. */
-export function commitLayerUsage(ctx, usage) {
-    if (!canWriteLayerUsage(ctx)) {
-        return;
-    }
-    ctx.lastLayerUsage = usage;
-}
-//#endregion

package/dist/memory/layers/durable-task-state.d.ts

@@ -1,79 +0,0 @@
-import type { ZodType } from 'zod';
-export interface DurableTaskState {
-    checkpoints: Array<{
-        timestamp: number;
-        depth: number;
-    }>;
-    files: string[];
-    data: Record<string, unknown>;
-}
-export interface DurableTaskStateSerializer {
-    serialize(state: DurableTaskState): string;
-    deserialize(data: string): DurableTaskState;
-}
-export interface DurableTaskStateConfig {
-    baseDir?: string;
-    gitCommit?: boolean;
-    schema?: ZodType;
-    serializer?: DurableTaskStateSerializer;
-}
-/**
- * Creates a memory layer that persists task checkpoints, files, and arbitrary data across iterations.
- *
- * @public
- * @param _config - Optional configuration for base directory, git commit behavior, schema, and serializer.
- * @returns A `MemoryLayer` scoped to the execution with durable task state.
- */
-export declare function durableTaskState(_config?: DurableTaskStateConfig): {
-    id: "durable-task-state";
-    name: string;
-    slot: number;
-    scope: "execution";
-    budget: {
-        min: number;
-        max: number;
-    };
-    timeouts: {
-        store: number;
-    };
-    hooks: {
-        init({ storage }: import("../../index.js").InitParams): Promise<{
-            state: DurableTaskState;
-        }>;
-        recall({ state }: import("../../index.js").RecallParams<DurableTaskState>): Promise<{
-            items: import("../../index.js").InputMessageItem[];
-            tokenCount: number;
-        } | null>;
-        store({ state, ctx }: import("../../index.js").StoreParams<DurableTaskState>): Promise<{
-            state: DurableTaskState;
-        }>;
-        onSpawn({ parentState }: import("../../index.js").SpawnParams<DurableTaskState>): Promise<{
-            childState: DurableTaskState;
-            items: never[];
-        }>;
-        onReturn({ childState, parentState }: import("../../index.js").ReturnParams<DurableTaskState>): Promise<{
-            parentState: {
-                checkpoints: {
-                    timestamp: number;
-                    depth: number;
-                }[];
-                files: string[];
-                data: {
-                    [x: string]: unknown;
-                };
-            };
-        }>;
-        onComplete({ state, outcome }: import("../../index.js").CompleteParams<DurableTaskState>): Promise<{
-            state: {
-                data: {
-                    __outcome: import("../../index.js").ExecutionOutcome;
-                };
-                checkpoints: {
-                    timestamp: number;
-                    depth: number;
-                }[];
-                files: string[];
-            };
-        } | undefined>;
-    };
-};

package/dist/memory/layers/durable-task-state.js

@@ -1,118 +0,0 @@
-import { Slot } from '../../types/memory.js';
-import { createMessage, estimateTokens } from '../../util/message-helpers.js';
-/**
- * Creates a memory layer that persists task checkpoints, files, and arbitrary data across iterations.
- *
- * @public
- * @param _config - Optional configuration for base directory, git commit behavior, schema, and serializer.
- * @returns A `MemoryLayer` scoped to the execution with durable task state.
- */
-export function durableTaskState(_config) {
-    return {
-        id: 'durable-task-state',
-        name: 'Durable Task State',
-        slot: Slot.WORKING_MEMORY + 10, // 110
-        scope: 'execution',
-        budget: {
-            min: 100,
-            max: 800,
-        },
-        timeouts: {
-            store: 30_000,
-        },
-        hooks: {
-            async init({ storage }) {
-                const saved = await storage.get('state');
-                return {
-                    state: saved ?? {
-                        checkpoints: [],
-                        files: [],
-                        data: {},
-                    },
-                };
-            },
-            async recall({ state }) {
-                if (!state) {
-                    return null;
-                }
-                const text = `<task_state>\n${JSON.stringify(state, null, 2)}\n</task_state>`;
-                return {
-                    items: [
-                        createMessage(text, 'developer'),
-                    ],
-                    tokenCount: estimateTokens(text),
-                };
-            },
-            async store({ state, ctx }) {
-                const currentState = state ?? {
-                    checkpoints: [],
-                    files: [],
-                    data: {},
-                };
-                // Add a checkpoint for each store call
-                const newState = {
-                    ...currentState,
-                    checkpoints: [
-                        ...currentState.checkpoints,
-                        {
-                            timestamp: Date.now(),
-                            depth: ctx.depth,
-                        },
-                    ],
-                };
-                return {
-                    state: newState,
-                };
-            },
-            async onSpawn({ parentState }) {
-                // ALWAYS provides child state (unlike other layers)
-                return {
-                    childState: structuredClone(parentState),
-                    items: [],
-                };
-            },
-            async onReturn({ childState, parentState }) {
-                // Merge child artifacts back to parent
-                return {
-                    parentState: {
-                        checkpoints: [
-                            ...parentState.checkpoints,
-                            ...childState.checkpoints,
-                        ],
-                        files: [
-                            ...new Set([
-                                ...parentState.files,
-                                ...childState.files,
-                            ]),
-                        ],
-                        data: {
-                            ...parentState.data,
-                            ...childState.data,
-                        },
-                    },
-                };
-            },
-            async onComplete({ state, outcome }) {
-                if (!state) {
-                    return;
-                }
-                return {
-                    state: {
-                        ...state,
-                        data: {
-                            ...state.data,
-                            __outcome: outcome,
-                        },
-                        checkpoints: [
-                            ...state.checkpoints,
-                            {
-                                timestamp: Date.now(),
-                                depth: 0,
-                            },
-                        ],
-                    },
-                };
-            },
-        },
-    };
-}

package/dist/memory/layers/file-reference.d.ts

@@ -1,55 +0,0 @@
-import type { MemoryLayer } from '../../types/memory.js';
-interface TrackedFile {
-    /** Absolute path to the file */
-    absolutePath: string;
-    /** Original reference path (as written by user) */
-    referencePath: string;
-    /** File content (null if deleted or error) */
-    content: string | null;
-    /** LLM-assigned priority score (0-100, higher = more relevant) */
-    priority: number;
-    /** Content hash for change detection */
-    contentHash: string;
-    /** Whether the file has been deleted */
-    deleted: boolean;
-    /** Estimated token count */
-    tokenCount: number;
-    /** Error message if file couldn't be read (security, size, permission) */
-    error?: string;
-}
-interface FileReferenceState {
-    /** Map of reference path to tracked file info */
-    files: Map<string, TrackedFile>;
-    /** Base directory for resolving relative paths */
-    baseDir: string;
-}
-interface FileReferenceOptions {
-    /** Base directory for resolving relative paths (defaults to cwd) */
-    baseDir?: string;
-    /** Slot position (defaults to Slot.RAG) */
-    slot?: number;
-    /** Model to use for priority scoring */
-    scoringModel?: string;
-    /** Maximum file size in bytes (defaults to 1MB) */
-    maxFileSize?: number;
-    /** Whether to follow symlinks (defaults to false for security) */
-    followSymlinks?: boolean;
-    /** Allowed file extensions (defaults to common code/text extensions) */
-    allowedExtensions?: string[];
-}
-/**
- * Creates a memory layer that tracks file references in user messages.
- *
- * Syntax: `#path/to/file` in user messages
- *
- * Behavior:
- * - Transforms references to markdown anchor links `[#path/to/file](#path-to-file)`
- * - Scores file relevance using LLM when first referenced
- * - Injects file contents into context via recall(), ordered by priority
- * - Detects file changes on each new message, triggers immediate re-render
- * - Shows warning for deleted files
- *
- * @public
- */
-export declare function fileReference(opts?: FileReferenceOptions): MemoryLayer<FileReferenceState>;
-export {};