@pikku/core 0.12.107 → 0.12.111

package/src/wirings/agent/agent-agui.ts

@@ -1,405 +0,0 @@
-import type { AgentStreamChannel, AgentStreamEvent } from './agent.types.js'
-import { randomUUID } from './agent-utils.js'
-
-type AGUIEvent =
-  | { type: 'TEXT_MESSAGE_START'; messageId: string }
-  | { type: 'TEXT_MESSAGE_CONTENT'; messageId: string; delta: string }
-  | { type: 'TEXT_MESSAGE_END'; messageId: string }
-  | { type: 'TOOL_CALL_START'; toolCallId: string; toolCallName: string }
-  | { type: 'TOOL_CALL_ARGS'; toolCallId: string; delta: string }
-  | { type: 'TOOL_CALL_END'; toolCallId: string; toolCallName: string }
-  | {
-      type: 'TOOL_CALL_RESULT'
-      messageId: string
-      toolCallId: string
-      role: 'tool'
-      content: string
-    }
-  | { type: 'THINKING_START' }
-  | { type: 'THINKING_TEXT_MESSAGE_START'; messageId: string }
-  | { type: 'THINKING_TEXT_MESSAGE_CONTENT'; messageId: string; delta: string }
-  | { type: 'THINKING_TEXT_MESSAGE_END'; messageId: string }
-  | { type: 'THINKING_END' }
-  | { type: 'RUN_STARTED'; threadId: string; runId: string }
-  | {
-      type: 'RUN_FINISHED'
-      threadId: string
-      runId: string
-      model?: string
-      usage?: {
-        promptTokens: number
-        completionTokens: number
-        totalTokens: number
-      }
-    }
-  | { type: 'RUN_ERROR'; message: string; code?: string }
-  | { type: 'STEP_STARTED'; stepName: string }
-  | { type: 'STEP_FINISHED'; stepName: string }
-  | { type: 'CUSTOM'; name: string; value: unknown }
-
-export type { AGUIEvent }
-
-export type AGUIChannelOptions = {
-  threadId?: string
-  runId?: string
-  getRunId?: () => string | undefined
-}
-
-function resultToString(result: unknown): string {
-  if (typeof result === 'string') return result
-  try {
-    return JSON.stringify(result, (_key, val) =>
-      typeof val === 'bigint' ? val.toString() : val
-    )
-  } catch {
-    return String(result)
-  }
-}
-
-export function wrapChannelWithAGUI(
-  inner: AgentStreamChannel,
-  options?: AGUIChannelOptions
-): AgentStreamChannel {
-  const threadId = options?.threadId ?? randomUUID()
-  let runId: string | null = options?.runId ?? null
-
-  function resolveRunId(): string {
-    if (!runId) {
-      runId = options?.getRunId?.() ?? randomUUID()
-    }
-    return runId
-  }
-
-  let textMessageId: string | null = null
-  let thinkingMessageId: string | null = null
-  let openStepName: string | null = null
-  let stepSeq = 0
-  let runStartedSent = false
-  let terminal = false
-  let sawUsage = false
-  let usageModel: string | undefined
-  const usageTotals = { input: 0, output: 0 }
-
-  function send(event: AGUIEvent): void {
-    if (!runStartedSent) {
-      runStartedSent = true
-      inner.send({
-        type: 'RUN_STARTED',
-        threadId,
-        runId: resolveRunId(),
-      } as unknown as AgentStreamEvent)
-    }
-    inner.send(event as unknown as AgentStreamEvent)
-  }
-
-  function endTextMessage(): void {
-    if (textMessageId) {
-      send({ type: 'TEXT_MESSAGE_END', messageId: textMessageId })
-      textMessageId = null
-    }
-  }
-
-  function endThinkingMessage(): void {
-    if (thinkingMessageId) {
-      send({ type: 'THINKING_TEXT_MESSAGE_END', messageId: thinkingMessageId })
-      send({ type: 'THINKING_END' })
-      thinkingMessageId = null
-    }
-  }
-
-  function endStep(): void {
-    if (openStepName) {
-      send({ type: 'STEP_FINISHED', stepName: openStepName })
-      openStepName = null
-    }
-  }
-
-  function ensureTextMessage(): string {
-    if (!textMessageId) {
-      textMessageId = randomUUID()
-      send({ type: 'TEXT_MESSAGE_START', messageId: textMessageId })
-    }
-    return textMessageId
-  }
-
-  function ensureThinkingMessage(): string {
-    if (!thinkingMessageId) {
-      thinkingMessageId = randomUUID()
-      send({ type: 'THINKING_START' })
-      send({
-        type: 'THINKING_TEXT_MESSAGE_START',
-        messageId: thinkingMessageId,
-      })
-    }
-    return thinkingMessageId
-  }
-
-  function finishRun(): void {
-    endTextMessage()
-    endThinkingMessage()
-    endStep()
-    send({
-      type: 'RUN_FINISHED',
-      threadId,
-      runId: resolveRunId(),
-      ...(usageModel ? { model: usageModel } : {}),
-      ...(sawUsage
-        ? {
-            usage: {
-              promptTokens: usageTotals.input,
-              completionTokens: usageTotals.output,
-              totalTokens: usageTotals.input + usageTotals.output,
-            },
-          }
-        : {}),
-    })
-    terminal = true
-  }
-
-  return {
-    channelId: inner.channelId,
-    openingData: inner.openingData,
-    get state() {
-      return inner.state
-    },
-    setState: (s) => inner.setState(s),
-    getState: () => inner.getState(),
-    clearState: () => inner.clearState(),
-    // Delegated: the wrapper is a view over the same connection, so a peer
-    // reachable from the channel underneath is reachable from here too.
-    remote: (funcName: string, data?: unknown) => inner.remote(funcName, data),
-    sendBinary: (data) => inner.sendBinary(data),
-    close: () => inner.close(),
-
-    send: (event: AgentStreamEvent) => {
-      if (terminal) return
-
-      switch (event.type) {
-        case 'text-delta': {
-          endThinkingMessage()
-          const id = ensureTextMessage()
-          send({
-            type: 'TEXT_MESSAGE_CONTENT',
-            messageId: id,
-            delta: event.text,
-          })
-          break
-        }
-
-        case 'reasoning-delta': {
-          endTextMessage()
-          const id = ensureThinkingMessage()
-          send({
-            type: 'THINKING_TEXT_MESSAGE_CONTENT',
-            messageId: id,
-            delta: event.text,
-          })
-          break
-        }
-
-        case 'tool-call': {
-          endTextMessage()
-          endThinkingMessage()
-          send({
-            type: 'TOOL_CALL_START',
-            toolCallId: event.toolCallId,
-            toolCallName: event.toolName,
-          })
-          send({
-            type: 'TOOL_CALL_ARGS',
-            toolCallId: event.toolCallId,
-            delta: resultToString(event.args) || '{}',
-          })
-          send({
-            type: 'TOOL_CALL_END',
-            toolCallId: event.toolCallId,
-            toolCallName: event.toolName,
-          })
-          break
-        }
-
-        case 'tool-result': {
-          send({
-            type: 'TOOL_CALL_RESULT',
-            messageId: randomUUID(),
-            toolCallId: event.toolCallId,
-            role: 'tool',
-            content: resultToString(event.result),
-          })
-          break
-        }
-
-        case 'usage': {
-          endTextMessage()
-          endThinkingMessage()
-          sawUsage = true
-          usageTotals.input += event.tokens.input
-          usageTotals.output += event.tokens.output
-          if (event.model) usageModel = event.model
-          break
-        }
-
-        case 'error': {
-          endTextMessage()
-          endThinkingMessage()
-          endStep()
-          send({ type: 'RUN_ERROR', message: event.message })
-          terminal = true
-          break
-        }
-
-        case 'done': {
-          finishRun()
-          break
-        }
-
-        case 'step-start': {
-          endTextMessage()
-          endThinkingMessage()
-          endStep()
-          stepSeq += 1
-          openStepName = `${event.agent ?? 'step'}#${stepSeq}`
-          send({ type: 'STEP_STARTED', stepName: openStepName })
-          break
-        }
-
-        case 'approval-request': {
-          endTextMessage()
-          endThinkingMessage()
-          send({
-            type: 'CUSTOM',
-            name: 'pikku:approval-request',
-            value: {
-              toolCallId: event.toolCallId,
-              toolName: event.toolName,
-              args: event.args,
-              reason: event.reason,
-              runId: event.runId,
-              agent: event.agent,
-              session: event.session,
-            },
-          })
-          break
-        }
-
-        case 'credential-request': {
-          endTextMessage()
-          endThinkingMessage()
-          send({
-            type: 'CUSTOM',
-            name: 'pikku:credential-request',
-            value: {
-              toolCallId: event.toolCallId,
-              toolName: event.toolName,
-              args: event.args,
-              credentialName: event.credentialName,
-              credentialType: event.credentialType,
-              connectUrl: event.connectUrl,
-              runId: event.runId,
-              agent: event.agent,
-              session: event.session,
-            },
-          })
-          break
-        }
-
-        case 'generative-ui': {
-          send({
-            type: 'CUSTOM',
-            name: 'pikku:generative-ui',
-            value: { spec: event.spec },
-          })
-          break
-        }
-
-        case 'data': {
-          send({
-            type: 'CUSTOM',
-            name: 'pikku:data',
-            value: { name: event.name, data: event.data },
-          })
-          break
-        }
-
-        case 'agent-call': {
-          send({
-            type: 'CUSTOM',
-            name: 'pikku:agent-call',
-            value: {
-              agentName: event.agentName,
-              session: event.session,
-              input: event.input,
-            },
-          })
-          break
-        }
-
-        case 'agent-result': {
-          send({
-            type: 'CUSTOM',
-            name: 'pikku:agent-result',
-            value: {
-              agentName: event.agentName,
-              session: event.session,
-              result: event.result,
-            },
-          })
-          break
-        }
-
-        case 'suspended': {
-          send({
-            type: 'CUSTOM',
-            name: 'pikku:suspended',
-            value: { reason: event.reason, missingRpcs: event.missingRpcs },
-          })
-          break
-        }
-
-        case 'interrupted': {
-          endTextMessage()
-          endThinkingMessage()
-          endStep()
-          send({
-            type: 'CUSTOM',
-            name: 'pikku:interrupted',
-            value: {
-              runId: event.runId,
-              text: event.text,
-              reason: event.reason,
-            },
-          })
-          break
-        }
-
-        // knowledge: decisions/internals/agent-speech-travels-as-a-custom-agui-event.md
-        case 'audio-delta': {
-          send({
-            type: 'CUSTOM',
-            name: 'pikku:audio-delta',
-            value: {
-              data: event.data,
-              format: event.format,
-              ...(event.text === undefined ? {} : { text: event.text }),
-            },
-          })
-          break
-        }
-
-        case 'audio-done': {
-          send({ type: 'CUSTOM', name: 'pikku:audio-done', value: {} })
-          break
-        }
-
-        case 'transcript': {
-          send({
-            type: 'CUSTOM',
-            name: 'pikku:transcript',
-            value: { text: event.text },
-          })
-          break
-        }
-      }
-    },
-  }
-}

