@noetic-tools/core 0.0.1 → 0.1.1

package/dist/memory/function-call-utils.d.ts

@@ -1,4 +1,4 @@
-import type { Item } from '../types/items';
+import type { Item } from '../types/items.js';
 /**
  * Finds the first function_call item matching `name`, parses its JSON arguments,
  * and returns the result as a record. Returns null if no match or invalid data.

package/dist/memory/function-call-utils.js

@@ -1,5 +1,7 @@
-import { frameworkCast } from '../interpreter/framework-cast';
-import { isFunctionCall } from '../interpreter/typeguards';
+import { frameworkCast } from '../util/framework-cast.js';
+function isFunctionCall(item) {
+    return item.type === 'function_call' && 'callId' in item && 'name' in item;
+}
 /**
  * Finds the first function_call item matching `name`, parses its JSON arguments,
  * and returns the result as a record. Returns null if no match or invalid data.

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

@@ -1,7 +1,7 @@
-import type { Tool } from '../types/common';
-import type { Context } from '../types/context';
-import type { ContextMemory, MemoryLayer } from '../types/memory';
-import type { AgentHarnessContract } from '../types/runtime';
+import type { Context } from '../types/context.js';
+import type { ContextMemory, MemoryLayer } from '../types/memory.js';
+import type { AgentHarnessContract } from '../types/runtime.js';
+import type { Tool } from '../types/tool.js';
 /**
  * Build the `ctx.memory` object — a readonly map of layer ID → resolved handle.
  * Handles use getters for data (live reads) and closures for functions (lazy state).

package/dist/memory/layer-api.js

@@ -1,5 +1,5 @@
-import { frameworkCast } from '../interpreter/framework-cast';
-import { contextToExecCtx } from '../runtime/exec-context-factory';
+import { frameworkCast } from '../util/framework-cast.js';
+import { contextToExecCtx } from './exec-context-factory.js';
 function executeLayerFn(params) {
     const { fn, args, layerId, harness, ctx } = params;
     const validated = fn.input.parse(args);

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

@@ -1,9 +1,9 @@
-import type { ItemSchemaRegistry } from '../schemas/item';
-import type { LLMResponse } from '../types/common';
-import type { ItemLog } from '../types/context';
-import type { Item } from '../types/items';
-import type { ExecutionContext, MemoryLayer, StorageAdapter } from '../types/memory';
-import type { SteeringDecision } from '../types/steering';
+import type { ItemSchemaRegistry } from '../schemas/item.js';
+import type { LLMResponse } from '../types/common.js';
+import type { ItemLog } from '../types/context-parts/item-log.js';
+import type { Item } from '../types/items.js';
+import type { ExecutionContext, MemoryLayer, StorageAdapter } from '../types/memory.js';
+import type { SteeringDecision } from '../types/steering.js';
 export interface LayerStateStore {
     get<T>(executionId: string, layerId: string): T | undefined;
     set<T>(executionId: string, layerId: string, state: T): void;

package/dist/memory/layer-lifecycle.js

@@ -1,9 +1,9 @@
-import { NoeticConfigError } from '../errors/noetic-config-error';
-import { frameworkCast } from '../interpreter/framework-cast';
-import { createMessage, estimateTokens } from '../interpreter/message-helpers';
-import { defaultItemSchemaRegistry } from '../schemas/item';
-import { SteeringAction } from '../types/steering';
-import { createScopedStorage, resolveScopeKey } from './scope';
+import { NoeticConfigError } from '../errors/noetic-config-error.js';
+import { defaultItemSchemaRegistry } from '../schemas/item.js';
+import { SteeringAction } from '../types/steering.js';
+import { frameworkCast } from '../util/framework-cast.js';
+import { createMessage, estimateTokens } from '../util/message-helpers.js';
+import { createScopedStorage, resolveScopeKey } from './scope.js';
 /** Maximum allowed re-render depth to prevent infinite loops */
 const MAX_RERENDER_DEPTH = 3;
 /**

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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,33 @@
+/**
+ * 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,6 +1,7 @@
-import type { Tool } from '../types/common';
-import type { Context, LastLayerUsage } from '../types/context';
-import type { RecallLayerOutput } from '../types/runtime';
+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;

package/dist/memory/layer-usage.js

@@ -1,5 +1,11 @@
-import { estimateTokens } from '../interpreter/message-helpers';
-import { isContextImpl } from '../interpreter/typeguards';
+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) {
@@ -40,7 +46,7 @@ export function computeLayerUsage({ ctx, modelId, instructions, tools, recallRes
 }
 /** Commit computed usage to the Context, replacing any prior snapshot. */
 export function commitLayerUsage(ctx, usage) {
-    if (!isContextImpl(ctx)) {
+    if (!canWriteLayerUsage(ctx)) {
         return;
     }
     ctx.lastLayerUsage = usage;

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

@@ -37,21 +37,21 @@ export declare function durableTaskState(_config?: DurableTaskStateConfig): {
         store: number;
     };
     hooks: {
-        init({ storage }: import("../..").InitParams): Promise<{
+        init({ storage }: import("../../index.js").InitParams): Promise<{
             state: DurableTaskState;
         }>;
-        recall({ state }: import("../..").RecallParams<DurableTaskState>): Promise<{
-            items: import("../..").InputMessageItem[];
+        recall({ state }: import("../../index.js").RecallParams<DurableTaskState>): Promise<{
+            items: import("../../index.js").InputMessageItem[];
             tokenCount: number;
         } | null>;
-        store({ state, ctx }: import("../..").StoreParams<DurableTaskState>): Promise<{
+        store({ state, ctx }: import("../../index.js").StoreParams<DurableTaskState>): Promise<{
             state: DurableTaskState;
         }>;
-        onSpawn({ parentState }: import("../..").SpawnParams<DurableTaskState>): Promise<{
+        onSpawn({ parentState }: import("../../index.js").SpawnParams<DurableTaskState>): Promise<{
             childState: DurableTaskState;
             items: never[];
         }>;
-        onReturn({ childState, parentState }: import("../..").ReturnParams<DurableTaskState>): Promise<{
+        onReturn({ childState, parentState }: import("../../index.js").ReturnParams<DurableTaskState>): Promise<{
             parentState: {
                 checkpoints: {
                     timestamp: number;
@@ -63,10 +63,10 @@ export declare function durableTaskState(_config?: DurableTaskStateConfig): {
                 };
             };
         }>;
-        onComplete({ state, outcome }: import("../..").CompleteParams<DurableTaskState>): Promise<{
+        onComplete({ state, outcome }: import("../../index.js").CompleteParams<DurableTaskState>): Promise<{
             state: {
                 data: {
-                    __outcome: import("../..").ExecutionOutcome;
+                    __outcome: import("../../index.js").ExecutionOutcome;
                 };
                 checkpoints: {
                     timestamp: number;

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

@@ -1,5 +1,5 @@
-import { createMessage, estimateTokens } from '../../interpreter/message-helpers';
-import { Slot } from '../../types/memory';
+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.
  *

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

@@ -1,4 +1,4 @@
-import type { MemoryLayer } from '../../types/memory';
+import type { MemoryLayer } from '../../types/memory.js';
 interface TrackedFile {
     /** Absolute path to the file */
     absolutePath: string;