@pikku/core 0.11.2 → 0.12.0

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

@@ -1,8 +1,27 @@
-import { CoreServices, PikkuWire } from '../../types/core.types.js'
+import {
+  CoreServices,
+  CoreSingletonServices,
+  PikkuWire,
+} from '../../types/core.types.js'
+import type { SessionService } from '../../services/user-session-service.js'
+import type { CoreUserSession } from '../../types/core.types.js'
 import { runPikkuFunc } from '../../function/function-runner.js'
 import { pikkuState } from '../../pikku-state.js'
 import { ForbiddenError } from '../../errors/errors.js'
+import { PikkuError } from '../../errors/error-handler.js'
 import { PikkuRPC, ResolvedFunction } from './rpc-types.js'
+import { parseVersionedId } from '../../version.js'
+import { encryptJSON } from '../../crypto-utils.js'
+
+export class RPCNotFoundError extends PikkuError {
+  public readonly rpcName: string
+  constructor(rpcName: string) {
+    super(`RPC function not found: ${rpcName}`)
+    this.rpcName = rpcName
+  }
+}
+import type { AIAgentInput } from '../ai-agent/ai-agent.types.js'
+import { runAIAgent } from '../ai-agent/ai-agent-runner.js'
 
 /**
  * Resolve a namespaced function reference to package and function names
@@ -20,22 +39,28 @@ const resolveNamespace = (
   const functionName = namespacedFunction.substring(colonIndex + 1)
 
   const externalPackages = pikkuState(null, 'rpc', 'externalPackages')
-  const packageName = externalPackages.get(namespace)
-  if (!packageName) {
+  const pkgConfig = externalPackages.get(namespace)
+  if (!pkgConfig) {
     return null
   }
 
   return {
-    package: packageName,
+    package: pkgConfig.package,
     function: functionName,
   }
 }
 
 const getPikkuFunctionName = (rpcName: string): string => {
   const rpc = pikkuState(null, 'rpc', 'meta')
-  const rpcMeta = rpc[rpcName]
+  let rpcMeta = rpc[rpcName]
   if (!rpcMeta) {
-    throw new Error(`RPC function not found: ${rpcName}`)
+    const { baseName, version } = parseVersionedId(rpcName)
+    if (version !== null) {
+      rpcMeta = rpc[baseName]
+    }
+  }
+  if (!rpcMeta) {
+    throw new RPCNotFoundError(rpcName)
   }
   return rpcMeta
 }
@@ -47,11 +72,22 @@ export class ContextAwareRPCService {
     private wire: PikkuWire,
     private options: {
       requiresAuth?: boolean
+      sessionService?: SessionService<CoreUserSession>
     }
   ) {}
 
   public async rpcExposed(funcName: string, data: any): Promise<any> {
-    const functionMeta = pikkuState(null, 'function', 'meta')[funcName]
+    let functionMeta: any
+    if (funcName.includes(':')) {
+      const resolved = resolveNamespace(funcName)
+      if (resolved) {
+        functionMeta = pikkuState(resolved.package, 'function', 'meta')[
+          resolved.function
+        ]
+      }
+    } else {
+      functionMeta = pikkuState(null, 'function', 'meta')[funcName]
+    }
     if (!functionMeta) {
       throw new Error(`Function not found: ${funcName}`)
     }
@@ -93,8 +129,6 @@ export class ContextAwareRPCService {
       getPikkuFunctionName(funcName),
       {
         auth: this.options.requiresAuth,
-        // TODO: this is a hack since services have already been created
-        // but is valid since we don't want to keep creating new wire services
         singletonServices: this.services,
         data: () => data,
         wire: updatedWire,
@@ -136,7 +170,7 @@ export class ContextAwareRPCService {
           `Available functions: ${Object.keys(externalFunctionMeta).join(', ') || '(none)'}`
       )
     }
-    const funcName = funcMeta.pikkuFuncName || resolved.function
+    const funcName = funcMeta.pikkuFuncId || resolved.function
 
     // Execute the function using runPikkuFunc with the external package's state
     // We use the parent services (this.services) since external packages share services
@@ -183,17 +217,142 @@ export class ContextAwareRPCService {
 
   public async startWorkflow<In = any>(
     workflowName: string,
-    input: In
+    input: In,
+    options?: {
+      startNode?: string
+      wire?: { type: string; id?: string; parentRunId?: string }
+    }
   ): Promise<{ runId: string }> {
     if (!this.services.workflowService) {
       throw new Error('WorkflowService service not available')
     }
+    const parentRunId = this.wire.workflowStep?.runId ?? this.wire.graph?.runId
+    const wire = options?.wire ?? {
+      type: this.wire.wireType ?? 'unknown',
+      id: this.wire.wireId,
+      ...(parentRunId ? { parentRunId } : {}),
+    }
     return this.services.workflowService.startWorkflow(
       workflowName,
       input,
-      this
+      wire,
+      this,
+      options
     )
   }
+
+  public async agent(
+    agentName: string,
+    input: AIAgentInput
+  ): Promise<{
+    runId: string
+    result: unknown
+    usage: { inputTokens: number; outputTokens: number }
+  }> {
+    const result = await runAIAgent(agentName, input, {
+      singletonServices: this.services as CoreSingletonServices,
+      sessionService: this.options.sessionService,
+    })
+    return {
+      runId: result.runId,
+      result: result.object ?? result.text,
+      usage: result.usage,
+    }
+  }
+
+  public async remote<In = any, Out = any>(
+    funcName: string,
+    data: In
+  ): Promise<Out> {
+    let endpoint: string | undefined
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    }
+
+    const colonIndex = funcName.indexOf(':')
+    if (colonIndex !== -1) {
+      const namespace = funcName.substring(0, colonIndex)
+      const externalPackages = pikkuState(null, 'rpc', 'externalPackages')
+      const pkgConfig = externalPackages.get(namespace)
+      endpoint = pkgConfig?.rpcEndpoint
+    }
+
+    if (!endpoint && this.services.deploymentService) {
+      const deployments =
+        await this.services.deploymentService.findFunction(funcName)
+      if (deployments.length > 0) {
+        endpoint = deployments[0].endpoint
+      }
+    }
+
+    if (!endpoint) {
+      throw new Error(
+        `No endpoint configured for remote RPC: ${funcName}. ` +
+          `Configure rpcEndpoint in externalPackages config or set up a DeploymentService.`
+      )
+    }
+
+    let secret: string | undefined
+    if (this.services.secrets) {
+      try {
+        secret = await this.services.secrets.getSecret('PIKKU_REMOTE_SECRET')
+      } catch {}
+    }
+    if (secret) {
+      if (!this.services.jwt) {
+        throw new Error(
+          'PIKKU_REMOTE_SECRET is set but JWT service is not available'
+        )
+      }
+      const session =
+        this.wire.getSession && typeof this.wire.getSession === 'function'
+          ? await this.wire.getSession()
+          : (this.wire as any).session
+      const sessionEnc = session
+        ? await encryptJSON(secret, { session })
+        : undefined
+      const token = await this.services.jwt.encode(
+        { value: 5, unit: 'minute' },
+        {
+          aud: 'pikku-remote',
+          fn: funcName,
+          iat: Date.now(),
+          session: sessionEnc,
+        }
+      )
+      headers.Authorization = `Bearer ${token}`
+    }
+
+    const url = `${endpoint}/rpc/${encodeURIComponent(funcName)}`
+    const timeoutMs = 30_000
+    const response = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ data }),
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+
+    if (!response.ok) {
+      let errorBody: string
+      try {
+        errorBody = JSON.stringify(await response.json())
+      } catch {
+        errorBody = await response.text()
+      }
+      throw new Error(
+        `Remote RPC call failed: ${response.status} ${response.statusText}. ${errorBody}`
+      )
+    }
+
+    try {
+      return (await response.json()) as Out
+    } catch {
+      const text = await response.text()
+      throw new Error(
+        `Remote RPC call returned non-JSON response: ${response.status} ${response.statusText}. ${text}`
+      )
+    }
+  }
 }
 
 // RPC Service class for the global interface
@@ -205,18 +364,29 @@ export class PikkuRPCService<
   getContextRPCService(
     services: Services,
     wire: PikkuWire,
-    requiresAuth?: boolean | undefined,
+    requiresAuthOrOptions?:
+      | boolean
+      | {
+          requiresAuth?: boolean
+          sessionService?: SessionService<CoreUserSession>
+        }
+      | undefined,
     depth: number = 0
   ): TypedRPC {
-    const serviceRPC = new ContextAwareRPCService(services, wire, {
-      requiresAuth,
-    })
+    const options =
+      typeof requiresAuthOrOptions === 'object' &&
+      requiresAuthOrOptions !== null
+        ? requiresAuthOrOptions
+        : { requiresAuth: requiresAuthOrOptions }
+    const serviceRPC = new ContextAwareRPCService(services, wire, options)
     return {
       depth,
       global: false,
       invoke: serviceRPC.rpc.bind(serviceRPC),
-      invokeExposed: serviceRPC.rpc.bind(serviceRPC),
+      remote: serviceRPC.remote.bind(serviceRPC),
+      exposed: serviceRPC.rpcExposed.bind(serviceRPC),
       startWorkflow: serviceRPC.startWorkflow.bind(serviceRPC),
+      agent: serviceRPC.agent.bind(serviceRPC),
       rpcWithWire: serviceRPC.rpcWithWire.bind(serviceRPC),
     } as any
   }

package/src/wirings/rpc/rpc-types.ts

@@ -1,13 +1,22 @@
-export type PikkuRPC<invoke extends Function = any> = {
+export type PikkuRPC<
+  Invoke extends Function = any,
+  Remote extends Function = any,
+  startWorkflow extends Function = any,
+  Agent extends Function = any,
+> = {
   depth: number
   global: boolean
-  invoke: invoke
+  invoke: Invoke
+  remote: Remote
+  exposed: (name: string, data: any) => Promise<any>
+  startWorkflow: startWorkflow
+  agent: Agent
 }
 
 export type RPCMeta = {
-  pikkuFuncName: string
+  pikkuFuncId: string
   expose: boolean
-  internal?: boolean
+  remote?: boolean
 }
 
 /**

package/src/wirings/scheduler/index.ts

@@ -1,9 +1,12 @@
-export * from './scheduler.types.js'
-
 export {
   runScheduledTask,
+  createSchedulerRuntimeHandlers,
   wireScheduler,
   getScheduledTasks,
 } from './scheduler-runner.js'
-
-export * from './log-schedulers.js'
+export { logSchedulers } from './log-schedulers.js'
+export type {
+  CoreScheduledTask,
+  ScheduledTasksMeta,
+  PikkuScheduledTask,
+} from './scheduler.types.js'

package/src/wirings/scheduler/scheduler-runner.test.ts

@@ -4,6 +4,7 @@ import {
   wireScheduler,
   runScheduledTask,
   getScheduledTasks,
+  createSchedulerRuntimeHandlers,
 } from './scheduler-runner.js'
 import { resetPikkuState, pikkuState } from '../../pikku-state.js'
 import { CoreScheduledTask } from './scheduler.types.js'
@@ -38,7 +39,7 @@ describe('wireScheduler', () => {
 
     // Set up metadata first
     pikkuState(null, 'scheduler', 'meta')['test-task'] = {
-      pikkuFuncName: 'scheduler_test-task',
+      pikkuFuncId: 'scheduler_test-task',
       name: 'test-task',
       schedule: '0 0 * * *',
     }
@@ -63,7 +64,10 @@ describe('wireScheduler', () => {
     assert.throws(
       () => wireScheduler(mockTask),
       (error: any) => {
-        assert.equal(error.message, 'Task metadata not found')
+        assert.equal(
+          error.message,
+          "Missing generated metadata for scheduled task 'missing-meta-task'"
+        )
         return true
       }
     )
@@ -81,7 +85,7 @@ describe('wireScheduler', () => {
 
     // Set up metadata
     pikkuState(null, 'scheduler', 'meta')['duplicate-task'] = {
-      pikkuFuncName: 'scheduler_duplicate-task',
+      pikkuFuncId: 'scheduler_duplicate-task',
       name: 'duplicate-task',
       schedule: '0 0 * * *',
     }
@@ -121,7 +125,7 @@ describe('wireScheduler', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['task-with-middleware'] = {
-      pikkuFuncName: 'scheduler_task-with-middleware',
+      pikkuFuncId: 'scheduler_task-with-middleware',
       name: 'task-with-middleware',
       schedule: '0 0 * * *',
     }
@@ -152,12 +156,12 @@ describe('runScheduledTask', () => {
 
     // Set up metadata and task
     pikkuState(null, 'scheduler', 'meta')['simple-task'] = {
-      pikkuFuncName: 'scheduler_simple-task',
+      pikkuFuncId: 'scheduler_simple-task',
       name: 'simple-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_simple-task'] = {
-      pikkuFuncName: 'scheduler_simple-task',
+      pikkuFuncId: 'scheduler_simple-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -185,19 +189,19 @@ describe('runScheduledTask', () => {
       schedule: '0 0 * * *',
       func: {
         func: async (services: any, data: any, wire: any) => {
-          receivedSession = await wire.session.get()
+          receivedSession = await wire.getSession()
         },
         auth: false,
       },
     }
 
     pikkuState(null, 'scheduler', 'meta')['task-with-session'] = {
-      pikkuFuncName: 'scheduler_task-with-session',
+      pikkuFuncId: 'scheduler_task-with-session',
       name: 'task-with-session',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_task-with-session'] = {
-      pikkuFuncName: 'scheduler_task-with-session',
+      pikkuFuncId: 'scheduler_task-with-session',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -274,12 +278,12 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['skipped-task'] = {
-      pikkuFuncName: 'scheduler_skipped-task',
+      pikkuFuncId: 'scheduler_skipped-task',
       name: 'skipped-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_skipped-task'] = {
-      pikkuFuncName: 'scheduler_skipped-task',
+      pikkuFuncId: 'scheduler_skipped-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -317,12 +321,12 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['skipped-task-no-reason'] = {
-      pikkuFuncName: 'scheduler_skipped-task-no-reason',
+      pikkuFuncId: 'scheduler_skipped-task-no-reason',
       name: 'skipped-task-no-reason',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_skipped-task-no-reason'] = {
-      pikkuFuncName: 'scheduler_skipped-task-no-reason',
+      pikkuFuncId: 'scheduler_skipped-task-no-reason',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -363,12 +367,12 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['wire-task'] = {
-      pikkuFuncName: 'scheduler_wire-task',
+      pikkuFuncId: 'scheduler_wire-task',
       name: 'wire-task',
       schedule: '*/5 * * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_wire-task'] = {
