apcore-js 0.1.2 → 0.3.0

package/CHANGELOG.md

@@ -5,6 +5,65 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.0] - 2026-02-20
+
+### Changed
+- Use shallow merge for `stream()` accumulation instead of last-chunk.
+
+### Added
+- Add `Executor.stream()` async generator and `ModuleAnnotations.streaming` for streaming support in the core execution pipeline.
+
+### Co-Authors
+- Claude Opus 4.6 <noreply@anthropic.com>
+
+### Added
+
+- **Error classes and constants**
+  - `ModuleExecuteError` — New error class for module execution failures
+  - `InternalError` — New error class for general internal errors
+  - `ErrorCodes` — Frozen object with all 26 error code strings for consistent error code usage
+  - `ErrorCode` — Type definition for all error codes
+- **Registry constants**
+  - `REGISTRY_EVENTS` — Frozen object with standard event names (`register`, `unregister`)
+  - `MODULE_ID_PATTERN` — Regex pattern enforcing lowercase/digits/underscores/dots for module IDs (no hyphens allowed to ensure bijective MCP tool name normalization)
+- **Executor methods**
+  - `Executor.callAsync()` — Alias for `call()` for compatibility with MCP bridge packages
+
+### Changed
+
+- **Module ID validation** — Registry now validates module IDs against `MODULE_ID_PATTERN` on registration, rejecting IDs with hyphens or invalid characters
+- **Event handling** — Registry event validation now uses `REGISTRY_EVENTS` constants instead of hardcoded strings
+- **Test updates** — Updated tests to use underscore-separated module IDs instead of hyphens (e.g., `math.add_ten` instead of `math.addTen`, `ctx_test` instead of `ctx-test`)
+
+### Fixed
+
+- **String literals in Registry** — Replaced hardcoded `'register'` and `'unregister'` strings with `REGISTRY_EVENTS.REGISTER` and `REGISTRY_EVENTS.UNREGISTER` constants in event triggers for consistency
+
+## [0.2.0] - 2026-02-20
+
+### Added
+
+- **Error classes and constants**
+  - `ModuleExecuteError` — New error class for module execution failures
+  - `InternalError` — New error class for general internal errors
+  - `ErrorCodes` — Frozen object with all 26 error code strings for consistent error code usage
+  - `ErrorCode` — Type definition for all error codes
+- **Registry constants**
+  - `REGISTRY_EVENTS` — Frozen object with standard event names (`register`, `unregister`)
+  - `MODULE_ID_PATTERN` — Regex pattern enforcing lowercase/digits/underscores/dots for module IDs (no hyphens allowed to ensure bijective MCP tool name normalization)
+- **Executor methods**
+  - `Executor.callAsync()` — Alias for `call()` for compatibility with MCP bridge packages
+
+### Changed
+
+- **Module ID validation** — Registry now validates module IDs against `MODULE_ID_PATTERN` on registration, rejecting IDs with hyphens or invalid characters
+- **Event handling** — Registry event validation now uses `REGISTRY_EVENTS` constants instead of hardcoded strings
+- **Test updates** — Updated tests to use underscore-separated module IDs instead of hyphens (e.g., `math.add_ten` instead of `math.addTen`, `ctx_test` instead of `ctx-test`)
+
+### Fixed
+
+- **String literals in Registry** — Replaced hardcoded `'register'` and `'unregister'` strings with `REGISTRY_EVENTS.REGISTER` and `REGISTRY_EVENTS.UNREGISTER` constants in event triggers for consistency
+
 ## [0.1.2] - 2026-02-18
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apcore-js",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "AI-Perceivable Core — schema-driven module development framework",
   "type": "module",
   "main": "./dist/index.js",

package/planning/overview.md

@@ -3,7 +3,7 @@
 ## Overall Progress
 
 ```
-[████████████████████████████████████████] 42/42 tasks (100%)
+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 42/42 tasks (100%)
 ```
 
 | Status | Count |

package/src/errors.ts

@@ -367,3 +367,58 @@ export class ModuleLoadError extends ModuleError {
     this.name = 'ModuleLoadError';
   }
 }
