@pikku/core 0.12.4 → 0.12.6

package/src/wirings/ai-agent/ai-agent-helpers.test.ts

@@ -0,0 +1,152 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import {
+  agent,
+  agentStream,
+  agentResume,
+  agentApprove,
+} from './ai-agent-helpers.js'
+
+describe('agent helpers', () => {
+  describe('agent', () => {
+    test('should return an object with func', () => {
+      const a = agent('myAgent')
+      assert.strictEqual(typeof a.func, 'function')
+    })
+
+    test('func should call rpc.agent.run', async () => {
+      const a = agent('myAgent')
+      let calledWith: any
+      const rpc = {
+        agent: {
+          run: async (...args: any[]) => {
+            calledWith = args
+            return {
+              runId: 'run-1',
+              result: 'done',
+              usage: { inputTokens: 10, outputTokens: 20 },
+            }
+          },
+        },
+      }
+      const input = { message: 'hello', threadId: 't1', resourceId: 'r1' }
+      const result = await a.func({}, input, { rpc })
+      assert.strictEqual(calledWith[0], 'myAgent')
+      assert.deepStrictEqual(calledWith[1], input)
+      assert.strictEqual(result.runId, 'run-1')
+    })
+  })
+
+  describe('agentStream', () => {
+    test('should return an object with func', () => {
+      const a = agentStream('myAgent')
+      assert.strictEqual(typeof a.func, 'function')
+    })
+
+    test('func should call rpc.agent.stream with bound name', async () => {
+      const a = agentStream('myAgent')
+      let calledWith: any
+      const rpc = {
+        agent: {
+          stream: async (...args: any[]) => {
+            calledWith = args
+          },
+        },
+      }
+      const input = { message: 'hello', threadId: 't1', resourceId: 'r1' }
+      await a.func({}, input, { rpc })
+      assert.strictEqual(calledWith[0], 'myAgent')
+      assert.deepStrictEqual(calledWith[1], input)
+    })
+
+    test('func should extract agentName from data when no name bound', async () => {
+      const a = agentStream()
+      let calledWith: any
+      const rpc = {
+        agent: {
+          stream: async (...args: any[]) => {
+            calledWith = args
+          },
+        },
+      }
+      const input = {
+        agentName: 'dynamicAgent',
+        message: 'hello',
+        threadId: 't1',
+        resourceId: 'r1',
+      }
+      await a.func({}, input, { rpc })
+      assert.strictEqual(calledWith[0], 'dynamicAgent')
+      assert.deepStrictEqual(calledWith[1], {
+        message: 'hello',
+        threadId: 't1',
+        resourceId: 'r1',
+      })
+    })
+
+    test('func should throw when no name bound and no agentName in data', async () => {
+      const a = agentStream()
+      const rpc = { agent: { stream: async () => {} } }
+      await assert.rejects(() => a.func({}, { message: 'hello' }, { rpc }), {
+        message:
+          'agentStream requires an agentName either as a parameter or in the input data',
+      })
+    })
+  })
+
+  describe('agentResume', () => {
+    test('should return an object with func', () => {
+      const a = agentResume()
+      assert.strictEqual(typeof a.func, 'function')
+    })
+
+    test('func should call rpc.agent.resume', async () => {
+      const a = agentResume()
+      let calledWith: any
+      const rpc = {
+        agent: {
+          resume: async (...args: any[]) => {
+            calledWith = args
+          },
+        },
+      }
+      const data = { runId: 'run-1', toolCallId: 'tc1', approved: true }
+      await a.func({}, data, { rpc })
+      assert.strictEqual(calledWith[0], 'run-1')
+      assert.deepStrictEqual(calledWith[1], {
+        toolCallId: 'tc1',
+        approved: true,
+      })
+    })
+  })
+
+  describe('agentApprove', () => {
+    test('should return an object with func', () => {
+      const a = agentApprove('myAgent')
+      assert.strictEqual(typeof a.func, 'function')
+    })
+
+    test('func should call rpc.agent.approve', async () => {
+      const a = agentApprove('myAgent')
+      let calledWith: any
+      const rpc = {
+        agent: {
+          approve: async (...args: any[]) => {
+            calledWith = args
+            return { approved: true }
+          },
+        },
+      }
+      const data = {
+        runId: 'run-1',
+        approvals: [{ toolCallId: 'tc1', approved: true }],
+      }
+      const result = await a.func({}, data, { rpc })
+      assert.strictEqual(calledWith[0], 'run-1')
+      assert.deepStrictEqual(calledWith[1], [
+        { toolCallId: 'tc1', approved: true },
+      ])
+      assert.deepStrictEqual(result, { approved: true })
+    })
+  })
+})

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

