@pikku/addon-meta-conversions 0.1.1 → 0.1.3

package/.pikku/function/pikku-functions-meta-verbose.gen.json

@@ -0,0 +1,33 @@
+{
+  "eventSend": {
+    "pikkuFuncId": "eventSend",
+    "functionType": "user",
+    "funcWrapper": "pikkuSessionlessFunc",
+    "sessionless": true,
+    "name": "eventSend",
+    "services": {
+      "optimized": true,
+      "services": [
+        "metaConversions"
+      ]
+    },
+    "inputSchemaName": "EventSendInput",
+    "outputSchemaName": "EventSendOutput",
+    "inputs": [
+      "EventSendInput"
+    ],
+    "outputs": [
+      "EventSendOutput"
+    ],
+    "implementationHash": "289d4066fc71925f",
+    "description": "Send server-side conversion events to Meta via the Conversions API",
+    "isDirectFunction": false,
+    "sourceFile": "/home/runner/work/addons/addons/packages/analytics/meta-conversions/src/functions/events/send.function.ts",
+    "exportedName": "eventSend",
+    "bodyStart": 49,
+    "bodyEnd": 49,
+    "contractHash": "5864ea42d4379da5",
+    "inputHash": "0030f99c",
+    "outputHash": "39d1f240"
+  }
+}

package/.pikku/function/pikku-functions-meta.gen.json

@@ -0,0 +1,27 @@
+{
+  "eventSend": {
+    "pikkuFuncId": "eventSend",
+    "functionType": "user",
+    "funcWrapper": "pikkuSessionlessFunc",
+    "sessionless": true,
+    "name": "eventSend",
+    "inputSchemaName": "EventSendInput",
+    "outputSchemaName": "EventSendOutput",
+    "inputs": [
+      "EventSendInput"
+    ],
+    "outputs": [
+      "EventSendOutput"
+    ],
+    "implementationHash": "289d4066fc71925f",
+    "contractHash": "5864ea42d4379da5",
+    "inputHash": "0030f99c",
+    "outputHash": "39d1f240",
+    "services": {
+      "optimized": true,
+      "services": [
+        "metaConversions"
+      ]
+    }
+  }
+}

package/.pikku/function/pikku-functions-meta.gen.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was generated by @pikku/cli@0.12.96
+ */
+import { pikkuState } from '@pikku/core/internal'
+import type { FunctionsMeta } from '@pikku/core'
+import metaData from './pikku-functions-meta.gen.json' with { type: 'json' }
+pikkuState('@pikku/addon-meta-conversions', 'function', 'meta', metaData as FunctionsMeta)

package/.pikku/function/pikku-functions.gen.ts

@@ -0,0 +1,8 @@
+/**
+ * This file was generated by @pikku/cli@0.12.96
+ */
+/* Import and register functions used by RPCs */
+import { addFunction } from '@pikku/core/function'
+import { eventSend } from '../../src/functions/events/send.function.js'
+
+addFunction('eventSend', eventSend, '@pikku/addon-meta-conversions')

package/.pikku/http/pikku-http-types.gen.ts