+
+export class ModuleExecuteError extends ModuleError {
+  constructor(moduleId: string, reason: string, options?: { cause?: Error; traceId?: string }) {
+    super(
+      'MODULE_EXECUTE_ERROR',
+      `Failed to execute module '${moduleId}': ${reason}`,
+      { moduleId, reason },
+      options?.cause,
+      options?.traceId,
+    );
+    this.name = 'ModuleExecuteError';
+  }
+}
+
+export class InternalError extends ModuleError {
+  constructor(message: string = 'Internal error', options?: { cause?: Error; traceId?: string }) {
+    super('GENERAL_INTERNAL_ERROR', message, {}, options?.cause, options?.traceId);
+    this.name = 'InternalError';
+  }
+}
+
+/**
+ * All framework error codes as constants.
+ * Use these instead of hardcoding error code strings.
+ */
+export const ErrorCodes = Object.freeze({
+  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+  CONFIG_INVALID: "CONFIG_INVALID",
+  ACL_RULE_ERROR: "ACL_RULE_ERROR",
+  ACL_DENIED: "ACL_DENIED",
+  MODULE_NOT_FOUND: "MODULE_NOT_FOUND",
+  MODULE_TIMEOUT: "MODULE_TIMEOUT",
+  MODULE_LOAD_ERROR: "MODULE_LOAD_ERROR",
+  MODULE_EXECUTE_ERROR: "MODULE_EXECUTE_ERROR",
+  SCHEMA_VALIDATION_ERROR: "SCHEMA_VALIDATION_ERROR",
+  SCHEMA_NOT_FOUND: "SCHEMA_NOT_FOUND",
+  SCHEMA_PARSE_ERROR: "SCHEMA_PARSE_ERROR",
+  SCHEMA_CIRCULAR_REF: "SCHEMA_CIRCULAR_REF",
+  CALL_DEPTH_EXCEEDED: "CALL_DEPTH_EXCEEDED",
+  CIRCULAR_CALL: "CIRCULAR_CALL",
+  CALL_FREQUENCY_EXCEEDED: "CALL_FREQUENCY_EXCEEDED",
+  GENERAL_INVALID_INPUT: "GENERAL_INVALID_INPUT",
+  GENERAL_INTERNAL_ERROR: "GENERAL_INTERNAL_ERROR",
+  FUNC_MISSING_TYPE_HINT: "FUNC_MISSING_TYPE_HINT",
+  FUNC_MISSING_RETURN_TYPE: "FUNC_MISSING_RETURN_TYPE",
+  BINDING_INVALID_TARGET: "BINDING_INVALID_TARGET",
+  BINDING_MODULE_NOT_FOUND: "BINDING_MODULE_NOT_FOUND",
+  BINDING_CALLABLE_NOT_FOUND: "BINDING_CALLABLE_NOT_FOUND",
+  BINDING_NOT_CALLABLE: "BINDING_NOT_CALLABLE",
+  BINDING_SCHEMA_MISSING: "BINDING_SCHEMA_MISSING",
+  BINDING_FILE_INVALID: "BINDING_FILE_INVALID",
+  CIRCULAR_DEPENDENCY: "CIRCULAR_DEPENDENCY",
+} as const);
+
+export type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];

package/src/executor.ts

@@ -168,6 +168,108 @@ export class Executor {
     return this._executeWithMiddleware(mod, moduleId, effectiveInputs, ctx);
   }
 