-      pikkuFuncName: 'scheduler_wire-task',
+      pikkuFuncId: 'scheduler_wire-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -401,12 +405,12 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['session-services-task'] = {
-      pikkuFuncName: 'scheduler_session-services-task',
+      pikkuFuncId: 'scheduler_session-services-task',
       name: 'session-services-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_session-services-task'] = {
-      pikkuFuncName: 'scheduler_session-services-task',
+      pikkuFuncId: 'scheduler_session-services-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -446,12 +450,12 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['cleanup-task'] = {
-      pikkuFuncName: 'scheduler_cleanup-task',
+      pikkuFuncId: 'scheduler_cleanup-task',
       name: 'cleanup-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_cleanup-task'] = {
-      pikkuFuncName: 'scheduler_cleanup-task',
+      pikkuFuncId: 'scheduler_cleanup-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -490,12 +494,12 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['error-cleanup-task'] = {
-      pikkuFuncName: 'scheduler_error-cleanup-task',
+      pikkuFuncId: 'scheduler_error-cleanup-task',
       name: 'error-cleanup-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_error-cleanup-task'] = {
-      pikkuFuncName: 'scheduler_error-cleanup-task',
+      pikkuFuncId: 'scheduler_error-cleanup-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -527,12 +531,12 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['error-task'] = {
-      pikkuFuncName: 'scheduler_error-task',
+      pikkuFuncId: 'scheduler_error-task',
       name: 'error-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_error-task'] = {
-      pikkuFuncName: 'scheduler_error-task',
+      pikkuFuncId: 'scheduler_error-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -574,12 +578,12 @@ describe('runScheduledTask', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['middleware-task'] = {
-      pikkuFuncName: 'scheduler_middleware-task',
+      pikkuFuncId: 'scheduler_middleware-task',
       name: 'middleware-task',
       schedule: '0 0 * * *',
     }
     pikkuState(null, 'function', 'meta')['scheduler_middleware-task'] = {
-      pikkuFuncName: 'scheduler_middleware-task',
+      pikkuFuncId: 'scheduler_middleware-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -608,7 +612,7 @@ describe('getScheduledTasks', () => {
     }
 
     pikkuState(null, 'scheduler', 'meta')['test-task'] = {
-      pikkuFuncName: 'scheduler_test-task',
+      pikkuFuncId: 'scheduler_test-task',
       name: 'test-task',
       schedule: '0 0 * * *',
     }