package/src/wirings/agent/agent-authorization.test.ts

@@ -1,208 +0,0 @@
-import { beforeEach, describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  resetPikkuState,
-  pikkuState,
-  setSingletonServices,
-} from '../../pikku-state.js'
-import { assertAgentAuthorized } from './agent-prepare.js'
-import { clearPermissionsCache } from '../../permissions.js'
-import {
-  ForbiddenError,
-  MissingScopeError,
-  MissingSessionError,
-} from '../../errors/errors.js'
-import type { CoreAgent } from './agent.types.js'
-import type { CoreUserSession } from '../../types/core.types.js'
-
-const logger = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-} as any
-
-beforeEach(() => {
-  resetPikkuState()
-  clearPermissionsCache()
-  setSingletonServices({ logger } as any)
-})
-
-const addAgent = (
-  agentName: string,
-  overrides: Partial<CoreAgent> = {}
-): CoreAgent => {
-  const agent: CoreAgent = {
-    name: agentName,
-    description: `${agentName} description`,
-    goal: `${agentName} goal`,
-    instructions: `${agentName} instructions`,
-    model: 'test/test-model',
-    ...overrides,
-  } as CoreAgent
-
-  pikkuState(null, 'agent', 'agents').set(agentName, agent)
-  return agent
-}
-
-const sessionService = (session: CoreUserSession | undefined) =>
-  ({
-    get: () => session,
-    setInitial: () => {},
-    sessionChanged: false,
-  }) as any
-
-describe('assertAgentAuthorized', () => {
-  test('resolves when the agent declares no authorization and a session exists', async () => {
-    const agent = addAgent('open')
-    await assertAgentAuthorized(
-      agent,
-      { sessionService: sessionService({ userId: 'u1' }) },
-      null
-    )
-  })
-
-  test('does not require a session unless auth is explicitly true', async () => {
-    const agent = addAgent('sessionless')
-    await assertAgentAuthorized(
-      agent,
-      { sessionService: sessionService(undefined) },
-      null
-    )
-  })
-
-  test('resolves with no sessionService at all (cron / queue invocation)', async () => {
-    const agent = addAgent('no-session-service')
-    await assertAgentAuthorized(agent, {}, null)
-  })
-
-  test('throws MissingSessionError when auth is explicitly true and no session exists', async () => {
-    const agent = addAgent('needs-session', { auth: true })
-    await assert.rejects(
-      () =>
-        assertAgentAuthorized(
-          agent,
-          { sessionService: sessionService(undefined) },
-          null
-        ),
-      MissingSessionError
-    )
-  })
-
-  test('enforces scopes even when auth is not required', async () => {
-    const agent = addAgent('scoped-sessionless', { scopes: ['reports:read'] })
-    await assert.rejects(
-      () => assertAgentAuthorized(agent, {}, null),
-      MissingScopeError
-    )
-  })
-
-  test('throws ForbiddenError when the permission group denies', async () => {
-    const agent = addAgent('guarded', {
-      permissions: { admin: async () => false },
-    })
-    await assert.rejects(
-      () =>
-        assertAgentAuthorized(
-          agent,
-          { sessionService: sessionService({ userId: 'u1' }) },
-          null
-        ),
-      ForbiddenError
-    )
-  })
-
-  test('resolves when at least one permission branch passes', async () => {
-    const agent = addAgent('or-group', {
-      permissions: {
-        admin: async () => false,
-        owner: async () => true,
-      },
-    })
-    await assertAgentAuthorized(
-      agent,
-      { sessionService: sessionService({ userId: 'u1' }) },
-      null
-    )
-  })
-
-  test('passes the session through to permission functions', async () => {
-    let seen: CoreUserSession | undefined
-    const agent = addAgent('sees-session', {
-      permissions: {
-        admin: async (_services: any, _data: any, wire: any) => {
-          seen = wire.session
-          return true
-        },
-      },
-    })
-    await assertAgentAuthorized(
-      agent,
-      { sessionService: sessionService({ userId: 'u1' }) },
-      null
-    )
-    assert.equal(seen?.userId, 'u1')
-  })
-
-  test('throws MissingScopeError when a required scope is not held', async () => {
-    const agent = addAgent('scoped', { scopes: ['reports:read'] })
-    await assert.rejects(
-      () =>
-        assertAgentAuthorized(
-          agent,
-          { sessionService: sessionService({ userId: 'u1', scopes: [] }) },
-          null
-        ),
-      MissingScopeError
-    )
-  })
-
-  test('resolves when the session holds the required scope', async () => {
-    const agent = addAgent('scoped-ok', { scopes: ['reports:read'] })
-    await assertAgentAuthorized(
-      agent,
-      {
-        sessionService: sessionService({
-          userId: 'u1',
-          scopes: ['reports:read'],
-        }),
-      },
-      null
-    )
-  })
-
-  test('resolves when an ancestor scope grant covers the requirement', async () => {
-    const agent = addAgent('scoped-parent', { scopes: ['reports:read'] })
-    await assertAgentAuthorized(
-      agent,
-      {
-        sessionService: sessionService({ userId: 'u1', scopes: ['reports'] }),
-      },
-      null
-    )
-  })
-
-  test('checks scopes before permissions', async () => {
-    let permissionRan = false
-    const agent = addAgent('scope-first', {
-      scopes: ['reports:read'],
-      permissions: {
-        admin: async () => {
-          permissionRan = true
-          return true
-        },
-      },
-    })
-    await assert.rejects(
-      () =>
-        assertAgentAuthorized(
-          agent,
-          { sessionService: sessionService({ userId: 'u1', scopes: [] }) },
-          null
-        ),
-      MissingScopeError
-    )
-    assert.equal(permissionRan, false)
-  })
-})