@@ -0,0 +1,119 @@
+/**
+ * This file was generated by @pikku/cli@0.12.96
+ */
+/**
+ * HTTP-specific type definitions for tree-shaking optimization
+ */
+
+import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, wireHTTPRoutes as wireHTTPRoutesCore, defineHTTPRoutes as defineHTTPRoutesCore } from '@pikku/core/http'
+import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware, PikkuFunctionConfig } from '../function/pikku-function-types.gen.js'
+import type { CoreHTTPFunctionWiring, HTTPMethod, HTTPRouteBaseConfig } from '@pikku/core/http'
+
+/**
+ * Type definition for HTTP API wirings with type-safe path parameters.
+ * Supports both authenticated and unauthenticated functions.
+ *
+ * @template In - Input type for the HTTP wiring
+ * @template Out - Output type for the HTTP wiring
+ * @template Route - String literal type for the HTTP path (e.g., "/users/:id")
+ */
+type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out, 'rpc' | 'session'>, PikkuFunctionSessionless<In, Out, 'rpc' | 'session'>, PikkuPermission<In>, PikkuMiddleware>
+
+/**
+ * Registers an HTTP wiring with the Pikku framework.
+ *
+ * @template In - Input type for the HTTP wiring
+ * @template Out - Output type for the HTTP wiring
+ * @template Route - String literal type for the HTTP path (e.g., "/users/:id")
+ * @param httpWiring - HTTP wiring definition with handler, method, and optional middleware
+ */
+export const wireHTTP = <In, Out, Route extends string>(
+  httpWiring: HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>
+) => {
+  wireHTTPCore(httpWiring as any)
+}
+
+/**
+ * Registers HTTP middleware either globally or for a specific route pattern.
+ *
+ * When a string route pattern is provided along with middleware, the middleware
+ * is applied only to that route. Otherwise, if an array is provided, it is treated
+ * as global middleware (applied to all routes).
+ *
+ * @param routeOrMiddleware - Either a global middleware array or a route pattern string
+ * @param middleware - The middleware array to apply when a route pattern is specified
+ *
+ * @example
+ * ```typescript
+ * // Add global HTTP middleware
+ * addHTTPMiddleware([authMiddleware, loggingMiddleware])
+ *
+ * // Add route-specific middleware
+ * addHTTPMiddleware('/api/admin/*', [adminAuthMiddleware])
+ * ```
+ */
+export const addHTTPMiddleware = (
+  routeOrMiddleware: PikkuMiddleware[] | string,
+  middleware?: PikkuMiddleware[]
+) => {
+  addHTTPMiddlewareCore(routeOrMiddleware as any, middleware as any)
+}
+
+/**
+ * Route configuration for wireHTTPRoutes with proper typing
+ */
+type HTTPRouteConfig = HTTPRouteBaseConfig & {
+  method: HTTPMethod
+  route: string
+  func: PikkuFunctionConfig<any, any, any, any, any, any>
+  auth?: boolean
+  middleware?: PikkuMiddleware[]
+  sse?: boolean
+}
+
+/**
+ * Typed route map for wireHTTPRoutes
+ */
+type TypedHTTPRouteMap = {
+  [key: string]: HTTPRouteConfig | TypedHTTPRouteMap | TypedHTTPRouteContract
+}
+
+/**
+ * Typed route contract for defineHTTPRoutes
+ */
+type TypedHTTPRouteContract<T extends TypedHTTPRouteMap = TypedHTTPRouteMap> = TypedHTTPRoutesGroupConfig & {
+  routes: T
+}
+
+/**
+ * Group config with typed middleware
+ */
+type TypedHTTPRoutesGroupConfig = {
+  basePath?: string
+  tags?: string[]
+  auth?: boolean
+  middleware?: PikkuMiddleware[]
+}
+
+/**
+ * Full config for wireHTTPRoutes
+ */
+type TypedWireHTTPRoutesConfig = TypedHTTPRoutesGroupConfig & {
+  routes: TypedHTTPRouteMap | HTTPRouteConfig[]
+}
+
+/**
+ * Type-safe helper for defining route contracts that can be composed.
+ */
+export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(routes: T): TypedHTTPRouteContract<T>
+export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(config: TypedHTTPRoutesGroupConfig & { routes: T }): TypedHTTPRouteContract<T>
+export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(configOrRoutes: T | (TypedHTTPRoutesGroupConfig & { routes: T })): TypedHTTPRouteContract<T> {
+  return defineHTTPRoutesCore(configOrRoutes as any) as unknown as TypedHTTPRouteContract<T>
+}
+
+/**
+ * Wires multiple HTTP routes from a nested map or array configuration.
+ */
+export const wireHTTPRoutes = (config: TypedWireHTTPRoutesConfig): void => {
+  wireHTTPRoutesCore(config as any)
+}

package/.pikku/mcp/pikku-mcp-types.gen.ts