+  /**
+   * Alias for call(). Provided for compatibility with MCP bridge packages
+   * that may call callAsync() by convention.
+   */
+  async callAsync(
+    moduleId: string,
+    inputs?: Record<string, unknown> | null,
+    context?: Context | null,
+  ): Promise<Record<string, unknown>> {
+    return this.call(moduleId, inputs, context);
+  }
+
+  /**
+   * Streaming execution pipeline. If the module exposes a stream() async generator,
+   * yields each chunk. Otherwise falls back to call() and yields a single chunk.
+   *
+   * Pipeline: context -> safety -> lookup -> ACL -> validate inputs -> before-middleware
+   *   -> stream (or fallback to execute) -> validate accumulated output -> after-middleware
+   */
+  async *stream(
+    moduleId: string,
+    inputs?: Record<string, unknown> | null,
+    context?: Context | null,
+  ): AsyncGenerator<Record<string, unknown>> {
+    let effectiveInputs = inputs ?? {};
+    const ctx = this._createContext(moduleId, context);
+    this._checkSafety(moduleId, ctx);
+
+    const mod = this._lookupModule(moduleId);
+    this._checkAcl(moduleId, ctx);
+
+    effectiveInputs = this._validateInputs(mod, effectiveInputs, ctx);
+
+    yield* this._streamWithMiddleware(mod, moduleId, effectiveInputs, ctx);
+  }
+
+  private async *_streamWithMiddleware(
+    mod: Record<string, unknown>,
+    moduleId: string,
+    inputs: Record<string, unknown>,
+    ctx: Context,
+  ): AsyncGenerator<Record<string, unknown>> {
+    let effectiveInputs = inputs;
+    let executedMiddlewares: Middleware[] = [];
+
+    try {
+      try {
+        [effectiveInputs, executedMiddlewares] = this._middlewareManager.executeBefore(moduleId, effectiveInputs, ctx);
+      } catch (e) {
+        if (e instanceof MiddlewareChainError) {
+          executedMiddlewares = e.executedMiddlewares;
+          const recovery = this._middlewareManager.executeOnError(
+            moduleId, effectiveInputs, e.original, ctx, executedMiddlewares,
+          );
+          if (recovery !== null) {
+            yield recovery;
+            return;
+          }
+          executedMiddlewares = [];
+          throw e.original;
+        }
+        throw e;
+      }
+
+      const streamFn = mod['stream'] as
+        | ((inputs: Record<string, unknown>, context: Context) => AsyncGenerator<Record<string, unknown>>)
+        | undefined;
+
+      if (typeof streamFn === 'function') {
+        // Module has a stream() method: iterate and yield each chunk
+        let accumulated: Record<string, unknown> = {};
+        for await (const chunk of streamFn.call(mod, effectiveInputs, ctx)) {
+          accumulated = { ...accumulated, ...chunk };
+          yield chunk;
+        }
+
+        // Validate accumulated output against output schema
+        this._validateOutput(mod, accumulated);
+
+        // Run after-middleware on the accumulated result
+        this._middlewareManager.executeAfter(moduleId, effectiveInputs, accumulated, ctx);
+      } else {
+        // Fallback: execute normally and yield single chunk
+        let output = await this._executeWithTimeout(mod, moduleId, effectiveInputs, ctx);
+        this._validateOutput(mod, output);
+        output = this._middlewareManager.executeAfter(moduleId, effectiveInputs, output, ctx);
+        yield output;
+      }
+    } catch (exc) {
+      if (executedMiddlewares.length > 0) {
+        const recovery = this._middlewareManager.executeOnError(
+          moduleId, effectiveInputs, exc as Error, ctx, executedMiddlewares,
+        );
+        if (recovery !== null) {
+          yield recovery;
+          return;
+        }
+      }
+      throw exc;
+    }
+  }
+
   private _createContext(moduleId: string, context?: Context | null): Context {
     if (context == null) {
       return Context.create(this).child(moduleId);
@@ -253,10 +355,7 @@ export class Executor {
 
       let output = await this._executeWithTimeout(mod, moduleId, effectiveInputs, ctx);
 
-      const outputSchema = mod['outputSchema'] as TSchema | undefined;
-      if (outputSchema != null) {
-        this._validateSchema(outputSchema, output, 'Output');
-      }
+      this._validateOutput(mod, output);
 
       output = this._middlewareManager.executeAfter(moduleId, effectiveInputs, output, ctx);
       return output;
@@ -271,6 +370,13 @@ export class Executor {
     }
   }
 
+  private _validateOutput(mod: Record<string, unknown>, output: Record<string, unknown>): void {
+    const outputSchema = mod['outputSchema'] as TSchema | undefined;
+    if (outputSchema != null) {
+      this._validateSchema(outputSchema, output, 'Output');
+    }
+  }
+
   validate(moduleId: string, inputs: Record<string, unknown>): ValidationResult {
     const module = this._registry.get(moduleId);
     if (module === null) {

package/src/index.ts

@@ -5,7 +5,7 @@
 // Core
 export { Context, createIdentity } from './context.js';
 export type { Identity } from './context.js';
-export { Registry } from './registry/registry.js';
+export { Registry, REGISTRY_EVENTS, MODULE_ID_PATTERN } from './registry/registry.js';
 export { Executor, redactSensitive, REDACTED_VALUE } from './executor.js';
 
 // Module types
@@ -42,7 +42,11 @@ export {
   BindingFileInvalidError,
   CircularDependencyError,
   ModuleLoadError,
+  ModuleExecuteError,
+  InternalError,
+  ErrorCodes,
 } from './errors.js';
+export type { ErrorCode } from './errors.js';
 
 // ACL
 export { ACL } from './acl.js';

package/src/module.ts

@@ -11,6 +11,7 @@ export interface ModuleAnnotations {
   readonly idempotent: boolean;
   readonly requiresApproval: boolean;
   readonly openWorld: boolean;
+  readonly streaming: boolean;
 }
 
 export const DEFAULT_ANNOTATIONS: ModuleAnnotations = Object.freeze({
@@ -19,6 +20,7 @@ export const DEFAULT_ANNOTATIONS: ModuleAnnotations = Object.freeze({
   idempotent: false,
   requiresApproval: false,
   openWorld: true,
+  streaming: false,
 });
 
 export interface ModuleExample {

package/src/registry/registry.ts

@@ -13,6 +13,20 @@ import { scanExtensions, scanMultiRoot } from './scanner.js';
 import type { DependencyInfo, ModuleDescriptor } from './types.js';
 import { validateModule } from './validation.js';
 
+/**
+ * Standard registry event names.
+ */
+export const REGISTRY_EVENTS = Object.freeze({
+  REGISTER: "register",
+  UNREGISTER: "unregister",
+} as const);
+
+/**
+ * Valid module ID pattern. Only lowercase letters, digits, underscores, and dots.
+ * Hyphens are prohibited to ensure bijective MCP/OpenAI tool name normalization.
+ */
+export const MODULE_ID_PATTERN = /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/;
+
 type EventCallback = (moduleId: string, module: unknown) => void;
 
 export class Registry {
@@ -20,8 +34,8 @@ export class Registry {
   private _modules: Map<string, unknown> = new Map();
   private _moduleMeta: Map<string, Record<string, unknown>> = new Map();
   private _callbacks: Map<string, EventCallback[]> = new Map([
-    ['register', []],
-    ['unregister', []],
+    [REGISTRY_EVENTS.REGISTER, []],
+    [REGISTRY_EVENTS.UNREGISTER, []],
   ]);
   private _idMap: Record<string, Record<string, unknown>> = {};
   private _schemaCache: Map<string, Record<string, unknown>> = new Map();
@@ -187,15 +201,20 @@ export class Registry {
         }
       }
 
-      this._triggerEvent('register', modId, mod);
+      this._triggerEvent(REGISTRY_EVENTS.REGISTER, modId, mod);
       count++;
     }
     return count;
   }
 
   register(moduleId: string, module: unknown): void {
-    if (!moduleId) {
-      throw new InvalidInputError('module_id must be a non-empty string');
+    if (!moduleId || typeof moduleId !== "string") {
+      throw new InvalidInputError("Module ID must be a non-empty string");
+    }
+    if (!MODULE_ID_PATTERN.test(moduleId)) {
+      throw new InvalidInputError(
+        `Invalid module ID: "${moduleId}". Must match pattern: ${MODULE_ID_PATTERN} (lowercase, digits, underscores, dots only; no hyphens)`,
+      );
     }
 
     if (this._modules.has(moduleId)) {
@@ -215,7 +234,7 @@ export class Registry {
       }
     }
 
-    this._triggerEvent('register', moduleId, module);
+    this._triggerEvent(REGISTRY_EVENTS.REGISTER, moduleId, module);
   }
 
   unregister(moduleId: string): boolean {
@@ -236,7 +255,7 @@ export class Registry {
       }
     }
 
-    this._triggerEvent('unregister', moduleId, module);
+    this._triggerEvent(REGISTRY_EVENTS.UNREGISTER, moduleId, module);
     return true;
   }
 
@@ -311,8 +330,11 @@ export class Registry {
   }
 
   on(event: string, callback: EventCallback): void {
-    if (!this._callbacks.has(event)) {
-      throw new InvalidInputError(`Invalid event: ${event}. Must be 'register' or 'unregister'`);
+    const validEvents = Object.values(REGISTRY_EVENTS) as string[];
+    if (!validEvents.includes(event)) {
+      throw new InvalidInputError(
+        `Invalid event: ${event}. Must be one of: ${validEvents.map((e) => `'${e}'`).join(', ')}`,
+      );
     }
     this._callbacks.get(event)!.push(callback);
   }

package/src/schema/annotations.ts

@@ -11,6 +11,7 @@ const ANNOTATION_FIELDS: ReadonlyArray<keyof ModuleAnnotations> = [
   'idempotent',
   'requiresApproval',
   'openWorld',
+  'streaming',
 ];
 
 export function mergeAnnotations(

package/tests/integration/test-e2e-flow.test.ts

@@ -72,21 +72,21 @@ describe('E2E Flow', () => {
     });
     const modB = new FunctionModule({
       execute: (inputs) => ({ value: (inputs['x'] as number) + 10 }),
-      moduleId: 'math.addTen',
+      moduleId: 'math.add_ten',
       inputSchema: Type.Object({ x: Type.Number() }),
       outputSchema: Type.Object({ value: Type.Number() }),
       description: 'Add ten',
     });
     registry.register('math.double', modA);
-    registry.register('math.addTen', modB);
+    registry.register('math.add_ten', modB);
 
     const executor = new Executor({ registry });
-    const ctx = Context.create(executor, createIdentity('test-user'));
+    const ctx = Context.create(executor, createIdentity('test_user'));
 
     const r1 = await executor.call('math.double', { x: 5 }, ctx);
     expect(r1['value']).toBe(10);
 
-    const r2 = await executor.call('math.addTen', { x: r1['value'] as number }, ctx);
+    const r2 = await executor.call('math.add_ten', { x: r1['value'] as number }, ctx);
     expect(r2['value']).toBe(20);
   });
 

package/tests/registry/test-schema-export.test.ts

@@ -37,6 +37,7 @@ function createModule(
       idempotent: true,
       requiresApproval: false,
       openWorld: false,
+      streaming: false,
     },
     examples: [
       {

package/tests/schema/test-annotations.test.ts

@@ -25,6 +25,7 @@ describe('mergeAnnotations', () => {
       idempotent: true,
       requiresApproval: false,
       openWorld: false,
+      streaming: false,
     };
     const result = mergeAnnotations(null, codeAnnotations);
     expect(result.readonly).toBe(true);
@@ -39,6 +40,7 @@ describe('mergeAnnotations', () => {
       idempotent: false,
       requiresApproval: false,
       openWorld: true,
+      streaming: false,
     };
     const yamlAnnotations = { readonly: false, destructive: true };
     const result = mergeAnnotations(yamlAnnotations, codeAnnotations);

package/tests/schema/test-exporter.test.ts

@@ -55,6 +55,7 @@ describe('SchemaExporter', () => {
         idempotent: true,
         requiresApproval: false,
         openWorld: false,
+        streaming: false,
       };
       const result = exporter.exportMcp(sd, annotations, 'MyTool');
       expect(result['name']).toBe('MyTool');

package/tests/test-executor-stream.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect } from 'vitest';
+import { Type } from '@sinclair/typebox';
+import { Executor } from '../src/executor.js';
+import { FunctionModule } from '../src/decorator.js';
+import { Registry } from '../src/registry/registry.js';
+import { Middleware } from '../src/middleware/base.js';
+import { ModuleNotFoundError } from '../src/errors.js';
+
+function createSimpleModule(id: string): FunctionModule {
+  return new FunctionModule({
+    execute: (inputs) => ({ greeting: `Hello, ${inputs['name'] ?? 'world'}!` }),
+    moduleId: id,
+    inputSchema: Type.Object({ name: Type.Optional(Type.String()) }),
+    outputSchema: Type.Object({ greeting: Type.String() }),
+    description: 'Greet module',
+  });
+}
+
+/**
+ * Creates a module with a stream() async generator that yields chunks.
+ */
+function createStreamingModule(id: string): FunctionModule & { stream: (inputs: Record<string, unknown>) => AsyncGenerator<Record<string, unknown>> } {
+  const mod = new FunctionModule({
+    execute: (inputs) => ({ greeting: `Hello, ${inputs['name'] ?? 'world'}!` }),
+    moduleId: id,
+    inputSchema: Type.Object({ name: Type.Optional(Type.String()) }),
+    outputSchema: Type.Object({ greeting: Type.String() }),
+    description: 'Streaming greet module',
+  });
+
+  // Attach a stream method to the module
+  const streamingMod = mod as FunctionModule & { stream: (inputs: Record<string, unknown>) => AsyncGenerator<Record<string, unknown>> };
+  streamingMod.stream = async function* (inputs: Record<string, unknown>): AsyncGenerator<Record<string, unknown>> {
+    const name = (inputs['name'] as string) ?? 'world';
+    yield { greeting: `Hello, ` };
+    yield { greeting: `${name}` };
+    yield { greeting: `!` };
+  };
+
+  return streamingMod;
+}
+
+async function collectChunks(gen: AsyncGenerator<Record<string, unknown>>): Promise<Record<string, unknown>[]> {
+  const chunks: Record<string, unknown>[] = [];
+  for await (const chunk of gen) {
+    chunks.push(chunk);
+  }
+  return chunks;
+}
+
+describe('Executor.stream()', () => {
+  it('falls back to single chunk when module has no stream()', async () => {
+    const registry = new Registry();
+    const mod = createSimpleModule('greet');
+    registry.register('greet', mod);
+
+    const executor = new Executor({ registry });
+    const chunks = await collectChunks(executor.stream('greet', { name: 'Alice' }));
+
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]['greeting']).toBe('Hello, Alice!');
+  });
+
+  it('yields multiple chunks from streaming module', async () => {
+    const registry = new Registry();
+    const mod = createStreamingModule('greet');
+    registry.register('greet', mod);
+
+    const executor = new Executor({ registry });
+    const chunks = await collectChunks(executor.stream('greet', { name: 'Bob' }));
+
+    expect(chunks.length).toBeGreaterThan(1);
+    expect(chunks[0]['greeting']).toBe('Hello, ');
+    expect(chunks[1]['greeting']).toBe('Bob');
+    expect(chunks[2]['greeting']).toBe('!');
+  });
+
+  it('throws ModuleNotFoundError for unknown module', async () => {
+    const registry = new Registry();
+    const executor = new Executor({ registry });
+
+    const chunks: Record<string, unknown>[] = [];
+    await expect(async () => {
+      for await (const chunk of executor.stream('nonexistent')) {
+        chunks.push(chunk);
+      }
+    }).rejects.toThrow(ModuleNotFoundError);
+  });
+
+  it('runs before-middleware before streaming and after-middleware on accumulated result', async () => {
+    const registry = new Registry();
+    const mod = createStreamingModule('echo');
+    registry.register('echo', mod);
+
+    const calls: string[] = [];
+    class TrackingMiddleware extends Middleware {
+      override before() { calls.push('before'); return null; }
+      override after() { calls.push('after'); return null; }
+    }
+
+    const executor = new Executor({ registry, middlewares: [new TrackingMiddleware()] });
+    const chunks = await collectChunks(executor.stream('echo', { name: 'Test' }));
+
+    expect(chunks.length).toBeGreaterThan(0);
+    expect(calls).toContain('before');
+    expect(calls).toContain('after');
+    // before must come first
+    expect(calls.indexOf('before')).toBeLessThan(calls.indexOf('after'));
+  });
+
+  it('runs before-middleware before fallback and after-middleware on result', async () => {
+    const registry = new Registry();
+    const mod = createSimpleModule('echo');
+    registry.register('echo', mod);
+
+    const calls: string[] = [];
+    class TrackingMiddleware extends Middleware {
+      override before() { calls.push('before'); return null; }
+      override after() { calls.push('after'); return null; }
+    }
+
+    const executor = new Executor({ registry, middlewares: [new TrackingMiddleware()] });
+    const chunks = await collectChunks(executor.stream('echo', { name: 'Test' }));
+
+    expect(chunks).toHaveLength(1);
+    expect(calls).toEqual(['before', 'after']);
+  });
+
+  it('handles middleware error recovery in streaming mode', async () => {
+    const registry = new Registry();
+    const failMod = new FunctionModule({
+      execute: () => { throw new Error('stream-boom'); },
+      moduleId: 'fail',
+      inputSchema: Type.Object({}),
+      outputSchema: Type.Object({}),
+      description: 'Failing module',
+    });
+    registry.register('fail', failMod);
+
+    class RecoveryMiddleware extends Middleware {
+      override onError() { return { recovered: true }; }
+    }
+
+    const executor = new Executor({ registry, middlewares: [new RecoveryMiddleware()] });
+    // Non-streaming module fallback with error should recover
+    const chunks = await collectChunks(executor.stream('fail'));
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]['recovered']).toBe(true);
+  });
+
+  it('accumulates chunks via shallow merge for after-middleware', async () => {
+    const registry = new Registry();
+    const mod = {
+      description: 'multi-key streaming module',
+      inputSchema: Type.Object({ prefix: Type.String() }),
+      outputSchema: Type.Object({ a: Type.Optional(Type.String()), b: Type.Optional(Type.String()) }),
+      execute: async (inputs: Record<string, unknown>) => ({ a: `${inputs['prefix']}_a`, b: `${inputs['prefix']}_b` }),
+      async *stream(inputs: Record<string, unknown>) {
+        yield { a: `${inputs['prefix']}_a` };
+        yield { b: `${inputs['prefix']}_b` };
+      },
+    };
+    registry.register('multi', mod);
+
+    let afterOutput: Record<string, unknown> | null = null;
+    const executor = new Executor({ registry });
+    executor.useAfter((_mid, _inputs, output) => {
+      afterOutput = { ...output };
+      return null;
+    });
+
+    const chunks: Record<string, unknown>[] = [];
+    for await (const chunk of executor.stream('multi', { prefix: 'test' })) {
+      chunks.push(chunk);
+    }
+
+    expect(chunks).toHaveLength(2);
+    expect(chunks[0]).toEqual({ a: 'test_a' });
+    expect(chunks[1]).toEqual({ b: 'test_b' });
+    // After-middleware should receive the MERGED result
+    expect(afterOutput).toEqual({ a: 'test_a', b: 'test_b' });
+  });
+
+  it('validates output schema on accumulated streaming result', async () => {
+    const registry = new Registry();
+    const mod = new FunctionModule({
+      execute: () => ({ greeting: 'fallback' }),
+      moduleId: 'validated',
+      inputSchema: Type.Object({}),
+      outputSchema: Type.Object({ greeting: Type.String() }),
+      description: 'Validated module',
+    });
+
+    // Attach a stream that produces valid accumulated output
+    const streamingMod = mod as FunctionModule & { stream: (inputs: Record<string, unknown>) => AsyncGenerator<Record<string, unknown>> };
+    streamingMod.stream = async function* (): AsyncGenerator<Record<string, unknown>> {
+      yield { greeting: 'chunk1' };
+      yield { greeting: 'chunk2' };
+    };
+
+    registry.register('validated', streamingMod);
+
+    const executor = new Executor({ registry });
+    // The last chunk is used as the accumulated output for validation
+    const chunks = await collectChunks(executor.stream('validated'));
+    expect(chunks).toHaveLength(2);
+  });
+});

package/tests/test-executor.test.ts

@@ -221,16 +221,16 @@ describe('Executor', () => {
     let capturedCtx: Context | null = null;
     const mod = new FunctionModule({
       execute: (_inputs, ctx) => { capturedCtx = ctx; return { ok: true }; },
-      moduleId: 'ctx-test',
+      moduleId: 'ctx_test',
       inputSchema: Type.Object({}),
       outputSchema: Type.Object({ ok: Type.Boolean() }),
       description: 'Context capture',
     });
-    registry.register('ctx-test', mod);
+    registry.register('ctx_test', mod);
 
     const executor = new Executor({ registry });
     const ctx = Context.create(executor, createIdentity('user1'));
-    await executor.call('ctx-test', {}, ctx);
+    await executor.call('ctx_test', {}, ctx);
 
     expect(capturedCtx).not.toBeNull();
     expect(capturedCtx!.traceId).toBe(ctx.traceId);