@@ -0,0 +1,76 @@
+export function agent<TAgentMap extends Record<string, { output: any }>>(
+  agentName: string & keyof TAgentMap
+): { func: (services: any, data: any, wire: any) => Promise<any> } {
+  return {
+    func: async (_services: any, data: any, { rpc }: any) => {
+      return rpc.agent.run(agentName, data)
+    },
+  }
+}
+
+export function agentStream<TAgentMap extends Record<string, { output: any }>>(
+  agentName?: string & keyof TAgentMap
+): { func: (services: any, data: any, wire: any) => Promise<void> } {
+  return {
+    func: async (_services: any, data: any, { rpc }: any) => {
+      if (agentName) {
+        await rpc.agent.stream(agentName, data)
+      } else {
+        const { agentName: name, ...rest } = data
+        if (!name) {
+          throw new Error(
+            'agentStream requires an agentName either as a parameter or in the input data'
+          )
+        }
+        await rpc.agent.stream(name, rest)
+      }
+    },
+  }
+}
+
+export function agentResume(): {
+  func: (
+    services: any,
+    data: { runId: string; toolCallId: string; approved: boolean },
+    wire: any
+  ) => Promise<void>
+} {
+  return {
+    func: async (
+      _services: any,
+      data: { runId: string; toolCallId: string; approved: boolean },
+      { rpc }: any
+    ) => {
+      await rpc.agent.resume(data.runId, {
+        toolCallId: data.toolCallId,
+        approved: data.approved,
+      })
+    },
+  }
+}
+
+export function agentApprove<TAgentMap extends Record<string, { output: any }>>(
+  _agentName: string & keyof TAgentMap
+): {
+  func: (
+    services: any,
+    data: {
+      runId: string
+      approvals: { toolCallId: string; approved: boolean }[]
+    },
+    wire: any
+  ) => Promise<any>
+} {
+  return {
+    func: async (
+      _services: any,
+      data: {
+        runId: string
+        approvals: { toolCallId: string; approved: boolean }[]
+      },
+      { rpc }: any
+    ) => {
+      return rpc.agent.approve(data.runId, data.approvals)
+    },
+  }
+}

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