@@ -0,0 +1,183 @@
+/**
+ * This file was generated by @pikku/cli@0.12.96
+ */
+/**
+ * MCP-specific type definitions for tree-shaking optimization
+ */
+
+import {
+  CoreMCPResource,
+  CoreMCPPrompt,
+  wireMCPResource as wireMCPResourceCore,
+  wireMCPPrompt as wireMCPPromptCore,
+  MCPResourceResponse,
+  MCPToolResponse,
+  MCPPromptResponse,
+  AssertMCPResourceURIParams
+} from '@pikku/core/mcp'
+
+import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuMiddleware, PikkuPermission, InferSchemaOutput } from '../function/pikku-function-types.gen.js'
+import type { CorePermissionGroup } from '@pikku/core'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+
+/**
+ * Type definition for MCP resources that provide data to AI models.
+ *
+ * @template In - Input type for the resource request
+ * @template URI - URI template string type for compile-time parameter validation
+ */
+type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse, 'rpc' | 'session' | 'mcp'>> & { uri: URI }
+
+/**
+ * Type definition for MCP prompts that provide templates to AI models.
+ *
+ * @template In - Input type for the prompt parameters
+ */
+type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptResponse, 'rpc' | 'session' | 'mcp'>>
+
+/**
+ * Registers an MCP resource with the Pikku framework.
+ * Resources provide data that AI models can access.
+ *
+ * @template In - Input type for the resource request
+ * @template URI - URI template string for compile-time parameter validation
+ * @param mcpResource - MCP resource definition with data provider function
+ */
+export const wireMCPResource = <In, URI extends string>(
+  mcpResource: MCPResourceWiring<In, URI> & AssertMCPResourceURIParams<In, URI>
+) => {
+  wireMCPResourceCore(mcpResource as any)
+}
+
+/**
+ * Registers an MCP prompt with the Pikku framework.
+ * Prompts provide templates that AI models can use.
+ *
+ * @template In - Input type for the prompt parameters
+ * @param mcpPrompt - MCP prompt definition with template function
+ */
+export const wireMCPPrompt = <In>(
+  mcpPrompt: MCPPromptWiring<In>
+) => {
+  wireMCPPromptCore(mcpPrompt as any)
+}
+
+/**
+ * Configuration for MCP prompt with Zod schema input validation.
+ */
+type MCPPromptFuncConfigWithSchema<InputSchema extends StandardSchemaV1> = {
+  func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
+  name?: string
+  input: InputSchema
+}
+
+/**
+ * Creates a function for handling MCP prompt requests.
+ * These functions generate prompt templates for AI models.
+ *
+ * Supports two patterns:
+ * 1. Generic types: `pikkuMCPPromptFunc<Input>({ func: ... })`
+ * 2. Zod schemas: `pikkuMCPPromptFunc({ input: z.object(...), func: ... })`
+ *
+ * @template In - Input type for the prompt parameters (inferred from schema if provided)
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export function pikkuMCPPromptFunc<InputSchema extends StandardSchemaV1>(
+  config: MCPPromptFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
+export function pikkuMCPPromptFunc<In>(
+  func:
+    | PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp' | 'rpc'>
+    | {
+        func: PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp' | 'rpc'>
+        name?: string
+      }
+): PikkuFunctionConfig<In, MCPPromptResponse, 'mcp' | 'rpc'>
+export function pikkuMCPPromptFunc(func: any): any {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Configuration for MCP tool with Zod schema input validation.
+ */
+type MCPToolFuncConfigWithSchema<InputSchema extends StandardSchemaV1> = {
+  func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+  description?: string
+  tags?: string[]
+  title?: string
+  summary?: string
+  name?: string
+  middleware?: PikkuMiddleware[]
+  permissions?: CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>
+  input: InputSchema
+}
+
+/**
+ * Creates a function for handling MCP tool invocations.
+ * These functions perform actions that AI models can request.
+ *
+ * Supports two patterns:
+ * 1. Generic types: `pikkuMCPToolFunc<Input>({ func: ... })`
+ * 2. Zod schemas: `pikkuMCPToolFunc({ input: z.object(...), func: ... })`
+ *
+ * @template In - Input type for the tool invocation (inferred from schema if provided)
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export function pikkuMCPToolFunc<InputSchema extends StandardSchemaV1>(
+  config: MCPToolFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+export function pikkuMCPToolFunc<In>(
+  func:
+    | PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
+    | {
+      func: PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
+      description?: string
+      tags?: string[]
+      title?: string
+      summary?: string
+      name?: string
+      middleware?: PikkuMiddleware[]
+      permissions?: CorePermissionGroup<PikkuPermission<In>>
+    }
+): PikkuFunctionConfig<In, MCPToolResponse, 'mcp' | 'rpc'>
+export function pikkuMCPToolFunc(func: any): any {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Configuration for MCP resource with Zod schema input validation.
+ */
+type MCPResourceFuncConfigWithSchema<InputSchema extends StandardSchemaV1> = {
+  func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
+  name?: string
+  input: InputSchema
+}
+
+/**
+ * Creates a function for handling MCP resource requests.
+ * These functions provide data that AI models can access.
+ *
+ * Supports two patterns:
+ * 1. Generic types: `pikkuMCPResourceFunc<Input>({ func: ... })`
+ * 2. Zod schemas: `pikkuMCPResourceFunc({ input: z.object(...), func: ... })`
+ *
+ * @template In - Input type for the resource request (inferred from schema if provided)
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export function pikkuMCPResourceFunc<InputSchema extends StandardSchemaV1>(
+  config: MCPResourceFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
+export function pikkuMCPResourceFunc<In>(
+  func:
+    | PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp' | 'rpc'>
+    | {
+      func: PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp' | 'rpc'>
+      name?: string
+    }
+): PikkuFunctionConfig<In, MCPResourceResponse, 'mcp' | 'rpc'>
+export function pikkuMCPResourceFunc(func: any): any {
+  return typeof func === 'function' ? { func } : func
+}

package/.pikku/pikku-bootstrap-scenarios.gen.ts

@@ -0,0 +1,9 @@
+/**
+ * This file was generated by @pikku/cli@0.12.96
+ */
+import './pikku-bootstrap.gen.js'
+import './scenarios/schemas/register.gen.js'
+import './scenarios/pikku-scenario-functions-meta.gen.js'
+import './scenarios/pikku-scenario-functions.gen.js'
+import './scenarios/pikku-scenario-wirings-meta.gen.js'
+import './scenarios/pikku-scenario-wirings.gen.js'

