@pikku/core 0.12.3 → 0.12.5

package/src/permissions.ts

@@ -133,6 +133,14 @@ const combinedPermissionsCache: Record<
   gateway: {},
 }
 
+export const clearPermissionsCache = () => {
+  for (const key of Object.keys(
+    combinedPermissionsCache
+  ) as PikkuWiringTypes[]) {
+    combinedPermissionsCache[key] = {}
+  }
+}
+
 /**
  * Combines wiring-specific permissions with function-level permissions.
  *

package/src/services/in-memory-workflow-service.test.ts

@@ -142,12 +142,12 @@ describe('InMemoryWorkflowService', () => {
       assert.ok(updated.failedAt)
     })
 
-    test('should return default step state for non-existent step', async () => {
+    test('should throw for non-existent step', async () => {
       const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.getStepState(runId, 'non-existent')
-      assert.strictEqual(step.stepId, '')
-      assert.strictEqual(step.status, 'pending')
-      assert.strictEqual(step.attemptCount, 0)
+      await assert.rejects(
+        () => service.getStepState(runId, 'non-existent'),
+        /Step not found/
+      )
     })
   })
 

package/src/services/in-memory-workflow-service.ts

@@ -3,6 +3,7 @@ import { PikkuWorkflowService } from '../wirings/workflow/pikku-workflow-service
 import type { SerializedError } from '../types/core.types.js'
 import type {
   WorkflowRun,
+  WorkflowRunService,
   WorkflowRunWire,
   StepState,
   WorkflowStatus,
@@ -31,7 +32,10 @@ interface InternalStepData {
  * await workflowService.startWorkflow('myWorkflow', input, { type: 'cli' }, rpc, { inline: true })
  * ```
  */