@@ -0,0 +1,310 @@
+import { randomUUID } from 'crypto'
+import type { CoreSingletonServices } from '../../types/core.types.js'
+import type {
+  CoreAIAgent,
+  AIAgentMemoryConfig,
+  AIAgentInput,
+  AIMessage,
+} from './ai-agent.types.js'
+import type { AIStorageService } from '../../services/ai-storage-service.js'
+import type { Logger } from '../../services/logger.js'
+import type { SchemaService } from '../../services/schema-service.js'
+
+export function resolveMemoryServices(
+  agent: CoreAIAgent,
+  singletonServices: CoreSingletonServices
+): {
+  storage: AIStorageService | undefined
+} {
+  const memoryConfig = agent.memory
+  const storage = memoryConfig?.storage
+    ? (singletonServices as any)[memoryConfig.storage]
+    : singletonServices.aiStorage
+  return { storage }
+}
+
+export function deepMergeWorkingMemory(
+  existing: Record<string, unknown>,
+  updates: Record<string, unknown>
+): Record<string, unknown> {
+  const result = { ...existing }
+  for (const key of Object.keys(updates)) {
+    const value = updates[key]
+    if (value === null) {
+      delete result[key]
+    } else if (
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      typeof result[key] === 'object' &&
+      result[key] !== null &&
+      !Array.isArray(result[key])
+    ) {
+      result[key] = deepMergeWorkingMemory(
+        result[key] as Record<string, unknown>,
+        value as Record<string, unknown>
+      )
+    } else {
+      result[key] = value
+    }
+  }
+  return result
+}
+
+export function buildWorkingMemoryPrompt(
+  currentState: Record<string, unknown> | null,
+  jsonSchema?: Record<string, unknown>
+): string {
+  const parts: string[] = []
+
+  if (jsonSchema?.properties) {
+    const props = jsonSchema.properties as Record<
+      string,
+      { type?: string; description?: string }
+    >
+    const fieldLines = Object.entries(props).map(([name, def]) => {
+      const type = def.type ?? 'unknown'
+      const desc = def.description ? ` - ${def.description}` : ''
+      return `  - ${name} (${type})${desc}`
+    })
+    if (fieldLines.length > 0) {
+      parts.push(`Working memory fields:\n${fieldLines.join('\n')}`)
+    }
+  }
+
+  if (currentState && Object.keys(currentState).length > 0) {
+    parts.push(`Current working memory:\n${JSON.stringify(currentState)}`)
+  } else {
+    parts.push('Current working memory: (empty)')
+  }
+
+  parts.push(
+    'When you learn new information, output a partial JSON update in <working_memory> tags. ' +
+      'Only include changed fields. Set a field to null to delete it.'
+  )
+
+  return parts.join('\n\n')
+}
+
+export async function loadContextMessages(
+  memoryConfig: AIAgentMemoryConfig | undefined,
+  storage: AIStorageService | undefined,
+  input: AIAgentInput,
+  workingMemoryJsonSchema?: Record<string, unknown>
+): Promise<AIMessage[]> {
+  const contextMessages: AIMessage[] = []
+
+  if (memoryConfig?.workingMemory && storage) {
+    const workingMem = await storage.getWorkingMemory(input.threadId, 'thread')
+    const prompt = buildWorkingMemoryPrompt(workingMem, workingMemoryJsonSchema)
+    contextMessages.push({
+      id: `wm-${randomUUID()}`,
+      role: 'system',
+      content: prompt,
+      createdAt: new Date(),
+    })
+  }
+
+  return contextMessages
+}
+
+export async function saveMessages(
+  storage: AIStorageService | undefined,
+  threadId: string,
+  resourceId: string,
+  memoryConfig: AIAgentMemoryConfig | undefined,
+  userMessage: AIMessage | null | undefined,
+  result: {
+    text: string
+    steps: {
+      toolCalls?: {
+        name: string
+        args: Record<string, unknown>
+        result: string
+      }[]
+    }[]
+  },
+  options?: {
+    workingMemoryJsonSchema?: Record<string, unknown>
+    workingMemorySchemaName?: string | null
+    logger?: Logger
+    schemaService?: SchemaService
+  }
+): Promise<string> {
+  let responseText = result.text
+
+  if (storage) {
+    const newMessages: AIMessage[] = userMessage ? [userMessage] : []
+
+    for (const step of result.steps) {
+      if (step.toolCalls?.length) {
+        const toolCallIds = step.toolCalls.map(() => randomUUID())
+        newMessages.push({
+          id: randomUUID(),
+          role: 'assistant',
+          toolCalls: step.toolCalls.map((tc, i) => ({
+            id: toolCallIds[i],
+            name: tc.name,
+            args: tc.args,
+          })),
+          createdAt: new Date(),
+        })
+        newMessages.push({
+          id: randomUUID(),
+          role: 'tool',
+          toolResults: step.toolCalls.map((tc, i) => ({
+            id: toolCallIds[i],
+            name: tc.name,
+            result: tc.result,
+          })),
+          createdAt: new Date(),
+        })
+      }
+    }
+
+    newMessages.push({
+      id: randomUUID(),
+      role: 'assistant',
+      content: responseText,
+      createdAt: new Date(),
+    })
+
+    await storage.saveMessages(threadId, newMessages)
+
+    if (memoryConfig?.workingMemory) {
+      const parsed = parseWorkingMemory(responseText)
+      if (parsed) {
+        const existing =
+          (await storage.getWorkingMemory(threadId, 'thread')) ?? {}
+        const merged = deepMergeWorkingMemory(existing, parsed)
+
+        if (options?.schemaService && options?.workingMemorySchemaName) {
+          try {
+            await options.schemaService.validateSchema(
+              options.workingMemorySchemaName,
+              merged
+            )
+          } catch (err) {
+            options.logger?.warn(
+              `Working memory validation failed: ${err instanceof Error ? err.message : String(err)}`
+            )
+          }
+        }
+
+        await storage.saveWorkingMemory(threadId, 'thread', merged)
+        responseText = stripWorkingMemoryTags(responseText)
+      }
+    }
+  }
+
+  return responseText
+}
+
+export function trimMessages(
+  messages: AIMessage[],
+  maxTokenBudget: number = 100000
+): AIMessage[] {
+  const sanitized = sanitizeToolMessages(messages)
+
+  let estimatedTokens = 0
+  const result: AIMessage[] = []
+
+  for (let i = sanitized.length - 1; i >= 0; i--) {
+    const msg = sanitized[i]
+    const msgTokens = estimateTokens(msg)
+    if (estimatedTokens + msgTokens > maxTokenBudget && result.length > 0) {
+      break
+    }
+    estimatedTokens += msgTokens
+    result.unshift(msg)
+  }
+
+  if (
+    result.length > 0 &&
+    result[0].role !== 'user' &&
+    result[0].role !== 'system'
+  ) {
+    const firstUserIdx = result.findIndex(
+      (m) => m.role === 'user' || m.role === 'system'
+    )
+    if (firstUserIdx > 0) {
+      return result.slice(firstUserIdx)
+    }
+  }
+
+  return result
+}
+
+function sanitizeToolMessages(messages: AIMessage[]): AIMessage[] {
+  const result: AIMessage[] = []
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i]
+
+    if (msg.role === 'assistant' && msg.toolCalls?.length) {
+      const next = messages[i + 1]
+      if (!next || next.role !== 'tool' || !next.toolResults?.length) {
+        if (msg.content) {
+          result.push({ ...msg, toolCalls: undefined })
+        }
+        continue
+      }
+
+      const toolCallIds = new Set(msg.toolCalls.map((tc) => tc.id))
+      const resultIds = new Set(next.toolResults.map((tr) => tr.id))
+      const allMatched = [...toolCallIds].every((id) => resultIds.has(id))
+
+      if (!allMatched) {
+        if (msg.content) {
+          result.push({ ...msg, toolCalls: undefined })
+        }
+        result.push({
+          ...next,
+          toolResults:
+            next.toolResults.filter((tr) => !toolCallIds.has(tr.id)) ||
+            undefined,
+        })
+        i++
+        continue
+      }
+    }
+
+    result.push(msg)
+  }
+
+  return result.filter(
+    (m) => m.role !== 'tool' || (m.toolResults && m.toolResults.length > 0)
+  )
+}
+
+function estimateTokens(msg: AIMessage): number {
+  let chars = 0
+  if (msg.content) {
+    if (typeof msg.content === 'string') {
+      chars += msg.content.length
+    } else {
+      for (const part of msg.content) {
+        if (part.type === 'text') chars += part.text.length
+        else chars += 1000
+      }
+    }
+  }
+  if (msg.toolCalls) chars += JSON.stringify(msg.toolCalls).length
+  if (msg.toolResults) chars += JSON.stringify(msg.toolResults).length
+  return Math.ceil(chars / 4)
+}
+
+export function parseWorkingMemory(
+  text: string
+): Record<string, unknown> | null {
+  const match = text.match(/<working_memory>([\s\S]*?)<\/working_memory>/)
+  if (!match) return null
+  try {
+    return JSON.parse(match[1].trim())
+  } catch {
+    return null
+  }
+}
+
+export function stripWorkingMemoryTags(text: string): string {
+  return text.replace(/<working_memory>[\s\S]*?<\/working_memory>/g, '').trim()
+}