package/.pikku/pikku-bootstrap.gen.ts

@@ -0,0 +1,8 @@
+/**
+ * This file was generated by @pikku/cli@0.12.96
+ */
+import './rpc/pikku-rpc-wirings-meta.internal.gen.js'
+import './function/pikku-functions-meta.gen.js'
+import './addon/pikku-package.gen.js'
+import './schemas/register.gen.js'
+import './function/pikku-functions.gen.js'

package/.pikku/pikku-meta-service.gen.ts

@@ -0,0 +1,10 @@
+/**
+ * This file was generated by @pikku/cli@0.12.96
+ */
+import { LocalMetaService } from '@pikku/core/services/local-meta'
+
+export class PikkuMetaService extends LocalMetaService {
+  constructor() {
+    super('/home/runner/work/addons/addons/packages/analytics/meta-conversions/.pikku')
+  }
+}

package/.pikku/pikku-services.gen.ts

@@ -0,0 +1,50 @@
+/**
+ * This file was generated by @pikku/cli@0.12.96
+ */
+import type { SingletonServices } from '../types/application-types.d.js'
+import type { Services } from '../types/application-types.d.js'
+
+// Singleton services map: true if required, false if available but unused
+export const requiredSingletonServices = {
+  'agentRunService': false,
+  'aiAgentRunner': false,
+  'aiEmbedding': false,
+  'aiRunState': false,
+  'aiStorage': false,
+  'audit': false,
+  'auditLog': false,
+  'auth': false,
+  'config': true,
+  'content': false,
+  'coverageService': false,
+  'credentialService': false,
+  'deploymentService': false,
+  'emailService': false,
+  'eventHub': false,
+  'jwt': false,
+  'logger': true,
+  'metaConversions': false,
+  'metaService': false,
+  'queueService': false,
+  'schedulerService': false,
+  'schema': true,
+  'scopeService': false,
+  'secrets': true,
+  'sessionStore': false,
+  'variables': true,
+  'webhookService': false,
+  'workflowRunService': false,
+  'workflowService': false,
+} as const
+
+// Wire services map: true if required, false if available but unused
+export const requiredWireServices = {
+} as const
+
+// Type exports
+export type RequiredSingletonServices = Required<Pick<SingletonServices, 'config' | 'logger' | 'schema' | 'secrets' | 'variables'>> & Partial<Omit<SingletonServices, 'config' | 'logger' | 'schema' | 'secrets' | 'variables'>>
+
+export type RequiredWireServices = Partial<Services>
+
+// Services this addon needs from the parent project
+export const requiredParentServices = ["secrets"] as const

