every-plugin 0.0.6 → 0.1.1

package/dist/runtime/services/plugin.service.js

@@ -1,127 +1,270 @@
-import { Duration, Effect, Layer, Schedule } from "effect";
+import { call } from "@orpc/server";
+import { Cache, Duration, Effect, Hash, Layer, Schedule } from "effect";
 import { PluginLoggerTag } from "../../plugin";
 import { PluginRuntimeError } from "../errors";
+import { createSourceStream } from "../streaming";
 import { validate } from "../validation";
-import { PluginCacheService } from "./plugin-cache.service";
+import { ModuleFederationService } from "./module-federation.service";
 import { SecretsService } from "./secrets.service";
 export class PluginService extends Effect.Tag("PluginService")() {
     static Live = (registry, secrets) => Layer.effect(PluginService, Effect.gen(function* () {
-        const cacheService = yield* PluginCacheService;
+        const moduleFederationService = yield* ModuleFederationService;
         const secretsService = yield* SecretsService;
         const logger = yield* PluginLoggerTag;
+        const activePlugins = new Set();
         const retrySchedule = Schedule.exponential(Duration.millis(100)).pipe(Schedule.compose(Schedule.recurs(2)));
         const resolveUrl = (baseUrl, version) => version && version !== "latest"
             ? baseUrl.replace("@latest", `@${version}`)
             : baseUrl;
-        return {
-            loadPlugin: (pluginId) => Effect.gen(function* () {
-                const metadata = registry[pluginId];
-                if (!metadata) {
-                    return yield* Effect.fail(new PluginRuntimeError({
-                        pluginId,
-                        operation: "load-plugin",
-                        cause: new Error(`Plugin ${pluginId} not found in registry`),
+        // Implementation functions
+        const loadPluginImpl = (pluginId) => Effect.gen(function* () {
+            const metadata = registry[pluginId];
+            if (!metadata) {
+                return yield* Effect.fail(new PluginRuntimeError({
+                    pluginId,
+                    operation: "load-plugin",
+                    cause: new Error(`Plugin ${pluginId} not found in registry`),
+                    retryable: false,
+                }));
+            }
+            const url = resolveUrl(metadata.remoteUrl);
+            // Register and load the remote constructor
+            yield* moduleFederationService.registerRemote(pluginId, url).pipe(Effect.mapError((error) => new PluginRuntimeError({
+                pluginId,
+                operation: "register-remote",
+                cause: error.cause,
+                retryable: true,
+            })));
+            logger.logDebug(`Trying to load ${pluginId}:${url}`);
+            const ctor = yield* moduleFederationService.loadRemoteConstructor(pluginId, url).pipe(Effect.mapError((error) => new PluginRuntimeError({
+                pluginId,
+                operation: "load-remote",
+                cause: error.cause,
+                retryable: false
+            })));
+            return {
+                ctor,
+                metadata: {
+                    pluginId,
+                    version: metadata.version,
+                    description: metadata.description,
+                    type: metadata.type,
+                },
+            };
+        });
+        const instantiatePluginImpl = (pluginConstructor) => Effect.gen(function* () {
+            const instance = yield* Effect.try({
+                try: () => new pluginConstructor.ctor(),
+                catch: (error) => new PluginRuntimeError({
+                    pluginId: pluginConstructor.metadata.pluginId,
+                    operation: "instantiate-plugin",
+                    cause: error instanceof Error ? error : new Error(String(error)),
+                    retryable: false,
+                }),
+            });
+            // Validate plugin ID matches
+            if (instance.id !== pluginConstructor.metadata.pluginId) {
+                return yield* Effect.fail(new PluginRuntimeError({
+                    pluginId: pluginConstructor.metadata.pluginId,
+                    operation: "validate-plugin-id",
+                    cause: new Error(`Plugin ID mismatch: expected ${pluginConstructor.metadata.pluginId}, got ${instance.id}`),
+                    retryable: false,
+                }));
+            }
+            return {
+                plugin: instance,
+                metadata: pluginConstructor.metadata,
+            };
+        });
+        const initializePluginImpl = (pluginInstance, config) => Effect.gen(function* () {
+            const { plugin } = pluginInstance;
+            // Validate raw config using plugin's Zod schema
+            const validatedConfig = yield* validate(plugin.configSchema, config, plugin.id, "config").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
+                pluginId: plugin.id,
+                operation: "validate-config",
+                cause: validationError.zodError,
+                retryable: false,
+            })));
+            // Hydrate secrets
+            const hydratedConfig = yield* secretsService.hydrateSecrets(validatedConfig, secrets);
+            // Validate hydrated config
+            const finalConfig = yield* validate(plugin.configSchema, hydratedConfig, plugin.id, "config").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
+                pluginId: plugin.id,
+                operation: "validate-hydrated-config",
+                cause: validationError.zodError,
+                retryable: false,
+            })));
+            // Initialize plugin with retry logic
+            const pluginLayer = Layer.succeed(PluginLoggerTag, logger);
+            yield* plugin.initialize(finalConfig).pipe(Effect.mapError((error) => new PluginRuntimeError({
+                pluginId: plugin.id,
+                operation: "initialize-plugin",
+                cause: error,
+                retryable: error.retryable ?? false,
+            })), Effect.retry(retrySchedule.pipe(Schedule.whileInput((error) => error.retryable))), Effect.provide(pluginLayer));
+            const initializedPlugin = {
+                plugin,
+                metadata: pluginInstance.metadata,
+                config: finalConfig, // TODO: config type
+            };
+            activePlugins.add(initializedPlugin);
+            return initializedPlugin;
+        });
+        // Cache functionality
+        const generateConfigHash = (config) => {
+            return Hash.structure(config).toString();
+        };
+        // Store original config by hash for cache lookup
+        const configByHash = new Map();
+        const cache = yield* Cache.make({
+            capacity: 1024,
+            timeToLive: Duration.minutes(60),
+            lookup: (cacheKey) => {
+                const [pluginId, configHash] = cacheKey.split(':');
+                if (!pluginId || !configHash) {
+                    return Effect.fail(new PluginRuntimeError({
+                        operation: "cache-lookup",
+                        cause: new Error(`Invalid cache key format: ${cacheKey}`),
                         retryable: false,
                     }));
                 }
-                const url = resolveUrl(metadata.remoteUrl);
-                const cacheKey = `${pluginId}:${url}`;
-                const cachedConstructor = yield* cacheService.getCachedConstructor(cacheKey);
-                return {
-                    ctor: cachedConstructor.ctor,
-                    metadata: {
-                        pluginId,
-                        version: metadata.version,
-                        description: metadata.description,
-                        type: metadata.type,
-                    },
-                };
-            }),
-            instantiatePlugin: (pluginConstructor) => Effect.gen(function* () {
-                const instance = yield* Effect.try({
-                    try: () => new pluginConstructor.ctor(),
-                    catch: (error) => new PluginRuntimeError({
-                        pluginId: pluginConstructor.metadata.pluginId,
-                        operation: "instantiate-plugin",
-                        cause: error instanceof Error ? error : new Error(String(error)),
-                        retryable: false,
-                    }),
-                });
-                // Validate plugin ID matches
-                if (instance.id !== pluginConstructor.metadata.pluginId) {
-                    return yield* Effect.fail(new PluginRuntimeError({
-                        pluginId: pluginConstructor.metadata.pluginId,
-                        operation: "validate-plugin-id",
-                        cause: new Error(`Plugin ID mismatch: expected ${pluginConstructor.metadata.pluginId}, got ${instance.id}`),
+                const config = configByHash.get(configHash);
+                if (!config) {
+                    return Effect.fail(new PluginRuntimeError({
+                        operation: "cache-lookup",
+                        cause: new Error(`No config found for hash: ${configHash}`),
                         retryable: false,
                     }));
                 }
-                return {
-                    plugin: instance,
-                    metadata: pluginConstructor.metadata,
-                };
-            }),
-            initializePlugin: (pluginInstance, config) => Effect.gen(function* () {
-                const { plugin } = pluginInstance;
-                // Validate raw config using plugin's Zod schema
-                const validatedConfig = yield* validate(plugin.configSchema, config, plugin.id, "config").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
+                return Effect.gen(function* () {
+                    const ctor = yield* loadPluginImpl(pluginId);
+                    const instance = yield* instantiatePluginImpl(ctor);
+                    return yield* initializePluginImpl(instance, config);
+                });
+            },
+        });
+        const usePluginImpl = (pluginId, config) => {
+            const configHash = generateConfigHash(config);
+            const cacheKey = `${pluginId}:${configHash}`;
+            // Store config for cache lookup
+            configByHash.set(configHash, config);
+            return cache.get(cacheKey).pipe(Effect.map(plugin => plugin));
+        };
+        // Extract executePlugin implementation for reuse
+        const executePluginImpl = (initializedPlugin, input) => Effect.gen(function* () {
+            const { plugin } = initializedPlugin;
+            // Validate input
+            const validatedInput = yield* validate(plugin.inputSchema, input, plugin.id, "input").pipe(Effect.mapError((validationError) => {
+                return new PluginRuntimeError({
                     pluginId: plugin.id,
-                    operation: "validate-config",
+                    operation: "validate-input",
                     cause: validationError.zodError,
                     retryable: false,
-                })));
-                // Hydrate secrets
-                const hydratedConfig = yield* secretsService.hydrateSecrets(validatedConfig, secrets);
-                // Validate hydrated config
-                const finalConfig = yield* validate(plugin.configSchema, hydratedConfig, plugin.id, "config").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
+                });
+            }));
+            // Get oRPC router and call procedure directly
+            const router = plugin.createRouter();
+            const procedureName = validatedInput.procedure;
+            if (!(procedureName in router)) {
+                return yield* Effect.fail(new PluginRuntimeError({
                     pluginId: plugin.id,
-                    operation: "validate-hydrated-config",
-                    cause: validationError.zodError,
+                    operation: "execute-plugin",
+                    cause: new Error(`Unknown procedure: ${procedureName}`),
                     retryable: false,
-                })));
-                // Initialize plugin with retry logic
-                const pluginLayer = Layer.succeed(PluginLoggerTag, logger);
-                yield* plugin
-                    .initialize(finalConfig)
-                    .pipe(Effect.mapError((error) => new PluginRuntimeError({
+                }));
+            }
+            const context = 'state' in validatedInput ? { state: validatedInput.state } : {};
+            const output = yield* Effect.tryPromise({
+                try: () => {
+                    const procedure = router[procedureName];
+                    if (!procedure) {
+                        throw new Error(`Procedure ${procedureName} not found in router`);
+                    }
+                    // Use oRPC call utility as per docs
+                    return call(procedure, validatedInput.input, { context });
+                },
+                catch: (error) => new PluginRuntimeError({
                     pluginId: plugin.id,
-                    operation: "initialize-plugin",
-                    cause: error,
-                    retryable: error.retryable ?? false,
-                })), Effect.retry(retrySchedule.pipe(Schedule.whileInput((error) => error.retryable))), Effect.provide(pluginLayer));
-                return {
-                    plugin,
-                    metadata: pluginInstance.metadata,
-                    config: finalConfig, // TODO: config type
-                };
-            }),
-            executePlugin: (initializedPlugin, input) => Effect.gen(function* () {
-                const { plugin } = initializedPlugin;
-                // Validate input
-                const validatedInput = yield* validate(plugin.inputSchema, input, plugin.id, "input").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
-                    pluginId: plugin.id,
-                    operation: "validate-input",
+                    operation: "execute-plugin",
+                    cause: error instanceof Error ? error : new Error(String(error)),
+                    retryable: true,
+                }),
+            }).pipe(Effect.retry(retrySchedule.pipe(Schedule.whileInput((error) => error.retryable))));
+            return output;
+        });
+        return {
+            loadPlugin: loadPluginImpl,
+            instantiatePlugin: instantiatePluginImpl,
+            initializePlugin: initializePluginImpl,
+            executePlugin: executePluginImpl,
+            usePlugin: usePluginImpl,
+            streamPlugin: (pluginId, config, input, options) => Effect.gen(function* () {
+                const initializedPlugin = yield* usePluginImpl(pluginId, config);
+                // Check if procedure is streamable and validate state
+                const procedureName = input.procedure;
+                const isStreamable = initializedPlugin.plugin.isStreamable(procedureName);
+                if (!isStreamable) {
+                    return yield* Effect.fail(new PluginRuntimeError({
+                        pluginId,
+                        operation: "stream-plugin-validate",
+                        cause: new Error(`Procedure ${procedureName} is not streamable`),
+                        retryable: false,
+                    }));
+                }
+                // Check stateSchema exists for streamable procedures
+                if (!('stateSchema' in initializedPlugin.plugin) || !initializedPlugin.plugin.stateSchema) {
+                    return yield* Effect.fail(new PluginRuntimeError({
+                        pluginId: initializedPlugin.plugin.id,
+                        operation: "validate-state",
+                        cause: new Error(`Streamable plugin ${initializedPlugin.plugin.id} must have a stateSchema`),
+                        retryable: false,
+                    }));
+                }
+                // Validate initial state
+                yield* validate(initializedPlugin.plugin.stateSchema, input.state, initializedPlugin.plugin.id, "state").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
+                    pluginId: initializedPlugin.plugin.id,
+                    operation: "validate-state",
                     cause: validationError.zodError,
                     retryable: false,
                 })));