@@ -625,3 +629,43 @@ describe('getScheduledTasks', () => {
     assert.equal(tasks.size, 0)
   })
 })
+
+describe('createSchedulerRuntimeHandlers', () => {
+  test('invokes RPC with optional session and runs scheduled task callback', async () => {
+    const calls: Array<{ type: string; value: any }> = []
+    const logger = createMockLogger()
+    const singletonServices = { logger } as any
+
+    const handlers = createSchedulerRuntimeHandlers({
+      singletonServices,
+    })
+
+    const originalGetContextRPCService = (await import('../rpc/rpc-runner.js'))
+      .rpcService.getContextRPCService
+    ;(await import('../rpc/rpc-runner.js')).rpcService.getContextRPCService = ((
+      _services: any,
+      wire: any
+    ) => {
+      calls.push({ type: 'wire', value: wire })
+      return {
+        invoke: async (rpcName: string, data: any) => {
+          calls.push({ type: 'invoke', value: { rpcName, data } })
+        },
+      } as any
+    }) as any
+
+    try {
+      await handlers.invokeRPC('testRpc', { value: 1 }, { userId: 'u1' } as any)
+    } finally {
+      ;(await import('../rpc/rpc-runner.js')).rpcService.getContextRPCService =
+        originalGetContextRPCService
+    }
+
+    assert.equal(calls[0]?.type, 'wire')
+    assert.deepEqual(calls[0]?.value, { session: { userId: 'u1' } })
+    assert.deepEqual(calls[1]?.value, {
+      rpcName: 'testRpc',
+      data: { value: 1 },
+    })
+  })
+})

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

