@pikku/core 0.12.20 → 0.12.22

package/src/index.ts

@@ -123,8 +123,18 @@ export { createGraph } from './wirings/workflow/graph/graph-node.js'
 export { wireAddon } from './wirings/rpc/wire-addon.js'
 export type { WireAddonConfig } from './wirings/rpc/wire-addon.js'
 export type { PikkuPackageState } from './types/state.types.js'
-export { runMiddleware, addMiddleware } from './middleware-runner.js'
-export { addPermission, checkAuthPermissions } from './permissions.js'
+export {
+  runMiddleware,
+  addTagMiddleware,
+  addTagMiddleware as addMiddleware,
+  addGlobalMiddleware,
+} from './middleware-runner.js'
+export {
+  addTagPermission,
+  addTagPermission as addPermission,
+  addGlobalPermission,
+  checkAuthPermissions,
+} from './permissions.js'
 export { isSerializable, stopSingletonServices } from './utils.js'
 export { getSingletonServices, getCreateWireServices } from './pikku-state.js'
 export {

package/src/middleware/index.ts

@@ -4,5 +4,14 @@ export { authBearer } from './auth-bearer.js'
 export { pikkuRemoteAuthMiddleware } from './remote-auth.js'
 export { cors } from './cors.js'
 export { telemetryOuter, telemetryInner } from './telemetry.js'
-export { addMiddleware, runMiddleware } from '../middleware-runner.js'
-export { addPermission } from '../permissions.js'
+export {
+  addTagMiddleware,
+  addTagMiddleware as addMiddleware,
+  addGlobalMiddleware,
+  runMiddleware,
+} from '../middleware-runner.js'
+export {
+  addTagPermission,
+  addTagPermission as addPermission,
+  addGlobalPermission,
+} from '../permissions.js'

package/src/middleware/telemetry.ts

@@ -13,7 +13,7 @@ import { pikkuMiddleware, pikkuMiddlewareFactory } from '../types/core.types.js'
  * @example
  * ```typescript
  * import { telemetryOuter } from '@pikku/core/middleware'
- * addMiddleware('myTag', [telemetryOuter()])
+ * addTagMiddleware('myTag', [telemetryOuter()])
  * ```
  */
 export const telemetryOuter = pikkuMiddlewareFactory<{
@@ -70,7 +70,7 @@ export const telemetryOuter = pikkuMiddlewareFactory<{
  * @example
  * ```typescript
  * import { telemetryInner } from '@pikku/core/middleware'
- * addMiddleware('myTag', [telemetryInner()])
+ * addTagMiddleware('myTag', [telemetryInner()])
  * ```
  */
 export const telemetryInner = pikkuMiddlewareFactory<{

package/src/middleware-runner.test.ts

@@ -2,7 +2,7 @@ import { describe, test, beforeEach } from 'node:test'
 import assert from 'node:assert'
 import {
   combineMiddleware,
-  addMiddleware,
+  addTagMiddleware,
   runMiddleware,
 } from './middleware-runner.js'
 import { resetPikkuState } from './pikku-state.js'
@@ -115,8 +115,8 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    addMiddleware('wiringTag', [wiringTagMiddleware])
-    addMiddleware('funcTag', [funcTagMiddleware])
+    addTagMiddleware('wiringTag', [wiringTagMiddleware])
+    addTagMiddleware('funcTag', [funcTagMiddleware])
 
     const wiringMiddleware: CorePikkuMiddleware = async (
       services,
@@ -157,7 +157,7 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    addMiddleware('testTag', [taggedMiddleware])
+    addTagMiddleware('testTag', [taggedMiddleware])
 
     const result = combineMiddleware('http', Math.random().toString(), {
       wireInheritedMiddleware: [{ type: 'tag', tag: 'testTag' }],
@@ -176,7 +176,7 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    addMiddleware('funcTestTag', [taggedMiddleware])
+    addTagMiddleware('funcTestTag', [taggedMiddleware])
 
     const result = combineMiddleware('http', Math.random().toString(), {
       funcInheritedMiddleware: [{ type: 'tag', tag: 'funcTestTag' }],
@@ -194,8 +194,8 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    addMiddleware('tag1', [middleware1])
-    addMiddleware('tag2', [middleware2])
+    addTagMiddleware('tag1', [middleware1])
+    addTagMiddleware('tag2', [middleware2])
 
     const result = combineMiddleware('http', Math.random().toString(), {
       wireInheritedMiddleware: [
@@ -218,7 +218,7 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    addMiddleware('billing', [billingMiddleware])
+    addTagMiddleware('billing', [billingMiddleware])
 
     const result = combineMiddleware('http', Math.random().toString(), {
       wireInheritedMiddleware: [{ type: 'tag', tag: 'billing:read' }],
@@ -237,7 +237,7 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    addMiddleware('billing', [billingMiddleware])
+    addTagMiddleware('billing', [billingMiddleware])
 
     const result = combineMiddleware('http', Math.random().toString(), {
       wireInheritedMiddleware: [{ type: 'tag', tag: 'billing' }],
@@ -263,8 +263,8 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    addMiddleware('billing', [billingMiddleware])
-    addMiddleware('billing:read', [billingReadMiddleware])
+    addTagMiddleware('billing', [billingMiddleware])
+    addTagMiddleware('billing:read', [billingReadMiddleware])
 
     const result = combineMiddleware('http', Math.random().toString(), {
       wireInheritedMiddleware: [{ type: 'tag', tag: 'billing:read' }],
@@ -298,9 +298,9 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    addMiddleware('billing', [billingMiddleware])
-    addMiddleware('billing:read', [billingReadMiddleware])
-    addMiddleware('billing:read:admin', [billingReadAdminMiddleware])
+    addTagMiddleware('billing', [billingMiddleware])
+    addTagMiddleware('billing:read', [billingReadMiddleware])
+    addTagMiddleware('billing:read:admin', [billingReadAdminMiddleware])
 
     const result = combineMiddleware('http', Math.random().toString(), {
       wireInheritedMiddleware: [{ type: 'tag', tag: 'billing:read:admin' }],
@@ -321,7 +321,7 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    addMiddleware('billing', [billingMiddleware])
+    addTagMiddleware('billing', [billingMiddleware])
 
     const result = combineMiddleware('http', Math.random().toString(), {
       funcInheritedMiddleware: [{ type: 'tag', tag: 'billing:write' }],
@@ -336,7 +336,7 @@ describe('combineMiddleware', () => {
       await next()
     }
 
-    addMiddleware('existingTag', [middleware])
+    addTagMiddleware('existingTag', [middleware])
 
     const result = combineMiddleware('http', Math.random().toString(), {
       wireInheritedMiddleware: [

package/src/middleware-runner.ts

@@ -91,39 +91,16 @@ const isSortedByPriority = (
 }
 
 /**
- * Registers global middleware for a specific tag.
+ * Registers tag-scoped middleware. Applies to any wiring (HTTP, Channel,
+ * Queue, Scheduler, MCP, CLI, Workflow, Agent) that carries the matching tag.
  *
- * This function registers middleware at runtime that will be applied to
- * any wiring (HTTP, Channel, Queue, Scheduler, MCP, CLI) that includes the matching tag.
- *
- * For tree-shaking benefits, wrap in a factory function:
- * `export const x = () => addMiddleware('tag', [...])`
- *
- * Accepts an array that can contain:
- * - Direct middleware functions (CorePikkuMiddleware)
- * - Factory middleware functions (CorePikkuMiddlewareFactory)
- *
- * @template PikkuMiddleware The middleware type.
- * @param {string} tag - The tag that the middleware should apply to.
- * @param {CorePikkuMiddlewareGroup} middleware - Array of middleware for this tag.
- *
- * @returns {CorePikkuMiddlewareGroup} The middleware array (for chaining/wrapping).
+ * For tree-shaking, wrap in a factory:
+ * `export const x = () => addTagMiddleware('tag', [...])`
  *
  * @example
- * ```typescript
- * // Recommended: tree-shakeable
- * export const adminMiddleware = () => addMiddleware('admin', [
- *   authMiddleware,
- *   loggingMiddleware({ level: 'info' })
- * ])
- *
- * // Also works: no tree-shaking
- * export const apiMiddleware = addMiddleware('api', [
- *   rateLimitMiddleware
- * ])
- * ```
+ * export const adminMiddleware = () => addTagMiddleware('admin', [authMiddleware])
  */
-export const addMiddleware = <PikkuMiddleware extends CorePikkuMiddleware>(
+export const addTagMiddleware = <PikkuMiddleware extends CorePikkuMiddleware>(
   tag: string,
   middleware: CorePikkuMiddlewareGroup,
   packageName: string | null = null
@@ -133,6 +110,33 @@ export const addMiddleware = <PikkuMiddleware extends CorePikkuMiddleware>(
   return middleware
 }
 
+/**
+ * Registers wire-agnostic global middleware. Runs at the top of every
+ * wiring's middleware chain — before wire-, tag-, and function-level
+ * entries — across HTTP, Channel, Queue, Scheduler, MCP, CLI, Workflow, Agent.
+ *
+ * Resolution order: global → wire → tag → function.
+ *
+ * @example
+ * addGlobalMiddleware([telemetryMiddleware])
+ */
+export const addGlobalMiddleware = <
+  PikkuMiddleware extends CorePikkuMiddleware,
+>(
+  middleware: CorePikkuMiddlewareGroup,
+  packageName: string | null = null
+): CorePikkuMiddlewareGroup => {
+  const state = pikkuState(
+    packageName,
+    'middleware',
+    'global'
+  ) as unknown as CorePikkuMiddlewareGroup
+  ;(state as CorePikkuMiddleware[]).push(
+    ...(middleware as CorePikkuMiddleware[])
+  )
+  return middleware
+}
+
 /**
  * Retrieves a registered middleware function by its name.
  *
@@ -218,7 +222,15 @@ export const combineMiddleware = (
 
   const resolved: CorePikkuMiddleware[] = []
 
-  // 1. Resolve wire inherited middleware (HTTP + tag groups + individual wire middleware)
+  const globals = pikkuState(
+    packageName,
+    'middleware',
+    'global'
+  ) as unknown as CorePikkuMiddleware[]
+  if (globals && globals.length > 0) {
+    resolved.push(...globals)
+  }
+
   if (wireInheritedMiddleware) {
     for (const meta of wireInheritedMiddleware) {
       if (meta.type === 'http') {

package/src/permissions.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, beforeEach } from 'node:test'
 import * as assert from 'node:assert'
-import { addPermission, runPermissions } from './permissions.js'
+import { addTagPermission, runPermissions } from './permissions.js'
 import { pikkuState, resetPikkuState } from './pikku-state.js'
 import type { CoreServices, CoreUserSession } from './types/core.types.js'
 import type {
@@ -47,11 +47,11 @@ const mockSession: CoreUserSession = {
   userId: 'test-user',
 } as any
 
-describe('addPermission', () => {
+describe('addTagPermission', () => {
   test('should add single permission for a tag', () => {
     const mockPermission = async () => true
 
-    addPermission('testTag', [mockPermission])
+    addTagPermission('testTag', [mockPermission])
 
     const permissions = getPermissionsForTags(['testTag'])
     assert.equal(permissions.length, 1)
@@ -62,7 +62,7 @@ describe('addPermission', () => {
     const mockPermission1 = async () => true
     const mockPermission2 = async () => false
 
-    addPermission('multiTestTag', [mockPermission1, mockPermission2])
+    addTagPermission('multiTestTag', [mockPermission1, mockPermission2])
 
     const permissions = getPermissionsForTags(['multiTestTag'])
     assert.equal(permissions.length, 2)
@@ -75,7 +75,7 @@ describe('addPermission', () => {
       permissions: [async () => true, async () => false],
     }
 
-    addPermission('groupTestTag', mockPermissionGroup)
+    addTagPermission('groupTestTag', mockPermissionGroup)
 
     const permissions = getPermissionsForTags(['groupTestTag'])
     assert.equal(permissions.length, 1)
@@ -85,7 +85,7 @@ describe('addPermission', () => {
   test('should apply parent tag permission to namespaced tag via runPermissions', async () => {
     const billingPermission = async () => true
 
-    addPermission('billing', [billingPermission])
+    addTagPermission('billing', [billingPermission])
 
     await runPermissions('rpc', Math.random().toString(), {
       wireInheritedPermissions: [{ type: 'tag', tag: 'billing:write' }],
@@ -106,8 +106,8 @@ describe('addPermission', () => {
       return true
     }
 
-    addPermission('billing', [billingPermission])
-    addPermission('billing:read', [billingReadPermission])
+    addTagPermission('billing', [billingPermission])
+    addTagPermission('billing:read', [billingReadPermission])
 
     await runPermissions('rpc', Math.random().toString(), {
       wireInheritedPermissions: [{ type: 'tag', tag: 'billing:read' }],
@@ -134,9 +134,9 @@ describe('addPermission', () => {
       return true
     }
 
-    addPermission('billing', [billingPermission])
-    addPermission('billing:read', [billingReadPermission])
-    addPermission('billing:read:admin', [billingReadAdminPermission])
+    addTagPermission('billing', [billingPermission])
+    addTagPermission('billing:read', [billingReadPermission])
+    addTagPermission('billing:read:admin', [billingReadAdminPermission])
 
     await runPermissions('rpc', Math.random().toString(), {
       wireInheritedPermissions: [{ type: 'tag', tag: 'billing:read:admin' }],
@@ -151,7 +151,7 @@ describe('addPermission', () => {
   test('should apply parent tag permission via funcInheritedPermissions', async () => {
     const billingPermission = async () => true
 
-    addPermission('billing', [billingPermission])
+    addTagPermission('billing', [billingPermission])
 
     await runPermissions('rpc', Math.random().toString(), {
       funcInheritedPermissions: [{ type: 'tag', tag: 'billing:delete' }],
@@ -164,11 +164,11 @@ describe('addPermission', () => {
   test('should throw error when tag already exists', () => {
     const mockPermission = async () => true
 
-    addPermission('duplicateTag', [mockPermission])
+    addTagPermission('duplicateTag', [mockPermission])
 
     assert.throws(
       () => {
-        addPermission('duplicateTag', [mockPermission])
+        addTagPermission('duplicateTag', [mockPermission])
       },
       {
         message:
@@ -195,7 +195,7 @@ describe('runPermissions', () => {
       return true
     }
 
-    addPermission('wiringTag', [wiringTagPermission])
+    addTagPermission('wiringTag', [wiringTagPermission])
 
     await runPermissions('rpc', Math.random().toString(), {
       wireInheritedPermissions: [{ type: 'tag', tag: 'wiringTag' }],
@@ -219,8 +219,8 @@ describe('runPermissions', () => {
       return true
     }
 
-    addPermission('wiringTag', [wiringTagPermission])
-    addPermission('funcTag', [funcTagPermission])
+    addTagPermission('wiringTag', [wiringTagPermission])
+    addTagPermission('funcTag', [funcTagPermission])
 
     const wirePermissions: CorePermissionGroup = {
       permissions: [
@@ -258,7 +258,10 @@ describe('runPermissions', () => {
     const failingPermission = async () => false
     const passingPermission = async () => true
 
-    addPermission('atLeastOneTestTag', [failingPermission, passingPermission])
+    addTagPermission('atLeastOneTestTag', [
+      failingPermission,
+      passingPermission,
+    ])
 
     // Should not throw because at least one permission passes
     await runPermissions('rpc', Math.random().toString(), {
@@ -273,7 +276,7 @@ describe('runPermissions', () => {
     const failingPermission1 = async () => false
     const failingPermission2 = async () => false
 
-    addPermission('allFailTestTag', [failingPermission1, failingPermission2])
+    addTagPermission('allFailTestTag', [failingPermission1, failingPermission2])
 
     await assert.rejects(
       runPermissions('rpc', Math.random().toString(), {
@@ -309,7 +312,7 @@ describe('runPermissions', () => {
   test('should throw error when all function tag permissions fail', async () => {
     const failingPermission = async () => false
 
-    addPermission('funcTag', [failingPermission])
+    addTagPermission('funcTag', [failingPermission])
 
     await assert.rejects(
       runPermissions('rpc', Math.random().toString(), {
@@ -350,7 +353,7 @@ describe('runPermissions', () => {
       return false
     }
 
-    addPermission('failingWiringTag', [failingWiringTagPermission])
+    addTagPermission('failingWiringTag', [failingWiringTagPermission])
 
     const wirePermissions: CorePermissionGroup = {
       permissions: [
@@ -377,7 +380,7 @@ describe('runPermissions', () => {
   test('should handle array permissions in tag-based permissions', async () => {
     const arrayPermission = [async () => true, async () => false]
 
-    addPermission('arrayTestTag', arrayPermission)
+    addTagPermission('arrayTestTag', arrayPermission)
 
     // Should not throw because verifyPermissions handles array properly
     await runPermissions('rpc', Math.random().toString(), {
@@ -393,7 +396,7 @@ describe('runPermissions', () => {
       permissions: [async () => true],
     }
 
-    addPermission('objectTestTag', permissionGroup)
+    addTagPermission('objectTestTag', permissionGroup)
 
     // Should not throw because verifyPermissions handles objects properly
     await runPermissions('rpc', Math.random().toString(), {
@@ -418,7 +421,7 @@ describe('runPermissions', () => {
 
     const testData = { test: 'data' }
 
-    addPermission('paramTestTag', [testPermission])
+    addTagPermission('paramTestTag', [testPermission])
 
     await runPermissions('rpc', Math.random().toString(), {
       wireInheritedPermissions: [{ type: 'tag', tag: 'paramTestTag' }],

package/src/permissions.ts

@@ -75,34 +75,16 @@ const getPermissionByName = (name: string): CorePikkuPermission | undefined => {
 }
 
 /**
- * Adds global permissions for a specific tag.
+ * Registers tag-scoped permissions. Applies to any wiring that carries the
+ * matching tag.
  *
- * This function allows you to register permissions that will be applied to
- * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
- *
- * For tree-shaking benefits, wrap in a factory function:
- * `export const x = () => addPermission('tag', [...])`
- *
- * @param {string} tag - The tag that the permissions should apply to.
- * @param {any[]} permissions - The permissions array to apply for the specified tag.
- *
- * @returns {CorePermissionGroup | CorePikkuPermission[]} The permissions (for chaining/wrapping).
+ * For tree-shaking, wrap in a factory:
+ * `export const x = () => addTagPermission('tag', [...])`
  *
  * @example
- * ```typescript
- * // Recommended: tree-shakeable
- * export const adminPermissions = () => addPermission('admin', [
- *   adminPermission,
- *   rolePermission({ role: 'admin' })
- * ])
- *
- * // Also works: no tree-shaking
- * export const apiPermissions = addPermission('api', [
- *   readPermission
- * ])
- * ```
+ * export const adminPermissions = () => addTagPermission('admin', [adminPermission])
  */
-export const addPermission = (
+export const addTagPermission = (
   tag: string,
   permissions: CorePermissionGroup | CorePikkuPermission[],
   packageName: string | null = null
@@ -117,6 +99,32 @@ export const addPermission = (
   return permissions
 }
 
+/**
+ * Registers wire-agnostic global permissions. Runs at the top of every
+ * wiring's permission resolution — before wire-, tag-, and function-level
+ * entries — across all wire types.
+ *
+ * Resolution order: global → wire → tag → function.
+ *
+ * @example
+ * addGlobalPermission([signedInUser])
+ */
+export const addGlobalPermission = (
+  permissions: CorePermissionGroup | CorePikkuPermission[],
+  packageName: string | null = null
+): CorePermissionGroup | CorePikkuPermission[] => {
+  const state = pikkuState(packageName, 'permissions', 'global') as unknown as (
+    | CorePermissionGroup
+    | CorePikkuPermission
+  )[]
+  if (Array.isArray(permissions)) {
+    state.push(...(permissions as CorePikkuPermission[]))
+  } else {
+    state.push(permissions)
+  }
+  return permissions
+}
+
 const combinedPermissionsCache: Record<
   PikkuWiringTypes,
   Record<string, readonly (CorePermissionGroup | CorePikkuPermission)[]>
@@ -189,7 +197,15 @@ const combinePermissions = (
 
   const resolved: (CorePermissionGroup | CorePikkuPermission)[] = []
 
-  // 1. Resolve wire inherited permissions (HTTP + tag groups + individual wire permissions)
+  const globals = pikkuState(
+    packageName,
+    'permissions',
+    'global'
+  ) as unknown as (CorePermissionGroup | CorePikkuPermission)[]
+  if (globals && globals.length > 0) {
+    resolved.push(...globals)
+  }
+
   if (wireInheritedPermissions) {
     for (const meta of wireInheritedPermissions) {
       if (meta.type === 'http') {

package/src/pikku-request.test.ts

@@ -0,0 +1,35 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { PikkuRequest } from './pikku-request.js'
+
+class TestPikkuRequest<In> extends PikkuRequest<In> {}
+
+describe('PikkuRequest', () => {
+  test('returns stored data', async () => {
+    const request = new TestPikkuRequest({ hello: 'world' })
+
+    assert.deepEqual(await request.data(), { hello: 'world' })
+  })
+
+  test('preserves falsey payloads', async () => {
+    await assert.doesNotReject(async () => {
+      const zeroRequest = new TestPikkuRequest(0)
+      assert.equal(await zeroRequest.data(), 0)
+
+      const falseRequest = new TestPikkuRequest(false)
+      assert.equal(await falseRequest.data(), false)
+
+      const emptyStringRequest = new TestPikkuRequest('')
+      assert.equal(await emptyStringRequest.data(), '')
+    })
+  })
+
+  test('throws when data is undefined', async () => {
+    const request = new TestPikkuRequest(undefined as never)
+
+    await assert.rejects(() => request.data(), {
+      message: 'Data not found',
+    })
+  })
+})

package/src/pikku-request.ts

@@ -15,7 +15,7 @@ export abstract class PikkuRequest<In = any> {
    * @returns A promise that resolves to an object containing the combined data.
    */
   public async data(): Promise<In> {
-    if (!this.#data) {
+    if (this.#data === undefined) {
       throw new Error('Data not found')
     }
     return this.#data

package/src/pikku-state.ts

@@ -135,6 +135,7 @@ const createEmptyPackageState = (): PikkuPackageState => ({
   middleware: {
     tagGroup: {},
     httpGroup: {},
+    global: [] as any,
   },
   channelMiddleware: {
     tagGroup: {},
@@ -142,6 +143,7 @@ const createEmptyPackageState = (): PikkuPackageState => ({
   permissions: {
     tagGroup: {},
     httpGroup: {},
+    global: [] as any,
   },
   misc: {
     errors: new Map(),
@@ -150,9 +152,6 @@ const createEmptyPackageState = (): PikkuPackageState => ({
     channelMiddleware: {},
     permissions: {},
   },
-  models: {
-    config: null,
-  },
   package: {
     factories: null,
     singletonServices: null,

package/src/run-tests-script.test.ts

@@ -29,6 +29,24 @@ describe('run-tests.sh discovery behavior', () => {
     fs.rmSync(tempDir, { recursive: true, force: true })
   })
 
+  test('returns success in CI when no tests are found', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pikku-core-tests-'))
+    const srcDir = path.join(tempDir, 'src')
+    fs.mkdirSync(srcDir, { recursive: true })
+    fs.copyFileSync(runTestsScriptPath, path.join(tempDir, 'run-tests.sh'))
+
+    const result = spawnSync('bash', ['run-tests.sh'], {
+      cwd: tempDir,
+      encoding: 'utf8',
+      env: { ...process.env, CI: 'true' },
+    })
+
+    assert.equal(result.status, 0)
+    assert.match(result.stdout, /No test files found matching pattern/)
+
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+
   test('returns failure in strict mode when no tests are found', () => {
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pikku-core-tests-'))
     const srcDir = path.join(tempDir, 'src')

package/src/services/ai-agent-runner-service.ts

@@ -30,6 +30,7 @@ export type AIAgentStepResult = {
   toolResults: { toolCallId: string; toolName: string; result: unknown }[]
   usage: { inputTokens: number; outputTokens: number }
   finishReason: 'stop' | 'tool-calls' | 'length' | 'error' | 'unknown'
+  reasoningContent?: string
 }
 
 export interface AIAgentRunnerService {

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

@@ -24,7 +24,7 @@ export class InMemoryQueueService implements QueueService {
       pikkuUserId: options?.pikkuUserId,
     }
 
-    const delay = options?.delay ?? 0
+    const delay = options?.delay ?? 100 + Math.floor(Math.random() * 201)
 
     setTimeout(async () => {
       try {

package/src/services/in-memory-session-store.ts

@@ -3,8 +3,7 @@ import type { SessionStore } from './session-store.js'
 
 export class InMemorySessionStore<
   UserSession extends CoreUserSession = CoreUserSession,
-> implements SessionStore<UserSession>
-{
+> implements SessionStore<UserSession> {
   private sessions = new Map<string, UserSession>()
 
   async get(pikkuUserId: string): Promise<UserSession | undefined> {