package/src/wirings/ai-agent/ai-agent-model-config.test.ts

@@ -0,0 +1,115 @@
+import { describe, test, beforeEach } from 'node:test'
+import assert from 'node:assert'
+import { resolveModelConfig } from './ai-agent-model-config.js'
+import { resetPikkuState, pikkuState } from '../../pikku-state.js'
+
+beforeEach(() => {
+  resetPikkuState()
+})
+
+describe('resolveModelConfig', () => {
+  test('should return agent model when no config', () => {
+    const result = resolveModelConfig('testAgent', {
+      model: 'anthropic/claude-3',
+      temperature: 0.7,
+    })
+    assert.strictEqual(result.model, 'anthropic/claude-3')
+    assert.strictEqual(result.temperature, 0.7)
+  })
+
+  test('should resolve model alias to string', () => {
+    pikkuState(null, 'models', 'config', {
+      models: { fast: 'anthropic/claude-haiku' },
+    } as any)
+
+    const result = resolveModelConfig('testAgent', { model: 'fast' })
+    assert.strictEqual(result.model, 'anthropic/claude-haiku')
+  })
+
+  test('should resolve model alias with temperature and maxSteps', () => {
+    pikkuState(null, 'models', 'config', {
+      models: {
+        smart: {
+          model: 'anthropic/claude-opus',
+          temperature: 0.3,
+          maxSteps: 10,
+        },
+      },
+    } as any)
+
+    const result = resolveModelConfig('testAgent', { model: 'smart' })
+    assert.strictEqual(result.model, 'anthropic/claude-opus')
+    assert.strictEqual(result.temperature, 0.3)
+    assert.strictEqual(result.maxSteps, 10)
+  })
+
+  test('should throw for unknown model alias', () => {
+    pikkuState(null, 'models', 'config', {
+      models: {},
+    } as any)
+
+    assert.throws(() => resolveModelConfig('testAgent', { model: 'unknown' }), {
+      message: "Unknown model alias 'unknown'.",
+    })
+  })
+
+  test('should pass through model with slash (not an alias)', () => {
+    pikkuState(null, 'models', 'config', {
+      models: {},
+    } as any)
+
+    const result = resolveModelConfig('testAgent', { model: 'openai/gpt-4' })
+    assert.strictEqual(result.model, 'openai/gpt-4')
+  })
+
+  test('should use agent override model', () => {
+    pikkuState(null, 'models', 'config', {
+      models: { fast: 'anthropic/haiku' },
+      agentOverrides: { testAgent: { model: 'fast' } },
+    } as any)
+
+    const result = resolveModelConfig('testAgent', {
+      model: 'anthropic/default',
+    })
+    assert.strictEqual(result.model, 'anthropic/haiku')
+  })
+
+  test('should use agent override temperature over alias', () => {
+    pikkuState(null, 'models', 'config', {
+      models: { smart: { model: 'anthropic/opus', temperature: 0.5 } },
+      agentOverrides: { testAgent: { model: 'smart', temperature: 0.1 } },
+    } as any)
+
+    const result = resolveModelConfig('testAgent', {
+      model: 'anthropic/default',
+    })
+    assert.strictEqual(result.temperature, 0.1)
+  })
+
+  test('should use agentDefaults as fallback', () => {
+    pikkuState(null, 'models', 'config', {
+      models: {},
+      agentDefaults: { temperature: 0.5, maxSteps: 20 },
+    } as any)
+
+    const result = resolveModelConfig('testAgent', {
+      model: 'anthropic/claude-3',
+    })
+    assert.strictEqual(result.temperature, 0.5)
+    assert.strictEqual(result.maxSteps, 20)
+  })
+
+  test('should prioritize: override > alias > defaults > agent', () => {
+    pikkuState(null, 'models', 'config', {
+      models: { fast: { model: 'anthropic/haiku', temperature: 0.3 } },
+      agentDefaults: { temperature: 0.5 },
+      agentOverrides: { testAgent: { temperature: 0.1 } },
+    } as any)
+
+    const result = resolveModelConfig('testAgent', {
+      model: 'fast',
+      temperature: 0.9,
+    })
+    assert.strictEqual(result.temperature, 0.1)
+  })
+})

