@pikku/core 0.11.0 → 0.11.2

package/src/wirings/http/routers/path-to-regex.test.ts

@@ -23,6 +23,7 @@ describe('PathToRegexRouter', () => {
     test('should correctly identify static routes', () => {
       // Setup test routes
       pikkuState(
+        null,
         'http',
         'routes',
         new Map([
@@ -36,8 +37,8 @@ describe('PathToRegexRouter', () => {
           ],
         ])
       )
-      pikkuState('http', 'middleware', new Map())
-      pikkuState('channel', 'channels', new Map())
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
 
       router.initialize()
 
@@ -56,6 +57,7 @@ describe('PathToRegexRouter', () => {
     test('should handle dynamic routes with parameters', () => {
       // Setup test routes with parameters
       pikkuState(
+        null,
         'http',
         'routes',
         new Map([
@@ -71,8 +73,8 @@ describe('PathToRegexRouter', () => {
           ],
         ])
       )
-      pikkuState('http', 'middleware', new Map())
-      pikkuState('channel', 'channels', new Map())
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
 
       router.initialize()
 
@@ -98,6 +100,7 @@ describe('PathToRegexRouter', () => {
     test('should handle multi-parameter routes', () => {
       // Setup routes with multiple parameters
       pikkuState(
+        null,
         'http',
         'routes',
         new Map([
@@ -116,8 +119,8 @@ describe('PathToRegexRouter', () => {
           ],
         ])
       )
-      pikkuState('http', 'middleware', new Map())
-      pikkuState('channel', 'channels', new Map())
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
 
       router.initialize()
 
@@ -139,6 +142,7 @@ describe('PathToRegexRouter', () => {
     test('should prioritize static routes over dynamic routes for performance', () => {
       // Setup mixed routes where static could conflict with dynamic
       pikkuState(
+        null,
         'http',
         'routes',
         new Map([
@@ -151,8 +155,8 @@ describe('PathToRegexRouter', () => {
           ],
         ])
       )
-      pikkuState('http', 'middleware', new Map())
-      pikkuState('channel', 'channels', new Map())
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
 
       router.initialize()
 
@@ -167,6 +171,7 @@ describe('PathToRegexRouter', () => {
   describe('Path Normalization', () => {
     test('should normalize paths without leading slash', () => {
       pikkuState(
+        null,
         'http',
         'routes',
         new Map([
@@ -179,8 +184,8 @@ describe('PathToRegexRouter', () => {
           ],
         ])
       )
-      pikkuState('http', 'middleware', new Map())
-      pikkuState('channel', 'channels', new Map())
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
 
       router.initialize()
 
@@ -201,9 +206,10 @@ describe('PathToRegexRouter', () => {
 
   describe('Channel Routes Integration', () => {
     test('should handle channel routes as GET routes', () => {
-      pikkuState('http', 'routes', new Map())
-      pikkuState('http', 'middleware', new Map())
+      pikkuState(null, 'http', 'routes', new Map())
+      pikkuState(null, 'http', 'middleware', new Map())
       pikkuState(
+        null,
         'channel',
         'channels',
         new Map([
@@ -233,11 +239,13 @@ describe('PathToRegexRouter', () => {
       const routeMiddleware = [async () => {}]
 
       pikkuState(
+        null,
         'http',
         'routes',
         new Map([['get', new Map([['/api/test', mockRoute('/api/test')]])]])
       )
       pikkuState(
+        null,
         'http',
         'middleware',
         new Map([
@@ -245,7 +253,7 @@ describe('PathToRegexRouter', () => {
           ['/api/test', routeMiddleware],
         ])
       )
-      pikkuState('channel', 'channels', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
 
       router.initialize()
 
@@ -260,12 +268,13 @@ describe('PathToRegexRouter', () => {
   describe('No Match Scenarios', () => {
     test('should return null for non-existent routes', () => {
       pikkuState(
+        null,
         'http',
         'routes',
         new Map([['get', new Map([['/existing', mockRoute('/existing')]])]])
       )
-      pikkuState('http', 'middleware', new Map())
-      pikkuState('channel', 'channels', new Map())
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
 
       router.initialize()
 
@@ -275,12 +284,13 @@ describe('PathToRegexRouter', () => {
 
     test('should return null for unsupported HTTP methods', () => {
       pikkuState(
+        null,
         'http',
         'routes',
         new Map([['get', new Map([['/test', mockRoute('/test')]])]])
       )
-      pikkuState('http', 'middleware', new Map())
-      pikkuState('channel', 'channels', new Map())
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
 
       router.initialize()
 
@@ -292,12 +302,13 @@ describe('PathToRegexRouter', () => {
   describe('Lazy Initialization', () => {
     test('should initialize automatically on first match call', () => {
       pikkuState(
+        null,
         'http',
         'routes',
         new Map([['get', new Map([['/test', mockRoute('/test')]])]])
       )
-      pikkuState('http', 'middleware', new Map())
-      pikkuState('channel', 'channels', new Map())
+      pikkuState(null, 'http', 'middleware', new Map())
+      pikkuState(null, 'channel', 'channels', new Map())
 
       // Don't call initialize manually
       const result = router.match('get', '/test')

package/src/wirings/http/routers/path-to-regex.ts

@@ -25,8 +25,8 @@ export class PathToRegexRouter implements Router {
   }
 
   public initialize() {
-    const routes = pikkuState('http', 'routes')
-    const channelRoutes = pikkuState('channel', 'channels')
+    const routes = pikkuState(null, 'http', 'routes')
+    const channelRoutes = pikkuState(null, 'channel', 'channels')
 
     // Helper function to compile routes for a given method
     const compileRoutesForMethod = (

package/src/wirings/mcp/mcp-runner.ts

@@ -1,10 +1,9 @@
 import {
-  PikkuInteraction,
-  PikkuWiringTypes,
+  PikkuWire,
   type CoreServices,
   type CoreSingletonServices,
   type CoreUserSession,
-  type CreateSessionServices,
+  type CreateWireServices,
 } from '../../types/core.types.js'
 import type {
   CoreMCPResource,
@@ -20,11 +19,11 @@ import type {
   CorePikkuFunctionSessionless,
 } from '../../function/functions.types.js'
 import { getErrorResponse } from '../../errors/error-handler.js'
-import { closeSessionServices } from '../../utils.js'
+import { closeWireServices } from '../../utils.js'
 import { pikkuState } from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
-import { rpcService } from '../rpc/rpc-runner.js'
 import { BadRequestError, NotFoundError } from '../../errors/errors.js'
+import { PikkuSessionService } from '../../services/user-session-service.js'
 
 export class MCPError extends Error {
   constructor(public readonly error: JsonRpcErrorResponse) {
@@ -37,7 +36,7 @@ export class MCPError extends Error {
 export type RunMCPEndpointParams<Tools extends string = any> = {
   singletonServices: CoreSingletonServices
   mcp?: PikkuMCP<Tools>
-  createSessionServices?: CreateSessionServices<
+  createWireServices?: CreateWireServices<
     CoreSingletonServices,
     CoreServices<CoreSingletonServices>,
     CoreUserSession
@@ -57,13 +56,13 @@ export const wireMCPResource = <
 >(
   mcpResource: CoreMCPResource<PikkuFunctionConfig>
 ) => {
-  const resourcesMeta = pikkuState('mcp', 'resourcesMeta')
+  const resourcesMeta = pikkuState(null, 'mcp', 'resourcesMeta')
   const mcpResourceMeta = resourcesMeta[mcpResource.uri]
   if (!mcpResourceMeta) {
     throw new Error(`MCP resource metadata not found for '${mcpResource.uri}'`)
   }
   addFunction(mcpResourceMeta.pikkuFuncName, mcpResource.func as any)
-  const resources = pikkuState('mcp', 'resources')
+  const resources = pikkuState(null, 'mcp', 'resources')
   if (resources.has(mcpResource.uri)) {
     throw new Error(`MCP resource already exists: ${mcpResource.uri}`)
   }
@@ -77,13 +76,13 @@ export const wireMCPTool = <
 >(
   mcpTool: CoreMCPTool<PikkuFunctionConfig>
 ) => {
-  const toolsMeta = pikkuState('mcp', 'toolsMeta')
+  const toolsMeta = pikkuState(null, 'mcp', 'toolsMeta')
   const mcpToolMeta = toolsMeta[mcpTool.name]
   if (!mcpToolMeta) {
     throw new Error(`MCP tool metadata not found for '${mcpTool.name}'`)
   }
   addFunction(mcpToolMeta.pikkuFuncName, mcpTool.func as any)
-  const tools = pikkuState('mcp', 'tools')
+  const tools = pikkuState(null, 'mcp', 'tools')
   if (tools.has(mcpTool.name)) {
     throw new Error(`MCP tool already exists: ${mcpTool.name}`)
   }
@@ -97,13 +96,13 @@ export const wireMCPPrompt = <
 >(
   mcpPrompt: CoreMCPPrompt<PikkuFunctionConfig>
 ) => {
-  const promptsMeta = pikkuState('mcp', 'promptsMeta')
+  const promptsMeta = pikkuState(null, 'mcp', 'promptsMeta')
   const mcpPromptMeta = promptsMeta[mcpPrompt.name]
   if (!mcpPromptMeta) {
     throw new Error(`MCP prompt metadata not found for '${mcpPrompt.name}'`)
   }
   addFunction(mcpPromptMeta.pikkuFuncName, mcpPrompt.func as any)
-  const prompts = pikkuState('mcp', 'prompts')
+  const prompts = pikkuState(null, 'mcp', 'prompts')
   if (prompts.has(mcpPrompt.name)) {
     throw new Error(`MCP prompt already exists: ${mcpPrompt.name}`)
   }
@@ -119,8 +118,8 @@ export async function runMCPResource(
   let pikkuFuncName: string | undefined
   let extractedParams: Record<string, string> = {}
 
-  const metas = pikkuState('mcp', 'resourcesMeta')
-  const endpoints = pikkuState('mcp', 'resources')
+  const metas = pikkuState(null, 'mcp', 'resourcesMeta')
+  const endpoints = pikkuState(null, 'mcp', 'resources')
 
   if (endpoints.has(uri)) {
     endpoint = endpoints.get(uri)
@@ -171,8 +170,8 @@ export async function runMCPTool(
   params: RunMCPEndpointParams,
   name: string
 ) {
-  const endpoint = pikkuState('mcp', 'tools').get(name)
-  const meta = pikkuState('mcp', 'toolsMeta')[name]
+  const endpoint = pikkuState(null, 'mcp', 'tools').get(name)
+  const meta = pikkuState(null, 'mcp', 'toolsMeta')[name]
   return await runMCPPikkuFunc(
     request,
     'tool',
@@ -188,8 +187,8 @@ export async function runMCPPrompt(
   params: RunMCPEndpointParams,
   name: string
 ) {
-  const endpoint = pikkuState('mcp', 'prompts').get(name)
-  const meta = pikkuState('mcp', 'promptsMeta')[name]
+  const endpoint = pikkuState(null, 'mcp', 'prompts').get(name)
+  const meta = pikkuState(null, 'mcp', 'promptsMeta')[name]
   return await runMCPPikkuFunc(
     request,
     'prompt',
@@ -209,13 +208,9 @@ async function runMCPPikkuFunc(
   name: string,
   mcp: CoreMCPResource | CoreMCPTool | CoreMCPPrompt | undefined,
   pikkuFuncName: string | undefined,
-  {
-    singletonServices,
-    createSessionServices,
-    mcp: mcpInteraction,
-  }: RunMCPEndpointParams
+  { singletonServices, createWireServices, mcp: mcpWire }: RunMCPEndpointParams
 ): Promise<JsonRpcResponse> {
-  let sessionServices: any
+  let wireServices: any
 
   try {
     // Validate JSON-RPC request structure
@@ -239,52 +234,32 @@ async function runMCPPikkuFunc(
 
     singletonServices.logger.debug(`Running MCP ${type}: ${name}`)
 
-    const interaction: PikkuInteraction = { mcp: mcpInteraction }
-
-    const getAllServices = async () => {
-      sessionServices = await createSessionServices?.(
-        singletonServices,
-        interaction,
-        undefined
-      )
-
-      return rpcService.injectRPCService(
-        {
-          ...singletonServices,
-          ...sessionServices,
-          mcp: mcpInteraction,
-        },
-        interaction
-      )
+    const wire: PikkuWire = {
+      mcp: mcpWire,
+      session: new PikkuSessionService(),
     }
 
     // Get metadata for the MCP endpoint to access pre-resolved middleware
     let meta: any
     if (type === 'resource') {
-      meta = pikkuState('mcp', 'resourcesMeta')[name]
+      meta = pikkuState(null, 'mcp', 'resourcesMeta')[name]
     } else if (type === 'tool') {
-      meta = pikkuState('mcp', 'toolsMeta')[name]
+      meta = pikkuState(null, 'mcp', 'toolsMeta')[name]
     } else if (type === 'prompt') {
-      meta = pikkuState('mcp', 'promptsMeta')[name]
+      meta = pikkuState(null, 'mcp', 'promptsMeta')[name]
     }
 
-    const result = await runPikkuFunc(
-      PikkuWiringTypes.mcp,
-      `${type}:${name}`,
-      pikkuFuncName,
-      {
-        singletonServices,
-        getAllServices,
-        userSession: undefined, // TODO
-        data: () => request.params,
-        inheritedMiddleware: meta?.middleware,
-        wireMiddleware: mcp.middleware,
-        inheritedPermissions: meta?.permissions,
-        wirePermissions: mcp.permissions,
-        tags: mcp.tags,
-        interaction,
-      }
-    )
+    const result = await runPikkuFunc('mcp', `${type}:${name}`, pikkuFuncName, {
+      singletonServices,
+      createWireServices,
+      data: () => request.params,
+      inheritedMiddleware: meta?.middleware,
+      wireMiddleware: mcp.middleware,
+      inheritedPermissions: meta?.permissions,
+      wirePermissions: mcp.permissions,
+      tags: mcp.tags,
+      wire,
+    })
 
     return {
       id: request.id,
@@ -316,32 +291,32 @@ async function runMCPPikkuFunc(
       })
     }
   } finally {
-    if (sessionServices) {
-      await closeSessionServices(singletonServices.logger, sessionServices)
+    if (wireServices) {
+      await closeWireServices(singletonServices.logger, wireServices)
     }
   }
 }
 
 export const getMCPTools = () => {
-  return pikkuState('mcp', 'tools')
+  return pikkuState(null, 'mcp', 'tools')
 }
 
 export const getMCPResources = () => {
-  return pikkuState('mcp', 'resources')
+  return pikkuState(null, 'mcp', 'resources')
 }
 
 export const getMCPResourcesMeta = () => {
-  return pikkuState('mcp', 'resourcesMeta')
+  return pikkuState(null, 'mcp', 'resourcesMeta')
 }
 
 export const getMCPToolsMeta = () => {
-  return pikkuState('mcp', 'toolsMeta')
+  return pikkuState(null, 'mcp', 'toolsMeta')
 }
 
 export const getMCPPrompts = () => {
-  return pikkuState('mcp', 'prompts')
+  return pikkuState(null, 'mcp', 'prompts')
 }
 
 export const getMCPPromptsMeta = () => {
-  return pikkuState('mcp', 'promptsMeta')
+  return pikkuState(null, 'mcp', 'promptsMeta')
 }

package/src/wirings/mcp/mcp.types.ts

@@ -104,6 +104,8 @@ export type CoreMCPResource<
   uri: string
   title: string
   description: string
+  summary?: string
+  errors?: string[]
   mimeType?: string
   size?: number
   streaming?: boolean
@@ -126,6 +128,8 @@ export type CoreMCPTool<
   name: string
   title?: string
   description: string
+  summary?: string
+  errors?: string[]
   func: PikkuFunctionConfig
   tags?: string[]
   streaming?: boolean
@@ -145,6 +149,8 @@ export type CoreMCPPrompt<
 > = {
   name: string
   description: string
+  summary?: string
+  errors?: string[]
   func: PikkuFunctionConfig
   tags?: string[]
   middleware?: PikkuMiddleware[]