@@ -7,14 +7,20 @@ import {
 } from '../../types/core.types.js'
 import type { CoreScheduledTask } from './scheduler.types.js'
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js'
+import { PikkuMissingMetaError } from '../../errors/errors.js'
 import { closeWireServices } from '../../utils.js'
 import { pikkuState } from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
-import { PikkuSessionService } from '../../services/user-session-service.js'
+import {
+  PikkuSessionService,
+  createMiddlewareSessionWireProps,
+} from '../../services/user-session-service.js'
 import {
   CorePikkuFunctionConfig,
   CorePikkuFunctionSessionless,
 } from '../../function/functions.types.js'
+import { rpcService } from '../rpc/rpc-runner.js'
+import { SchedulerRuntimeHandlers } from '../../services/scheduler-service.js'
 
 export type RunScheduledTasksParams = {
   name: string
@@ -37,9 +43,11 @@ export const wireScheduler = <
   const meta = pikkuState(null, 'scheduler', 'meta')
   const taskMeta = meta[scheduledTask.name]
   if (!taskMeta) {
-    throw new Error('Task metadata not found')
+    throw new PikkuMissingMetaError(
+      `Missing generated metadata for scheduled task '${scheduledTask.name}'`
+    )
   }
-  addFunction(taskMeta.pikkuFuncName, {
+  addFunction(taskMeta.pikkuFuncId, {
     func: scheduledTask.func.func,
     auth: scheduledTask.func.auth,
     permissions: scheduledTask.func.permissions,
@@ -103,7 +111,7 @@ export async function runScheduledTask({
         throw new ScheduledTaskSkippedError(name, reason)
       },
     },
-    session: userSession,
+    ...createMiddlewareSessionWireProps(userSession),
   }
 
   try {
@@ -111,7 +119,7 @@ export async function runScheduledTask({
       `Running schedule task: ${name} | schedule: ${task.schedule}`
     )
 
-    await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncName, {
+    await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncId, {
       singletonServices,
       createWireServices,
       auth: false,
@@ -120,6 +128,7 @@ export async function runScheduledTask({
       wireMiddleware: task.middleware,
       tags: task.tags,
       wire,
+      sessionService: userSession,
     })
   } catch (e: any) {
     const errorResponse = getErrorResponse(e)
@@ -137,3 +146,34 @@ export async function runScheduledTask({
 export const getScheduledTasks = () => {
   return pikkuState(null, 'scheduler', 'tasks')
 }
+
+export const createSchedulerRuntimeHandlers = ({
+  singletonServices,
+  createWireServices,
+}: {
+  singletonServices: CoreSingletonServices
+  createWireServices?: CreateWireServices<
+    CoreSingletonServices,
+    CoreServices<CoreSingletonServices>,
+    CoreUserSession
+  >
+}): SchedulerRuntimeHandlers => {
+  return {
+    logger: singletonServices.logger,
+    invokeRPC: async (
+      rpcName: string,
+      data?: any,
+      session?: CoreUserSession
+    ) => {
+      const wire = session ? ({ session } as PikkuWire) : ({} as PikkuWire)
+      const rpc = rpcService.getContextRPCService(singletonServices, wire)
+      await rpc.invoke(rpcName, data)
+    },
+    runScheduledTask: async (name: string) =>
+      runScheduledTask({
+        name,
+        singletonServices,
+        createWireServices,
+      }),
+  }
+}

package/src/wirings/secret/index.ts

@@ -0,0 +1,9 @@
+export { wireSecret } from './secret.types.js'
+export type {
+  CoreSecret,
+  OAuth2CredentialConfig,
+  SecretDefinitionMeta,
+  SecretDefinitionsMeta,
+  SecretDefinitions,
+} from './secret.types.js'
+export { validateAndBuildSecretDefinitionsMeta } from './validate-secret-definitions.js'