package/src/wirings/ai-agent/ai-agent-model-config.ts

@@ -0,0 +1,43 @@
+import { pikkuState } from '../../pikku-state.js'
+
+export function resolveModelConfig(
+  agentName: string,
+  agent: { model: string; temperature?: number; maxSteps?: number }
+): { model: string; temperature?: number; maxSteps?: number } {
+  let config: any = {}
+  try {
+    config = pikkuState(null, 'models', 'config') ?? {}
+  } catch {}
+  const models = config.models ?? {}
+  const defaults = config.agentDefaults
+  const agentOverride = config.agentOverrides?.[agentName]
+
+  let rawModel = agentOverride?.model ?? agent.model
+
+  let aliasTemperature: number | undefined
+  let aliasMaxSteps: number | undefined
+  if (!rawModel.includes('/')) {
+    const entry = models[rawModel]
+    if (!entry) throw new Error(`Unknown model alias '${rawModel}'.`)
+    if (typeof entry === 'string') {
+      rawModel = entry
+    } else {
+      rawModel = entry.model
+      aliasTemperature = entry.temperature
+      aliasMaxSteps = entry.maxSteps
+    }
+  }
+
+  const temperature =
+    agentOverride?.temperature ??
+    aliasTemperature ??
+    defaults?.temperature ??
+    agent.temperature
+  const maxSteps =
+    agentOverride?.maxSteps ??
+    aliasMaxSteps ??
+    defaults?.maxSteps ??
+    agent.maxSteps
+
+  return { model: rawModel, temperature, maxSteps }
+}