Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

3.9 KB
Raw Blame
import assert from 'node:assert/strict'

function block(type, callId, reads) {
  const value =
    type === 'tool-call'
      ? { type, name: 'Bash', input: { command: `echo ${callId}` } }
      : { type, output: `stdout ${callId}\n${'x'.repeat(1024)}` }
  if (reads) {
    Object.defineProperty(value, 'callId', {
      enumerable: true,
      get() {
        reads.count += 1
        return callId
      }
    })
  } else {
    value.callId = callId
  }
  return Object.freeze(value)
}

export function createFoldWorkloads(count, reads) {
  const call = (id) => block('tool-call', id, reads)
  const result = (id) => block('tool-result', id, reads)
  const named = Array.from({ length: count }, (_, index) => call(`call-${index}`))
  const answers = Array.from({ length: count }, (_, index) => result(`call-${index}`))
  const orphans = Array.from({ length: count }, (_, index) => result(`unknown-${index}`))
  const rows = (entries) =>
    Object.freeze(
      entries.map(([role, blocks], index) =>
        Object.freeze({
          id: `row-${index}`,
          role,
          blocks: Object.freeze(blocks),
          timestamp: index,
          source: 'transcript',
          journalPosition: Object.freeze({ sequence: index + 1, index: 0 })
        })
      )
    )
  return [
    {
      name: 'immediate-pairs',
      messages: rows([
        ['assistant', [{ type: 'text', text: 'Running commands' }]],
        ...named.flatMap((entry, index) => [
          ['tool', [entry]],
          ['tool', [answers[index]]]
        ])
      ])
    },
    {
      name: 'reverse-results',
      messages: rows([
        ['assistant', named],
        ...answers.toReversed().map((entry) => ['tool', [entry]])
      ])
    },
    {
      name: 'silent-call-backlog',
      messages: rows([
        ['assistant', named],
        ...named.flatMap((_, index) => [
          ['tool', [call(`later-${index}`)]],
          ['tool', [result(`later-${index}`)]]
        ])
      ])
    },
    { name: 'named-orphans-batch', messages: rows([['tool', orphans]]) },
    {
      name: 'named-orphans-singletons',
      messages: rows([['assistant', named], ...orphans.map((entry) => ['tool', [entry]])])
    },
    {
      name: 'leading-results-before-calls',
      messages: rows([
        ['user', [{ type: 'text', text: 'Continue' }]],
        ...answers.map((entry) => ['tool', [entry]]),
        ['assistant', named]
      ])
    }
  ]
}

export function summarizeFoldOutput(messages) {
  const blocks = messages.flatMap((message) => message.blocks)
  return {
    rows: messages.length,
    calls: blocks.filter((entry) => entry.type === 'tool-call').length,
    results: blocks.filter((entry) => entry.type === 'tool-result').length,
    standaloneRows: messages.filter((entry) => entry.unpairedToolResults === true).length
  }
}

export function assertFoldConservesEvidence(input, output) {
  const before = input.flatMap((message) => message.blocks)
  const after = output.flatMap((message) => message.blocks)
  for (const type of ['tool-call', 'tool-result']) {
    assert.deepEqual(
      new Set(after.filter((entry) => entry.type === type)),
      new Set(before.filter((entry) => entry.type === type))
    )
  }
  assert.equal(new Set(output.map((message) => message.id)).size, output.length)
}

export function countFoldOperations(run, messages, reads) {
  const known = new Set(messages.flatMap((message) => message.blocks))
  const push = Array.prototype.push
  let pairWrappers = 0
  const startReads = reads.count
  Array.prototype.push = function (...items) {
    for (const item of items) {
      if (
        item !== null &&
        typeof item === 'object' &&
        (('call' in item && known.has(item.call)) || ('result' in item && known.has(item.result)))
      ) {
        pairWrappers += 1
      }
    }
    return push.apply(this, items)
  }
  let output
  try {
    output = run(messages)
  } finally {
    Array.prototype.push = push
  }
  return { pairWrappers, callIdReads: reads.count - startReads, output }
}