-                // Execute plugin
+                // Create and return the stream
+                return createSourceStream(initializedPlugin, executePluginImpl, input, options);
+            }),
+            shutdownPlugin: (plugin) => Effect.gen(function* () {
                 const pluginLayer = Layer.succeed(PluginLoggerTag, logger);
-                const output = yield* plugin
-                    .execute(validatedInput)
-                    .pipe(Effect.mapError((error) => new PluginRuntimeError({
-                    pluginId: plugin.id,
-                    operation: "execute-plugin",
+                // Remove from active plugins
+                activePlugins.delete(plugin);
+                // Try to invalidate from cache if it exists there
+                const configHash = generateConfigHash(plugin.config);
+                const cacheKey = `${plugin.plugin.id}:${configHash}`;
+                yield* cache.invalidate(cacheKey).pipe(Effect.catchAll(() => Effect.void) // Ignore if not in cache
+                );
+                // Clean up config hash
+                configByHash.delete(configHash);
+                // Shutdown the plugin
+                yield* plugin.plugin.shutdown().pipe(Effect.mapError((error) => new PluginRuntimeError({
+                    pluginId: plugin.plugin.id,
+                    operation: "shutdown-plugin",
                     cause: error,
-                    retryable: error.retryable ?? false,
-                })), Effect.retry(retrySchedule.pipe(Schedule.whileInput((error) => error.retryable))), Effect.provide(pluginLayer));
-                // Validate output
-                const validatedOutput = yield* validate(plugin.outputSchema, output, plugin.id, "output").pipe(Effect.mapError((validationError) => new PluginRuntimeError({
-                    pluginId: plugin.id,
-                    operation: "validate-output",
-                    cause: validationError.zodError,
                     retryable: false,
-                })));
-                return validatedOutput;
+                })), Effect.provide(pluginLayer));
+            }),
+            clearCache: () => Effect.sync(() => {
+                configByHash.clear();
+            }),
+            cleanup: () => Effect.gen(function* () {
+                const pluginLayer = Layer.succeed(PluginLoggerTag, logger);
+                // Call shutdown on all active plugins
+                for (const initializedPlugin of activePlugins) {
+                    yield* initializedPlugin.plugin.shutdown().pipe(Effect.catchAll((error) => {
+                        // Log shutdown errors but don't fail the cleanup
+                        return logger.logError(`Failed to shutdown plugin ${initializedPlugin.plugin.id}`, error, { pluginId: initializedPlugin.plugin.id });
+                    }), Effect.provide(pluginLayer));
+                }
+                // Clear the active plugins set
+                activePlugins.clear();
+                // Clear cache
+                configByHash.clear();
             }),
         };
     }));

