@pikku/core 0.7.8 → 0.8.0

package/dist/middleware-runner.d.ts

@@ -1,5 +1,5 @@
 import { UserSessionService } from './services/user-session-service.js';
-import { CoreSingletonServices, PikkuInteraction, PikkuMiddleware } from './types/core.types.js';
+import { CoreSingletonServices, PikkuFunctionMiddleware, PikkuInteraction, PikkuMiddleware } from './types/core.types.js';
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
@@ -17,6 +17,6 @@ import { CoreSingletonServices, PikkuInteraction, PikkuMiddleware } from './type
  *   async () => { return await runMain(); }
  * );
  */
-export declare const runMiddleware: (services: CoreSingletonServices & {
-    userSession: UserSessionService<any>;
-}, interaction: PikkuInteraction, middlewares: PikkuMiddleware[], main?: () => Promise<void>) => Promise<void>;
+export declare const runMiddleware: <Middleware extends PikkuMiddleware | PikkuFunctionMiddleware = PikkuMiddleware>(services: CoreSingletonServices & {
+    userSession?: UserSessionService<any>;
+}, interaction: PikkuInteraction, middlewares: Middleware[], main?: () => Promise<unknown>) => Promise<unknown>;

package/dist/middleware-runner.js

@@ -16,13 +16,15 @@
  * );
  */
 export const runMiddleware = async (services, interaction, middlewares, main) => {
+    let result;
     const dispatch = async (index) => {
         if (middlewares && index < middlewares.length) {
             return await middlewares[index](services, interaction, () => dispatch(index + 1));
         }
         else if (main) {
-            await main();
+            result = await main();
         }
     };
     await dispatch(0);
+    return result;
 };

package/dist/pikku-state.d.ts

@@ -1,10 +1,12 @@
-import { ChannelsMeta, CoreAPIChannel } from './channel/channel.types.js';
-import { CoreHTTPFunctionRoute, HTTPMethod, HTTPRoutesMeta } from './http/http.types.js';
+import { ChannelsMeta, CoreAPIChannel } from './events/channel/channel.types.js';
+import { CoreHTTPFunctionRoute, HTTPMethod, HTTPRoutesMeta } from './events/http/http.types.js';
 import { FunctionsMeta, PikkuMiddleware } from './types/core.types.js';
-import { CoreScheduledTask, ScheduledTasksMeta } from './scheduler/scheduler.types.js';
+import { CoreScheduledTask, ScheduledTasksMeta } from './events/scheduler/scheduler.types.js';
 import { ErrorDetails, PikkuError } from './errors/error-handler.js';
 import { CorePikkuFunctionConfig } from './function/functions.types.js';
-import { RPCMeta } from './rpc/rpc-types.js';
+import { RPCMeta } from './events/rpc/rpc-types.js';
+import { queueWorkersMeta, CoreQueueWorker } from './events/queue/queue.types.js';
+import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from './events/mcp/mcp.types.js';
 interface PikkuState {
     function: {
         meta: FunctionsMeta;
@@ -33,6 +35,18 @@ interface PikkuState {
         tasks: Map<string, CoreScheduledTask>;
         meta: ScheduledTasksMeta;
     };
+    queue: {
+        registrations: Map<string, CoreQueueWorker>;
+        meta: queueWorkersMeta;
+    };
+    mcp: {
+        resources: Map<string, CoreMCPResource>;
+        resourcesMeta: MCPResourceMeta;
+        tools: Map<string, CoreMCPTool>;
+        toolsMeta: MCPToolMeta;
+        prompts: Map<string, CoreMCPPrompt>;
+        promptsMeta: MCPPromptMeta;
+    };
     misc: {
         errors: Map<PikkuError, ErrorDetails>;
         schemas: Map<string, any>;

package/dist/pikku-state.js

@@ -21,6 +21,18 @@ export const resetPikkuState = () => {
             tasks: new Map(),
             meta: [],
         },
+        queue: {
+            registrations: new Map(),
+            meta: {},
+        },
+        mcp: {
+            resources: new Map(),
+            resourcesMeta: {},
+            tools: new Map(),
+            toolsMeta: {},
+            prompts: new Map(),
+            promptsMeta: {},
+        },
         misc: {
             errors: globalThis.pikkuState?.misc?.errors || new Map(),
             schemas: globalThis.pikkuState?.misc?.schema || new Map(),

package/dist/services/user-session-service.d.ts

@@ -1,4 +1,4 @@
-import { ChannelStore } from '../channel/channel-store.js';
+import { ChannelStore } from '../events/channel/channel-store.js';
 import { CoreUserSession } from '../types/core.types.js';
 export interface UserSessionService<UserSession extends CoreUserSession> {
     sessionChanged: boolean;

package/dist/types/core.types.d.ts

@@ -1,18 +1,21 @@
 import type { Logger, LogLevel } from '../services/logger.js';
 import { VariablesService } from '../services/variables-service.js';
-import { EventHubService } from '../channel/eventhub-service.js';
+import { EventHubService } from '../events/channel/eventhub-service.js';
 import { SchemaService } from '../services/schema-service.js';
-import { PikkuHTTP } from '../http/http.types.js';
+import { PikkuHTTP } from '../events/http/http.types.js';
 import { UserSessionService } from '../services/user-session-service.js';
 import { JWTService } from '../services/jwt-service.js';
 import { SecretService } from '../services/secret-service.js';
-import { PikkuChannel } from '../channel/channel.types.js';
-import { PikkuRPC } from '../rpc/rpc-types.js';
+import { PikkuChannel } from '../events/channel/channel.types.js';
+import { PikkuRPC } from '../events/rpc/rpc-types.js';
+import { PikkuMCP } from '../events/mcp/mcp.types.js';
 export declare enum PikkuEventTypes {
     http = "http",
     scheduled = "scheduled",
     channel = "channel",
-    rpc = "rpc"
+    rpc = "rpc",
+    queue = "queue",
+    mcp = "mcp"
 }
 export interface FunctionServicesMeta {
     optimized: boolean;
@@ -89,7 +92,15 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
  */
 export interface PikkuInteraction {
     http?: PikkuHTTP;
+    mcp?: PikkuMCP;
+    rpc?: PikkuRPC;
 }
+/**
+ * A function that can wrap an interaction and be called before or after
+ */
+export type PikkuFunctionMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices & {
+    userSession?: UserSessionService<UserSession>;
+}, interactions: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
 /**
  * A function that can wrap an interaction and be called before or after
  */
@@ -100,6 +111,7 @@ export type PikkuMiddleware<SingletonServices extends CoreSingletonServices = Co
  * Represents the core services used by Pikku, including singleton services and the request/response interaction.
  */
 export type CoreServices<SingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession, CoreServices extends Record<string, unknown> = {}> = SingletonServices & PikkuInteraction & {
+    mcp?: PikkuMCP;
     rpc?: PikkuRPC;
     userSession?: UserSessionService<UserSession>;
     channel?: PikkuChannel<unknown, unknown>;

package/dist/types/core.types.js

@@ -4,4 +4,6 @@ export var PikkuEventTypes;
     PikkuEventTypes["scheduled"] = "scheduled";
     PikkuEventTypes["channel"] = "channel";
     PikkuEventTypes["rpc"] = "rpc";
+    PikkuEventTypes["queue"] = "queue";
+    PikkuEventTypes["mcp"] = "mcp";
 })(PikkuEventTypes || (PikkuEventTypes = {}));