package/.pikku/pikku-types.gen.ts

@@ -0,0 +1,24 @@
+/**
+ * This file was generated by @pikku/cli@0.12.96
+ */
+/**
+ * Main type export hub - re-exports all wiring-specific types
+ */
+
+// Core function, middleware, and permission types
+export * from './function/pikku-function-types.gen.js'
+
+// Trigger wiring types
+export * from './trigger/pikku-trigger-types.gen.js'
+
+// Node wiring types
+export * from './console/pikku-node-types.gen.js'
+
+// Secret definition types
+export * from './secrets/pikku-secret-types.gen.js'
+
+// Scope definition types
+export * from './scopes/pikku-scope-types.gen.js'
+
+// Addon types
+export * from './addon/pikku-addon-types.gen.js'

package/.pikku/queue/pikku-queue-types.gen.ts

@@ -0,0 +1,27 @@
+/**
+ * This file was generated by @pikku/cli@0.12.96
+ */
+/**
+ * Queue-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreQueueWorker, wireQueueWorker as wireQueueWorkerCore } from '@pikku/core/queue'
+import type { PikkuFunctionConfig } from '../function/pikku-function-types.gen.js'
+
+/**
+ * Type definition for queue workers that process background jobs.
+ *
+ * @template In - Input type for the queue job
+ * @template Out - Output type for the queue job
+ */
+type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out, 'session' | 'rpc'>>
+
+/**
+ * Registers a queue worker with the Pikku framework.
+ * Workers process background jobs from queues.
+ *
+ * @param queueWorker - Queue worker definition with job handler
+ */
+export const wireQueueWorker = (queueWorker: QueueWiring<any, any>) => {
+  wireQueueWorkerCore(queueWorker as any)
+}

package/.pikku/rpc/pikku-rpc-wirings-map.gen.d.ts