package/dist/runtime/services/secrets.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secrets.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/secrets.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,cAAc,EAAE,CACvB,MAAM,EAAE,GAAG,EAAE,QAAQ;IACrB,aAAa,EAAE,aAAa,KACzB,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC;CAC7C;;;;AAED,qBAAa,cAAe,SAAQ,mBAGjC;IACD,MAAM,CAAC,IAAI,GAAI,SAAS,aAAa,+CAgChC;CACN;AAED,eAAO,MAAM,iBAAiB,uBAAiB,CAAC;AAChD,eAAO,MAAM,kBAAkB,YApCL,aAAa,8CAoCc,CAAC"}
+{"version":3,"file":"secrets.service.d.ts","sourceRoot":"","sources":["../../../src/runtime/services/secrets.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,cAAc,EAAE,CACxB,MAAM,EAAE,GAAG,EAAE,QAAQ;IACrB,aAAa,EAAE,aAAa,KACxB,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC;CAC5C;;;;AAED,qBAAa,cAAe,SAAQ,mBAGjC;IACF,MAAM,CAAC,IAAI,GAAI,SAAS,aAAa,+CAiCjC;CACJ;AAED,eAAO,MAAM,iBAAiB,uBAAiB,CAAC;AAChD,eAAO,MAAM,kBAAkB,YArCN,aAAa,8CAqCe,CAAC"}

package/dist/runtime/services.d.ts

@@ -1,5 +1,4 @@
 export * from "./services/module-federation.service";
 export * from "./services/plugin.service";
-export * from "./services/plugin-cache.service";
 export * from "./services/secrets.service";
 //# sourceMappingURL=services.d.ts.map

package/dist/runtime/services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/runtime/services.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/runtime/services.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC"}

package/dist/runtime/services.js

@@ -1,4 +1,3 @@
 export * from "./services/module-federation.service";
 export * from "./services/plugin.service";
-export * from "./services/plugin-cache.service";
 export * from "./services/secrets.service";

package/dist/runtime/streaming/index.d.ts

@@ -0,0 +1,4 @@
+export { pipe, StateTransitions } from './state-effects';
+export { createSourceStream } from './streaming';
+export type { StreamingOptions, StreamState } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/streaming/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/streaming/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/runtime/streaming/index.js

@@ -0,0 +1,2 @@
+export { pipe, StateTransitions } from './state-effects';
+export { createSourceStream } from './streaming';

package/dist/runtime/streaming/state-effects.d.ts

@@ -0,0 +1,28 @@
+/**
+ * State transition helpers for common patterns
+ */
+export declare const StateTransitions: {
+    /**
+     * Transition to a new phase with optional updates
+     */
+    to: <T extends {
+        phase?: string;
+    }>(phase: string, updates?: Partial<T>) => (state: T) => T;
+    /**
+     * Add polling delay to state
+     */
+    withPolling: <T>(delayMs: number) => (state: T) => T;
+    /**
+     * Set error state with message and stop polling
+     */
+    withError: <T>(errorMessage: string) => (state: T) => T;
+    /**
+     * Preserve existing state with updates
+     */
+    update: <T>(updates: Partial<T>) => (state: T) => T;
+};
+/**
+ * Simple pipe utility for composing state transformations
+ */
+export declare const pipe: <T>(value: T, ...fns: Array<(val: T) => T>) => T;
+//# sourceMappingURL=state-effects.d.ts.map

package/dist/runtime/streaming/state-effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-effects.d.ts","sourceRoot":"","sources":["../../../src/runtime/streaming/state-effects.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;SACE,CAAC,SAAS;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,SAAS,MAAM,YAAW,OAAO,CAAC,CAAC,CAAC,MAClE,OAAO,CAAC,KAAG,CAAC;IAEf;;OAEG;kBACW,CAAC,WAAW,MAAM,MAC7B,OAAO,CAAC,KAAG,CAAC;IAEf;;OAEG;gBACS,CAAC,gBAAgB,MAAM,MAChC,OAAO,CAAC,KAAG,CAAC;IAOf;;OAEG;aACM,CAAC,WAAW,OAAO,CAAC,CAAC,CAAC,MAC5B,OAAO,CAAC,KAAG,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,KAAG,CACxB,CAAC"}

package/dist/runtime/streaming/state-effects.js

@@ -0,0 +1,30 @@
+/**
+ * State transition helpers for common patterns
+ */
+export const StateTransitions = {
+    /**
+     * Transition to a new phase with optional updates
+     */
+    to: (phase, updates = {}) => (state) => ({ ...state, phase, ...updates }),
+    /**
+     * Add polling delay to state
+     */
+    withPolling: (delayMs) => (state) => ({ ...state, nextPollMs: delayMs }),
+    /**
+     * Set error state with message and stop polling
+     */
+    withError: (errorMessage) => (state) => ({
+        ...state,
+        phase: 'error',
+        errorMessage,
+        nextPollMs: null
+    }),
+    /**
+     * Preserve existing state with updates
+     */
+    update: (updates) => (state) => ({ ...state, ...updates }),
+};
+/**
+ * Simple pipe utility for composing state transformations
+ */
+export const pipe = (value, ...fns) => fns.reduce((acc, fn) => fn(acc), value);

package/dist/runtime/streaming/streaming.d.ts

@@ -0,0 +1,8 @@
+import { Effect, Stream } from "effect";
+import type { z } from "zod";
+import type { Plugin } from "../../plugin";
+import type { PluginRuntimeError } from "../errors";
+import type { InitializedPlugin } from "../types";
+import type { StreamingOptions } from "./types";
+export declare const createSourceStream: <T extends Plugin, TInput extends z.infer<T["inputSchema"]>, TItem, TPluginState extends z.infer<T["stateSchema"]>>(initializedPlugin: InitializedPlugin<T>, executePlugin: (plugin: InitializedPlugin<T>, input: TInput) => Effect.Effect<any, PluginRuntimeError>, input: TInput, options?: StreamingOptions<TItem, TPluginState>) => Stream.Stream<TItem, PluginRuntimeError>;
+//# sourceMappingURL=streaming.d.ts.map

package/dist/runtime/streaming/streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["../../../src/runtime/streaming/streaming.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,MAAM,EAAyB,MAAM,EAAE,MAAM,QAAQ,CAAC;AACzE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAe,MAAM,SAAS,CAAC;AA8B7D,eAAO,MAAM,kBAAkB,GAC7B,CAAC,SAAS,MAAM,EAChB,MAAM,SAAS,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,EACxC,KAAK,EACL,YAAY,SAAS,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,EAE9C,mBAAmB,iBAAiB,CAAC,CAAC,CAAC,EACvC,eAAe,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,kBAAkB,CAAC,EACtG,OAAO,MAAM,EACb,UAAS,gBAAgB,CAAC,KAAK,EAAE,YAAY,CAAM,KAClD,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,kBAAkB,CAyGzC,CAAC"}

package/dist/runtime/streaming/streaming.js

@@ -0,0 +1,107 @@
+import { Duration, Effect, Stream } from "effect";
+/**
+ * Extract delay from plugin state (nextPollMs field)
+ * Returns null if nextPollMs is null (signals termination) or undefined (no delay specified)
+ */
+const extractDelayFromState = (state) => {
+    const stateWithPolling = state;
+    if (stateWithPolling?.nextPollMs === null) {
+        return null; // Explicit termination signal
+    }
+    return stateWithPolling?.nextPollMs ? Duration.millis(stateWithPolling.nextPollMs) : null;
+};
+/**
+ * Check if plugin state signals stream termination
+ */
+const isTerminalState = (state) => {
+    const stateWithPolling = state;
+    return stateWithPolling?.nextPollMs === null;
+};
+export const createSourceStream = (initializedPlugin, executePlugin, input, options = {}) => {
+    // Create initial stream state with plugin's initial state
+    const initialStreamState = {
+        invocations: 0,
+        pluginState: input.state,
+        lastItemCount: 0,
+    };
+    // Use Stream.async for full control over emission timing and delays
+    return Stream.async((emit) => {
+        let currentStreamState = initialStreamState;
+        let totalItemsEmitted = 0;
+        const loop = async () => {
+            try {
+                while (true) {
+                    console.log(`[STREAMING] Starting iteration ${currentStreamState.invocations + 1}`);
+                    // Check invocation limit BEFORE executing
+                    if (options.maxInvocations && currentStreamState.invocations >= options.maxInvocations) {
+                        console.log(`[STREAMING] Reached maxInvocations limit: ${options.maxInvocations}`);
+                        break;
+                    }
+                    // Check maxItems limit BEFORE executing
+                    if (options.maxItems && totalItemsEmitted >= options.maxItems) {
+                        console.log(`[STREAMING] Reached maxItems limit: ${options.maxItems}`);
+                        break;
+                    }
+                    // Execute plugin with current plugin state
+                    const pluginInput = {
+                        ...input,
+                        state: currentStreamState.pluginState ?? null
+                    };
+                    console.log(`[STREAMING] About to execute plugin with input:`, JSON.stringify(pluginInput, null, 2));
+                    console.log(`[STREAMING] Plugin state:`, JSON.stringify(currentStreamState.pluginState, null, 2));
+                    const rawResult = await Effect.runPromise(executePlugin(initializedPlugin, pluginInput));
+                    console.log(`[STREAMING] Plugin execution completed`);
+                    // Transform raw plugin result to streaming format
+                    const resultObj = rawResult;
+                    const items = Array.isArray(resultObj.items) ? resultObj.items : [];
+                    const nextPluginState = resultObj.nextState;
+                    console.log(`[STREAMING] Transformed result: ${items.length} items`);
+                    // Update stream state (increment AFTER execution)
+                    currentStreamState = {
+                        invocations: currentStreamState.invocations + 1,
+                        pluginState: nextPluginState,
+                        lastItemCount: items.length,
+                    };
+                    console.log(`[STREAMING] Invocation ${currentStreamState.invocations}, Items: ${items.length}`);
+                    // Call state change hook if provided
+                    if (options.onStateChange) {
+                        await Effect.runPromise(options.onStateChange(nextPluginState, items));
+                    }
+                    // Emit items immediately (before any delays)
+                    for (const item of items) {
+                        if (options.maxItems && totalItemsEmitted >= options.maxItems) {
+                            console.log(`[STREAMING] Stopping emission at maxItems limit: ${options.maxItems}`);
+                            break;
+                        }
+                        emit.single(item);
+                        totalItemsEmitted++;
+                    }
+                    // Check for termination conditions
+                    if (nextPluginState && isTerminalState(nextPluginState)) {
+                        console.log(`[STREAMING] Plugin signaled termination`);
+                        break;
+                    }
+                    // Check stopWhenEmpty condition
+                    if (options.stopWhenEmpty && items.length === 0) {
+                        console.log(`[STREAMING] Stopping due to empty result and stopWhenEmpty=true`);
+                        break;
+                    }
+                    // Handle delay AFTER emission, BEFORE next iteration
+                    const nextDelay = extractDelayFromState(nextPluginState);
+                    if (nextDelay && Duration.toMillis(nextDelay) > 0) {
+                        console.log(`[STREAMING] Sleeping for ${Duration.toMillis(nextDelay)}ms before next iteration`);
+                        await Effect.runPromise(Effect.sleep(nextDelay));
+                    }
+                }
+                // End the stream
+                emit.end();
+            }
+            catch (error) {
+                console.log(`[STREAMING] Error occurred:`, error);
+                emit.fail(error);
+            }
+        };
+        // Start the loop
+        loop();
+    });
+};

package/dist/runtime/streaming/types.d.ts

@@ -0,0 +1,19 @@
+import type { Effect } from "effect";
+/**
+ * Internal stream state managed by the runtime
+ */
+export interface StreamState<TPluginState> {
+    readonly invocations: number;
+    readonly pluginState: TPluginState;
+    readonly lastItemCount: number;
+}
+/**
+ * Enhanced streaming options with Effect-based hooks
+ */
+export interface StreamingOptions<TItem = unknown, TPluginState = unknown> {
+    maxItems?: number;
+    maxInvocations?: number;
+    stopWhenEmpty?: boolean;
+    onStateChange?: (newPluginState: TPluginState, items: TItem[]) => Effect.Effect<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/streaming/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/streaming/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,YAAY;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAC;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,YAAY,GAAG,OAAO;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IAGxB,aAAa,CAAC,EAAE,CAAC,cAAc,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CACvF"}

package/dist/runtime/streaming/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/test-utils.d.ts

@@ -0,0 +1,3 @@
+import type { PluginLogger } from "../plugin";
+export declare const createTestLogger: () => PluginLogger;
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/runtime/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../src/runtime/test-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,eAAO,MAAM,gBAAgB,QAAO,YAYlC,CAAC"}

package/dist/runtime/test-utils.js

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+export const createTestLogger = () => ({
+    logInfo: (message, context) => Effect.sync(() => console.log(`[INFO] ${message}`, context || '')),
+    logWarning: (message, context) => Effect.sync(() => console.warn(`[WARNING] ${message}`, context || '')),
+    logError: (message, error, context) => Effect.sync(() => console.error(`[ERROR] ${message}`, error, context || '')),
+    logDebug: (message, context) => Effect.sync(() => console.log(`[DEBUG] ${message}`, context || '')),
+});