cognitive-modules-cli 2.2.5 → 2.2.7

package/CHANGELOG.md

@@ -2,7 +2,7 @@
 
 All notable changes to this package are documented in this file.
 
-## 2.2.5 - 2026-02-06
+## 2.2.7 - 2026-02-06
 
 - Standardized v2.2 runtime behavior and cross-surface error envelope consistency (CLI/HTTP/MCP).
 - Clarified `compose` output contract: default/pretty output returns full v2.2 envelope, while `compose --trace` returns a debug wrapper object (`result/moduleResults/trace/totalTimeMs`) for diagnostics.

package/README.md

@@ -10,12 +10,12 @@ Node.js/TypeScript 版本的 Cognitive Modules CLI，提供 `cog` 命令。
 
 ```bash
 # 全局安装（推荐）
-npm install -g cogn@2.2.5
+npm install -g cogn@2.2.7
 # 或使用完整包名（同样提供 `cog` 命令）
-# npm install -g cognitive-modules-cli@2.2.5
+# npm install -g cognitive-modules-cli@2.2.7
 
 # 或使用 npx 零安装
-npx cogn@2.2.5 --help
+npx cogn@2.2.7 --help
 ```
 
 ## 快速开始

package/dist/cli.js

@@ -41,6 +41,7 @@ async function main() {
             pretty: { type: 'boolean', default: false },
             verbose: { type: 'boolean', short: 'V', default: false },
             'no-validate': { type: 'boolean', default: false },
+            stream: { type: 'boolean', default: false },
             // Add/update options
             name: { type: 'string', short: 'n' },
             tag: { type: 'string', short: 't' },
@@ -92,6 +93,7 @@ async function main() {
                     noValidate: values['no-validate'],
                     pretty: values.pretty,
                     verbose: values.verbose,
+                    stream: values.stream,
                 });
                 if (!result.success) {
                     if (result.data) {
@@ -102,7 +104,10 @@ async function main() {
                     }
                     process.exit(1);
                 }
-                console.log(JSON.stringify(result.data, null, values.pretty ? 2 : 0));
+                // Stream mode prints events as NDJSON already.
+                if (!values.stream) {
+                    console.log(JSON.stringify(result.data, null, values.pretty ? 2 : 0));
+                }
                 break;
             }
             case 'list': {

package/dist/commands/add.js

@@ -9,13 +9,15 @@
  *   cog add ziel-io/cognitive-modules -m code-simplifier
  *   cog add https://github.com/org/repo --module name --tag v1.0.0
  */
-import { createWriteStream, existsSync, mkdirSync, rmSync, readdirSync, statSync, copyFileSync } from 'node:fs';
+import { createWriteStream, existsSync, mkdirSync, rmSync, readdirSync, statSync, copyFileSync, lstatSync } from 'node:fs';
 import { writeFile, readFile, mkdir } from 'node:fs/promises';
-import { pipeline } from 'node:stream/promises';
+import { pipeline, finished } from 'node:stream/promises';
 import { Readable } from 'node:stream';
 import { join, basename, dirname, resolve, sep, isAbsolute } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
 import { RegistryClient } from '../registry/client.js';
+import { extractTarGzFile } from '../registry/tar.js';
 // Module storage paths
 const USER_MODULES_DIR = join(homedir(), '.cognitive', 'modules');
 const INSTALLED_MANIFEST = join(homedir(), '.cognitive', 'installed.json');
@@ -153,7 +155,11 @@ function copyDir(src, dest) {
     for (const entry of readdirSync(src)) {
         const srcPath = join(src, entry);
         const destPath = join(dest, entry);
-        if (statSync(srcPath).isDirectory()) {
+        const st = lstatSync(srcPath);
+        if (st.isSymbolicLink()) {
+            throw new Error(`Refusing to install module containing symlink: ${srcPath}`);
+        }
+        if (st.isDirectory()) {
             copyDir(srcPath, destPath);
         }
         else {
@@ -161,6 +167,74 @@ function copyDir(src, dest) {
         }
     }
 }
+async function downloadTarballWithSha256(url, outPath, maxBytes) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10_000);
+    const hash = createHash('sha256');
+    let received = 0;
+    const fileStream = createWriteStream(outPath);
+    try {
+        const response = await fetch(url, {
+            headers: { 'User-Agent': 'cognitive-runtime/2.2' },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to download tarball: ${response.status} ${response.statusText}`);
+        }
+        const contentLengthHeader = response.headers?.get?.('content-length');
+        if (contentLengthHeader) {
+            const contentLength = Number(contentLengthHeader);
+            if (!Number.isNaN(contentLength) && contentLength > maxBytes) {
+                throw new Error(`Tarball too large: ${contentLength} bytes (max ${maxBytes})`);
+            }
+        }
+        if (!response.body) {
+            throw new Error('Tarball response has no body');
+        }
+        const reader = response.body.getReader?.();
+        if (!reader) {
+            // Fallback: stream pipeline without incremental hash.
+            await pipeline(Readable.fromWeb(response.body), fileStream);
+            const content = await readFile(outPath);
+            return createHash('sha256').update(content).digest('hex');
+        }
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value) {
+                received += value.byteLength;
+                if (received > maxBytes) {
+                    controller.abort();
+                    throw new Error(`Tarball too large: ${received} bytes (max ${maxBytes})`);
+                }
+                const chunk = Buffer.from(value);
+                hash.update(chunk);
+                if (!fileStream.write(chunk)) {
+                    await new Promise((resolve) => fileStream.once('drain', () => resolve()));
+                }
+            }
+        }
+        fileStream.end();
+        await finished(fileStream);
+        return hash.digest('hex');
+    }
+    catch (error) {
+        try {
+            fileStream.destroy();
+        }
+        catch {
+            // ignore
+        }
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error('Tarball download timed out after 10000ms');
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 /**
  * Get module version from module.yaml or MODULE.md
  */
@@ -266,6 +340,7 @@ function parseModuleSpec(spec) {
 export async function addFromRegistry(moduleSpec, ctx, options = {}) {
     const { name: moduleName, version: requestedVersion } = parseModuleSpec(moduleSpec);
     const { name: customName, registry: registryUrl } = options;
+    let tempDir;
     try {
         const client = new RegistryClient(registryUrl);
         const moduleInfo = await client.getModule(moduleName);
@@ -325,10 +400,83 @@ export async function addFromRegistry(moduleSpec, ctx, options = {}) {
             }
             return result;
         }
-        // For tarball sources, download directly (future implementation)
+        // Tarball sources: require checksum, verify, and extract safely.
+        if (!downloadInfo.url.startsWith('http')) {
+            return { success: false, error: `Unsupported registry download URL: ${downloadInfo.url}` };
+        }
+        if (!downloadInfo.checksum) {
+            return {
+                success: false,
+                error: `Registry tarball missing checksum (required for safe install): ${moduleName}`,
+            };
+        }
+        tempDir = join(tmpdir(), `cog-reg-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        const tarPath = join(tempDir, 'module.tar.gz');
+        const MAX_TARBALL_BYTES = 20 * 1024 * 1024; // 20MB
+        const actualSha256 = await downloadTarballWithSha256(downloadInfo.url, tarPath, MAX_TARBALL_BYTES);
+        const expected = downloadInfo.checksum;
+        const checksumMatch = expected.match(/^sha256:([a-f0-9]{64})$/);
+        if (!checksumMatch) {
+            throw new Error(`Unsupported checksum format (expected sha256:<64hex>): ${expected}`);
+        }
+        const expectedHash = checksumMatch[1];
+        if (actualSha256 !== expectedHash) {
+            throw new Error(`Checksum mismatch for ${moduleName}: expected ${expectedHash}, got ${actualSha256}`);
+        }
+        const extractedRoot = join(tempDir, 'pkg');
+        mkdirSync(extractedRoot, { recursive: true });
+        await extractTarGzFile(tarPath, extractedRoot, {
+            maxFiles: 5_000,
+            maxTotalBytes: 50 * 1024 * 1024,
+            maxSingleFileBytes: 20 * 1024 * 1024,
+            maxTarBytes: 100 * 1024 * 1024,
+        });
+        // Find module directory inside extractedRoot.
+        const rootNames = readdirSync(extractedRoot).filter((e) => e !== '__MACOSX' && e !== '.DS_Store');
+        const rootPaths = rootNames.map((e) => join(extractedRoot, e)).filter((p) => existsSync(p));
+        const rootDirs = rootPaths.filter((p) => statSync(p).isDirectory());
+        const rootFiles = rootPaths.filter((p) => !statSync(p).isDirectory());
+        if (rootDirs.length === 0) {
+            throw new Error('Tarball extraction produced no root directory');
+        }
+        if (rootDirs.length !== 1 || rootFiles.length > 0) {
+            throw new Error(`Tarball must contain exactly one module root directory and no other top-level entries. ` +
+                `dirs=${rootDirs.map((p) => basename(p)).join(',') || '(none)'} files=${rootFiles.map((p) => basename(p)).join(',') || '(none)'}`);
+        }
+        // Strict mode: require root dir itself to be a valid module.
+        const sourcePath = rootDirs[0];
+        if (!isValidModule(sourcePath)) {
+            throw new Error('Root directory in tarball is not a valid module');
+        }
+        const installName = (customName || moduleName);
+        const safeInstallName = assertSafeModuleName(installName);
+        const targetPath = resolveModuleTarget(safeInstallName);
+        if (existsSync(targetPath)) {
+            rmSync(targetPath, { recursive: true, force: true });
+        }
+        await mkdir(USER_MODULES_DIR, { recursive: true });
+        copyDir(sourcePath, targetPath);
+        const version = await getModuleVersion(sourcePath);
+        await recordInstall(safeInstallName, {
+            source: downloadInfo.url,
+            githubUrl: downloadInfo.url,
+            version,
+            installedAt: targetPath,
+            installedTime: new Date().toISOString(),
+            registryModule: moduleName,
+            registryUrl,
+        });
         return {
-            success: false,
-            error: `Tarball downloads not yet supported. Source: ${moduleInfo.source}`,
+            success: true,
+            data: {
+                message: `Added: ${safeInstallName}${version ? ` v${version}` : ''} (registry tarball)`,
+                name: safeInstallName,
+                version,
+                location: targetPath,
+                source: 'registry',
+                registryModule: moduleName,
+            },
         };
     }
     catch (error) {
@@ -337,6 +485,16 @@ export async function addFromRegistry(moduleSpec, ctx, options = {}) {
             error: error instanceof Error ? error.message : String(error),
         };
     }
+    finally {
+        if (tempDir) {
+            try {
+                rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
 }
 /**
  * Add a module from GitHub

package/dist/commands/run.d.ts

@@ -9,5 +9,6 @@ export interface RunOptions {
     noValidate?: boolean;
     pretty?: boolean;
     verbose?: boolean;
+    stream?: boolean;
 }
 export declare function run(moduleName: string, ctx: CommandContext, options?: RunOptions): Promise<CommandResult>;

package/dist/commands/run.js

@@ -2,7 +2,7 @@
  * cog run - Run a Cognitive Module
  * Always returns v2.2 envelope format for consistency
  */
-import { findModule, getDefaultSearchPaths, runModule } from '../modules/index.js';
+import { findModule, getDefaultSearchPaths, runModule, runModuleStream } from '../modules/index.js';
 import { ErrorCodes, attachContext, makeErrorEnvelope } from '../errors/index.js';
 export async function run(moduleName, ctx, options = {}) {
     const searchPaths = getDefaultSearchPaths(ctx.cwd);
@@ -40,24 +40,47 @@ export async function run(moduleName, ctx, options = {}) {
                 };
             }
         }
-        // Run module with v2.2 envelope format
-        const result = await runModule(module, ctx.provider, {
-            args: options.args,
-            input: inputData,
-            verbose: options.verbose || ctx.verbose,
-            validateInput: !options.noValidate,
-            validateOutput: !options.noValidate,
-            useV22: true, // Always use v2.2 envelope
-        });
-        const output = attachContext(result, {
-            module: moduleName,
-            provider: ctx.provider.name,
-        });
-        // Always return full v2.2 envelope
-        return {
-            success: result.ok,
-            data: output,
-        };
+        if (options.stream) {
+            // Stream NDJSON events to stdout. Final exit code is determined by the end event.
+            let finalOk = null;
+            for await (const ev of runModuleStream(module, ctx.provider, {
+                args: options.args,
+                input: inputData,
+                validateInput: !options.noValidate,
+                validateOutput: !options.noValidate,
+                useV22: true,
+            })) {
+                // Write each event as one JSON line (NDJSON).
+                process.stdout.write(JSON.stringify(ev) + '\n');
+                if (ev.type === 'end' && ev.result) {
+                    finalOk = Boolean(ev.result.ok);
+                }
+            }
+            return {
+                success: finalOk === true,
+                data: { ok: finalOk === true },
+            };
+        }
+        else {
+            // Run module with v2.2 envelope format
+            const result = await runModule(module, ctx.provider, {
+                args: options.args,
+                input: inputData,
+                verbose: options.verbose || ctx.verbose,
+                validateInput: !options.noValidate,
+                validateOutput: !options.noValidate,
+                useV22: true, // Always use v2.2 envelope
+            });
+            const output = attachContext(result, {
+                module: moduleName,
+                provider: ctx.provider.name,
+            });
+            // Always return full v2.2 envelope
+            return {
+                success: result.ok,
+                data: output,
+            };
+        }
     }
     catch (e) {
         const message = e instanceof Error ? e.message : String(e);

package/dist/errors/index.d.ts

@@ -112,6 +112,13 @@ export interface ErrorEnvelopeOptions {
  */
 export declare function makeErrorEnvelope(options: ErrorEnvelopeOptions): CognitiveErrorEnvelope;
 export declare function attachContext<T extends object>(envelope: T, context?: EnvelopeContext): T & EnvelopeContext;
+/**
+ * Map a CEP error code to an HTTP status code.
+ *
+ * This is used to keep HTTP behavior consistent with the error model while
+ * allowing callers to attach context without rebuilding envelopes.
+ */
+export declare function httpStatusForErrorCode(code: string): number;
 /**
  * Create error envelope for HTTP API responses.
  *

package/dist/errors/index.js

@@ -191,54 +191,47 @@ export function attachContext(envelope, context) {
     };
 }
 /**
- * Create error envelope for HTTP API responses.
+ * Map a CEP error code to an HTTP status code.
  *
- * @returns Tuple of [statusCode, body]
+ * This is used to keep HTTP behavior consistent with the error model while
+ * allowing callers to attach context without rebuilding envelopes.
  */
-export function makeHttpError(options) {
-    const envelope = attachContext(makeErrorEnvelope(options), options);
-    const code = normalizeErrorCode(options.code);
-    // Determine HTTP status code
-    let statusCode;
-    const category = code.charAt(1);
+export function httpStatusForErrorCode(code) {
+    const normalized = normalizeErrorCode(code);
+    const category = normalized.charAt(1);
     switch (category) {
         case '1': {
             // Input errors -> Bad Request (with specific overrides)
-            if (code === ErrorCodes.INPUT_TOO_LARGE) {
-                statusCode = 413; // Payload Too Large
-            }
-            else {
-                statusCode = 400;
-            }
-            break;
+            if (normalized === ErrorCodes.INPUT_TOO_LARGE)
+                return 413;
+            return 400;
         }
-        case '2':
-            statusCode = 422;
-            break; // Processing errors -> Unprocessable Entity
-        case '3':
-            statusCode = 500;
-            break; // Output errors -> Internal Server Error
+        case '2': return 422; // Processing errors -> Unprocessable Entity
+        case '3': return 500; // Output errors -> Internal Server Error
         case '4': {
-            // Runtime errors - map to appropriate HTTP status
-            if (code === ErrorCodes.MODULE_NOT_FOUND ||
-                code === ErrorCodes.ENDPOINT_NOT_FOUND ||
-                code === ErrorCodes.RESOURCE_NOT_FOUND) {
-                statusCode = 404; // Not Found
-            }
-            else if (code === ErrorCodes.PERMISSION_DENIED) {
-                statusCode = 403; // Forbidden
-            }
-            else if (code === ErrorCodes.RATE_LIMITED) {
-                statusCode = 429; // Too Many Requests
+            // Runtime errors -> map to appropriate HTTP status
+            if (normalized === ErrorCodes.MODULE_NOT_FOUND ||
+                normalized === ErrorCodes.ENDPOINT_NOT_FOUND ||
+                normalized === ErrorCodes.RESOURCE_NOT_FOUND) {
+                return 404;
             }
-            else {
-                statusCode = 500; // Internal Server Error
-            }
-            break;
+            if (normalized === ErrorCodes.PERMISSION_DENIED)
+                return 403;
+            if (normalized === ErrorCodes.RATE_LIMITED)
+                return 429;
+            return 500;
         }
-        default: statusCode = 500;
+        default: return 500;
     }
-    // Add HTTP-specific fields
+}
+/**
+ * Create error envelope for HTTP API responses.
+ *
+ * @returns Tuple of [statusCode, body]
+ */
+export function makeHttpError(options) {
+    const envelope = attachContext(makeErrorEnvelope(options), options);
+    const statusCode = httpStatusForErrorCode(String(options.code));
     return [statusCode, envelope];
 }
 /**
@@ -316,16 +309,31 @@ export function shouldRetry(envelope) {
  * Use this for consistent success responses across HTTP and MCP layers.
  */
 export function makeSuccessEnvelope(options) {
+    const explain = (options.explain || 'Operation completed successfully').slice(0, 280);
+    // Envelope schema requires data to be an object with at least `rationale`.
+    // For non-module operations (list/info), we still emit a conforming envelope by
+    // injecting a minimal rationale if missing, or wrapping non-objects.
+    const normalizedData = (() => {
+        const d = options.data;
+        const isPlainObject = typeof d === 'object' && d !== null && !Array.isArray(d);
+        if (!isPlainObject) {
+            return { result: d, rationale: explain };
+        }
+        const obj = d;
+        if (typeof obj.rationale === 'string')
+            return options.data;
+        return { ...obj, rationale: explain };
+    })();
     return {
         ok: true,
         version: options.version || '2.2',
         meta: {
             confidence: options.confidence ?? 1.0,
             risk: options.risk ?? 'none',
-            explain: (options.explain || 'Operation completed successfully').slice(0, 280),
+            explain,
             trace_id: options.trace_id,
         },
-        data: options.data,
+        data: normalizedData,
     };
 }
 /**

package/dist/modules/runner.d.ts

@@ -369,13 +369,15 @@ export interface RunOptions {
 }
 export declare function runModule(module: CognitiveModule, provider: Provider, options?: RunOptions): Promise<ModuleResult>;
 /** Event types emitted during streaming execution */
-export type StreamEventType = 'start' | 'chunk' | 'meta' | 'complete' | 'error';
+export type StreamEventType = 'start' | 'delta' | 'meta' | 'end' | 'error';
 /** Event emitted during streaming execution */
 export interface StreamEvent {
     type: StreamEventType;
+    version: string;
     timestamp_ms: number;
-    module_name: string;
-    chunk?: string;
+    module: string;
+    provider?: string;
+    delta?: string;
     meta?: EnvelopeMeta;
     result?: EnvelopeResponseV22<unknown>;
     error?: {
@@ -398,9 +400,9 @@ export interface StreamOptions {
  *
  * Yields StreamEvent objects as the module executes:
  * - type="start": Module execution started
- * - type="chunk": Incremental data chunk (if LLM supports streaming)
+ * - type="delta": Incremental output delta (provider streaming chunk)
  * - type="meta": Meta information available early
- * - type="complete": Final complete result
+ * - type="end": Final result envelope (always emitted)
  * - type="error": Error occurred
  *
  * @example

package/dist/modules/runner.js

@@ -1324,9 +1324,9 @@ export async function runModule(module, provider, options = {}) {
  *
  * Yields StreamEvent objects as the module executes:
  * - type="start": Module execution started
- * - type="chunk": Incremental data chunk (if LLM supports streaming)
+ * - type="delta": Incremental output delta (provider streaming chunk)
  * - type="meta": Meta information available early
- * - type="complete": Final complete result
+ * - type="end": Final result envelope (always emitted)
  * - type="error": Error occurred
  *
  * @example
@@ -1342,11 +1342,14 @@ export async function* runModuleStream(module, provider, options = {}) {
     const { input, args, validateInput = true, validateOutput = true, useV22 = true, enableRepair = true, traceId, model } = options;
     const startTime = Date.now();
     const moduleName = module.name;
+    const providerName = provider?.name;
     function makeEvent(type, extra = {}) {
         return {
             type,
+            version: ENVELOPE_VERSION,
             timestamp_ms: Date.now() - startTime,
-            module_name: moduleName,
+            module: moduleName,
+            ...(providerName ? { provider: providerName } : {}),
             ...extra,
         };
     }
@@ -1378,7 +1381,7 @@ export async function* runModuleStream(module, provider, options = {}) {
                 _invokeErrorHooks(module.name, new Error(inputErrors.join('; ')), null);
                 const errorObj = errorResult.error;
                 yield makeEvent('error', { error: errorObj });
-                yield makeEvent('complete', { result: errorResult });
+                yield makeEvent('end', { result: errorResult });
                 return;
             }
         }
@@ -1415,7 +1418,7 @@ export async function* runModuleStream(module, provider, options = {}) {
             let streamResult;
             while (!(streamResult = await stream.next()).done) {
                 const chunk = streamResult.value;
-                yield makeEvent('chunk', { chunk });
+                yield makeEvent('delta', { delta: chunk });
             }
             // Get the final result (returned from the generator)
             fullContent = streamResult.value.content;
@@ -1429,7 +1432,7 @@ export async function* runModuleStream(module, provider, options = {}) {
             });
             fullContent = result.content;
             // Emit chunk event with full response
-            yield makeEvent('chunk', { chunk: result.content });
+            yield makeEvent('delta', { delta: result.content });
         }
         // Parse response
         let parsed;
@@ -1448,7 +1451,7 @@ export async function* runModuleStream(module, provider, options = {}) {
             // errorResult is always an error response from makeErrorResponse
             const errorObj = errorResult.error;
             yield makeEvent('error', { error: errorObj });
-            yield makeEvent('complete', { result: errorResult });
+            yield makeEvent('end', { result: errorResult });
             return;
         }
         // Convert to v2.2 envelope
@@ -1502,7 +1505,7 @@ export async function* runModuleStream(module, provider, options = {}) {
                     _invokeErrorHooks(module.name, new Error(dataErrors.join('; ')), response.data);
                     const errorObj = errorResult.error;
                     yield makeEvent('error', { error: errorObj });
-                    yield makeEvent('complete', { result: errorResult });
+                    yield makeEvent('end', { result: errorResult });
                     return;
                 }
                 const overflowErrors = validateOverflowLimits(dataToValidate, module);
@@ -1517,7 +1520,7 @@ export async function* runModuleStream(module, provider, options = {}) {
                     _invokeErrorHooks(module.name, new Error(overflowErrors.join('; ')), dataToValidate);
                     const errorObj = errorResult.error;
                     yield makeEvent('error', { error: errorObj });
-                    yield makeEvent('complete', { result: errorResult });
+                    yield makeEvent('end', { result: errorResult });
                     return;
                 }
                 const enumErrors = validateEnumStrategy(dataToValidate, module);
@@ -1532,7 +1535,7 @@ export async function* runModuleStream(module, provider, options = {}) {
                     _invokeErrorHooks(module.name, new Error(enumErrors.join('; ')), dataToValidate);
                     const errorObj = errorResult.error;
                     yield makeEvent('error', { error: errorObj });
-                    yield makeEvent('complete', { result: errorResult });
+                    yield makeEvent('end', { result: errorResult });
                     return;
                 }
             }
@@ -1554,7 +1557,7 @@ export async function* runModuleStream(module, provider, options = {}) {
                         _invokeErrorHooks(module.name, new Error(metaErrors.join('; ')), response.data);
                         const errorObj = errorResult.error;
                         yield makeEvent('error', { error: errorObj });
-                        yield makeEvent('complete', { result: errorResult });
+                        yield makeEvent('end', { result: errorResult });
                         return;
                     }
                 }
@@ -1566,8 +1569,8 @@ export async function* runModuleStream(module, provider, options = {}) {
         }
         const finalLatencyMs = Date.now() - startTime;
         _invokeAfterHooks(module.name, response, finalLatencyMs);
-        // Emit complete event
-        yield makeEvent('complete', { result: response });
+        // Emit end event
+        yield makeEvent('end', { result: response });
     }
     catch (e) {
         _invokeErrorHooks(module.name, e, null);
@@ -1579,7 +1582,7 @@ export async function* runModuleStream(module, provider, options = {}) {
         // errorResult is always an error response from makeErrorResponse
         const errorObj = errorResult.error;
         yield makeEvent('error', { error: errorObj });
-        yield makeEvent('complete', { result: errorResult });
+        yield makeEvent('end', { result: errorResult });
     }
 }
 // =============================================================================