-export class InMemoryWorkflowService extends PikkuWorkflowService {
+export class InMemoryWorkflowService
+  extends PikkuWorkflowService
+  implements WorkflowRunService
+{
   private runs = new Map<string, WorkflowRun>()
   private steps = new Map<string, StepState>() // keyed by `${runId}:${stepName}`
   private stepData = new Map<string, InternalStepData>() // keyed by stepId
@@ -114,7 +118,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
     const stepId = randomUUID()
     const now = new Date()
 
-    const step: StepState = {
+    const step: StepState & { stepName: string } = {
       stepId,
       status: 'pending',
       attemptCount: 1,
@@ -122,15 +126,16 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
       retryDelay: stepOptions?.retryDelay,
       createdAt: now,
       updatedAt: now,
+      stepName,
     }
 
     const key = `${runId}:${stepName}`
     this.steps.set(key, step)
     this.stepData.set(stepId, { rpcName, data, stepName })
 
-    // Add to history
+    // Add to history (same reference so mutations are reflected)
     const history = this.stepHistory.get(runId) || []
-    history.push({ ...step, stepName })
+    history.push(step)
     this.stepHistory.set(runId, history)
 
     return step
@@ -140,13 +145,9 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
     const key = `${runId}:${stepName}`
     const step = this.steps.get(key)
     if (!step) {
-      return {
-        stepId: '',
-        status: 'pending',
-        attemptCount: 0,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      }
+      throw new Error(
+        `Step not found: runId=${runId}, stepName=${stepName}. Use insertStepState to create it.`
+      )
     }
     return step
   }
@@ -228,7 +229,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
     const newStepId = randomUUID()
     const now = new Date()
 
-    const newStep: StepState = {
+    const newStep: StepState & { stepName: string } = {
       stepId: newStepId,
       status,
       attemptCount: failedStep.attemptCount + 1,
@@ -236,6 +237,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
       retryDelay: failedStep.retryDelay,
       createdAt: now,
       updatedAt: now,
+      stepName: stepName,
     }
 
     if (status === 'running') {
@@ -250,14 +252,76 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
       this.stepData.set(newStepId, { ...failedStepData })
     }
 
-    // Add to history
+    // Add to history (same reference so mutations are reflected)
     const history = this.stepHistory.get(runId) || []
-    history.push({ ...newStep, stepName })
+    history.push(newStep)
     this.stepHistory.set(runId, history)
 
     return newStep
   }
 
+  async listRuns(options?: {
+    workflowName?: string
+    status?: string
+    limit?: number
+    offset?: number
+  }): Promise<WorkflowRun[]> {
+    let runs = Array.from(this.runs.values())
+    if (options?.workflowName) {
+      runs = runs.filter((r) => r.workflow === options.workflowName)
+    }
+    if (options?.status) {
+      runs = runs.filter((r) => r.status === options.status)
+    }
+    runs.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
+    const offset = options?.offset ?? 0
+    const limit = options?.limit ?? runs.length
+    return runs.slice(offset, offset + limit)
+  }
+
+  async getRunSteps(
+    runId: string
+  ): Promise<
+    Array<StepState & { stepName: string; rpcName?: string; data?: any }>
+  > {
+    const history = this.stepHistory.get(runId) || []
+    return history.map((step) => {
+      const stepDataEntry = this.stepData.get(step.stepId)
+      return {
+        ...step,
+        rpcName: stepDataEntry?.rpcName ?? undefined,
+        data: stepDataEntry?.data,
+      }
+    })
+  }
+
+  async getDistinctWorkflowNames(): Promise<string[]> {
+    const names = new Set<string>()
+    for (const run of this.runs.values()) {
+      names.add(run.workflow)
+    }
+    return Array.from(names)
+  }
+
+  async deleteRun(id: string): Promise<boolean> {
+    const existed = this.runs.has(id)
+    this.runs.delete(id)
+    this.stepHistory.delete(id)
+    this.runState.delete(id)
+    const prefix = `${id}:`
+    for (const key of this.steps.keys()) {
+      if (key.startsWith(prefix)) {
+        const step = this.steps.get(key)
+        if (step) {
+          this.stepData.delete(step.stepId)
+          this.branchKeys.delete(step.stepId)
+        }
+        this.steps.delete(key)
+      }
+    }
+    return existed
+  }
+
   async withRunLock<T>(_id: string, fn: () => Promise<T>): Promise<T> {
     // In-memory service doesn't need locking for inline execution
     return fn()

package/src/wirings/ai-agent/ai-agent-prepare.ts

@@ -21,7 +21,10 @@ import {
   resolveNamespace,
   ContextAwareRPCService,
 } from '../../wirings/rpc/rpc-runner.js'
-import { buildDynamicWorkflowInstructions, buildWorkflowTools } from './agent-dynamic-workflow.js'
+import {
+  buildDynamicWorkflowInstructions,
+  buildWorkflowTools,
+} from './agent-dynamic-workflow.js'
 import {
   resolveMemoryServices,
   loadContextMessages,
@@ -122,7 +125,10 @@ export async function buildInstructions(
   }
 
   if (meta?.dynamicWorkflows && meta.tools?.length) {
-    instructions += buildDynamicWorkflowInstructions(meta.tools, meta.dynamicWorkflows)
+    instructions += buildDynamicWorkflowInstructions(
+      meta.tools,
+      meta.dynamicWorkflows
+    )
   }
 
   return instructions
@@ -408,6 +414,23 @@ export async function buildToolDefs(
             params,
             agentSessionMap
           )
+          if (
+            result.status === 'suspended' &&
+            result.pendingApprovals?.length
+          ) {
+            return {
+              __approvalRequired: true,
+              toolName: subAgentName,
+              args: toolInput,
+              agentRunId: result.runId,
+              subApprovals: result.pendingApprovals.map((a) => ({
+                toolCallId: a.toolCallId,
+                toolName: a.toolName,
+                args: a.args,
+                runId: a.runId,
+              })),
+            }
+          }
           return result.object ?? result.text
         },
       })

package/src/wirings/channel/channel-middleware-runner.ts

@@ -30,6 +30,12 @@ const channelMiddlewareCache: Record<
   readonly CorePikkuChannelMiddleware[]
 > = {}
 
+export const clearChannelMiddlewareCache = () => {
+  for (const key of Object.keys(channelMiddlewareCache)) {
+    delete channelMiddlewareCache[key]
+  }
+}
+
 export const combineChannelMiddleware = (
   wireType: string,
   uid: string,

package/src/wirings/workflow/pikku-workflow-service.ts

@@ -464,25 +464,28 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       throw new Error(`Missing workflow graphHash for '${name}'`)
     }
 
+    const shouldInline =
+      options?.inline || !getSingletonServices()?.queueService
+
     const runId = await this.createRun(
       name,
       input,
-      options?.inline ?? false,
+      shouldInline,
       workflowMeta.graphHash,
       wire
     )
 
-    if (options?.inline) {
+    if (shouldInline) {
       this.inlineRuns.add(runId)
-    }
-
-    if (options?.inline || !getSingletonServices()?.queueService) {
       this.runWorkflowJob(runId, rpcService)
-        .catch(() => {})
+        .catch((err) => {
+          getSingletonServices()!.logger.error(
+            `Workflow ${name} (run ${runId}) failed:`,
+            err
+          )
+        })
         .finally(() => {
-          if (options?.inline) {
-            this.inlineRuns.delete(runId)
-          }
+          this.inlineRuns.delete(runId)
         })
     } else {
       await this.resumeWorkflow(runId)