@@ -0,0 +1,135 @@
+/**
+ * This file was generated by @pikku/cli@0.12.96
+ */
+/**
+ * This provides the structure needed for typescript to be aware of RPCs and their return types
+ */
+
+
+
+
+
+export type EventSendInput = {
+    /** Array of server events to send (max 1000 per request) */
+    data: {
+        /** Standard or custom event name (e.g., Purchase, Lead, AddToCart, PageView, ViewContent) */
+        event_name: string;
+        /** Unix timestamp in seconds when the event occurred */
+        event_time: number;
+        /** Unique event ID for deduplication with browser pixel events */
+        event_id?: string | undefined;
+        /** URL where the event occurred */
+        event_source_url?: string | undefined;
+        /** Where the conversion occurred */
+        action_source: "website" | "email" | "app" | "phone_call" | "chat" | "physical_store" | "system_generated" | "other";
+        /** Hashed user data for matching (em, ph, fn, ln, ct, st, zp, country, external_id, client_ip_address, client_user_agent, fbc, fbp) */
+        user_data: {
+            [key: string]: string | string[];
+        };
+        /** Custom event data (value, currency, content_name, content_ids, contents, num_items, etc.) */
+        custom_data?: {
+            [key: string]: unknown;
+        } | undefined;
+        /** If true, event is used for attribution but not ad delivery optimization */
+        opt_out?: boolean | undefined;
+    }[];
+    /** Test event code from Events Manager for testing without affecting production data */
+    test_event_code?: string | undefined;
+}
+export type EventSendOutput = {
+    /** Number of events received by Meta */
+    events_received: number;
+    /** Diagnostic messages from the API */
+    messages: string[];
+    /** Trace ID for debugging with Meta support */
+    fbtrace_id: string;
+}
+export type SecretSchema_metaConversions = {
+    /** Meta Pixel ID */
+    pixelId: string;
+    /** Conversions API access token (generated in Events Manager) */
+    accessToken: string;
+}
+
+interface RPCHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+export type RPCMap = {
+};
+
+
+
+// No addon packages, use RPCMap directly
+export type FlattenedRPCMap = RPCMap
+
+type IsAny<T> = 0 extends (1 & T) ? true : false
+type IsVoidishInput<T> = IsAny<T> extends true
+  ? false
+  : [T] extends [void | null | undefined]
+    ? true
+    : false
+
+
+export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
+  ...args: IsVoidishInput<FlattenedRPCMap[Name]['input']> extends true
+    ? [name: Name]
+    : [name: Name, data: FlattenedRPCMap[Name]['input']]
+) => Promise<FlattenedRPCMap[Name]['output']>
+
+export type RPCRemote = <Name extends keyof FlattenedRPCMap>(
+  ...args: IsVoidishInput<FlattenedRPCMap[Name]['input']> extends true
+    ? [name: Name]
+    : [name: Name, data: FlattenedRPCMap[Name]['input']]
+) => Promise<FlattenedRPCMap[Name]['output']>
+
+import type { FlattenedWorkflowMap } from '../workflow/pikku-workflow-map.gen.d.js'
+
+import type { AgentMap } from '../agent/pikku-agent-map.gen.d.js'
+
+
+type FlattenedAgentMap = AgentMap
+
+
+import type { PikkuRPC } from '@pikku/core/rpc'
+
+interface AIAgentInput {
+  message: string
+  threadId: string
+  resourceId: string
+}
+
+export type TypedStartWorkflow = <Name extends keyof FlattenedWorkflowMap>(
+  name: Name,
+  input: FlattenedWorkflowMap[Name]['input'],
+  options?: { startNode?: string }
+) => Promise<{ runId: string }>
+
+export type TypedRunWorkflow = <Name extends keyof FlattenedWorkflowMap>(
+  name: Name,
+  input: FlattenedWorkflowMap[Name]['input']
+) => Promise<FlattenedWorkflowMap[Name]['output']>
+
+export type TypedWorkflowStatus = (
+  workflowName: string,
+  runId: string
+) => Promise<{ id: string; status: 'running' | 'suspended' | 'completed' | 'failed' | 'cancelled'; output?: unknown; error?: { message?: string } }>
+
+type TypedAgentRun = [keyof FlattenedAgentMap] extends [never]
+  ? (name: string, input: AIAgentInput) => Promise<any>
+  : <Name extends keyof FlattenedAgentMap>(
+      name: Name,
+      input: AIAgentInput
+    ) => Promise<{ runId: string; result: FlattenedAgentMap[Name]['output']; usage: { inputTokens: number; outputTokens: number } }>
+
+type TypedAgentStream = [keyof FlattenedAgentMap] extends [never]
+  ? (name: string, input: AIAgentInput, options?: { requiresToolApproval?: 'all' | 'explicit' | false }) => Promise<void>
+  : <Name extends keyof FlattenedAgentMap>(
+      name: Name,
+      input: AIAgentInput,
+      options?: { requiresToolApproval?: 'all' | 'explicit' | false }
+    ) => Promise<void>
+
+export type TypedPikkuRPC = PikkuRPC<RPCInvoke, RPCRemote, TypedStartWorkflow, TypedAgentRun, TypedAgentStream>
+