@jigging/agent-method 0.0.0 → 0.1.0-alpha.3

package/test/conversation.test.ts

@@ -0,0 +1,305 @@
+import { expect, test } from 'bun:test'
+
+/** Synthetic Agent host, real public SDK subprocess. No native-client qualification. */
+async function exercise(mode: string) {
+  const process = Bun.spawn([Bun.which('bun')!, `${import.meta.dir}/conversation-fixture.ts`], {
+    stdin: 'pipe',
+    stdout: 'pipe',
+    stderr: 'pipe',
+  })
+  const errors = new Response(process.stderr).text()
+  const timer = setTimeout(() => process.kill(), 5_000)
+  const send = (frame: unknown) => {
+    process.stdin.write(JSON.stringify(frame) + '\n')
+    process.stdin.flush()
+  }
+  const ok = (request: any, result: unknown) => send({ jsonrpc: '2.0', id: request.id, result })
+  const fail = (request: any, code: string) =>
+    send({ jsonrpc: '2.0', id: request.id, error: { code: -32000, message: code, data: { code } } })
+  const queues: any[] = []
+  let read: any
+  let eventRead: any
+  const eventQueue = [
+    { item: { sequence: 1, value: { sessionUpdate: 'plan', entries: [], turn: 0 } } },
+    {
+      item: {
+        sequence: 2,
+        value: {
+          sessionUpdate: 'agent_message_chunk',
+          content: { type: 'text', text: 'visible draft' },
+          turn: 0,
+        },
+      },
+    },
+  ]
+  let call: any
+  let sequence = 0
+  let creates = 0
+  let closed = false
+  let final: any
+  let nativeSettled = false
+  const operations: any[] = []
+  const item = (value: unknown) => {
+    queues.push({ item: { sequence: ++sequence, value } })
+    if (read) {
+      ok(read, queues.shift())
+      read = undefined
+    }
+  }
+  const terminal = (turn: number, type = 'result') =>
+    item(
+      type === 'result'
+        ? { type, turn, result: { outcome: 'done', output: { text: `answer ${turn}` } } }
+        : { type, turn },
+    )
+  send({
+    jsonrpc: '2.0',
+    id: 'root',
+    method: 'flow/run',
+    params: {
+      protocol: 'run/0',
+      input: mode,
+      settings: {},
+      attachments: {},
+      scratch: '/tmp/unused',
+      deadlineUnixMs: Date.now() + 4_000,
+    },
+  })
+  try {
+    let buffer = ''
+    const decoder = new TextDecoder()
+    for await (const bytes of process.stdout) {
+      buffer += decoder.decode(bytes, { stream: true })
+      while (buffer.includes('\n')) {
+        const split = buffer.indexOf('\n')
+        const request = JSON.parse(buffer.slice(0, split))
+        buffer = buffer.slice(split + 1)
+        operations.push(request)
+        if (request.id === 'root') {
+          final = request
+          continue
+        }
+        const p = request.params
+        if (request.method === 'channel/create') {
+          creates++
+          if (mode === 'partial-allocation' && creates === 2) {
+            fail(request, 'RESOURCE_EXHAUSTED')
+            continue
+          }
+          const prefix = creates === 1 ? 'commands' : creates === 2 ? 'replies' : 'events'
+          expect(p.contract).toEqual({ slot: 'agent', channel: prefix })
+          ok(request, {
+            send: { endpoint: `${prefix}:s`, direction: 'send', delivery: 'direct' },
+            receive: {
+              endpoint: `${prefix}:r`,
+              direction: 'receive',
+              delivery: 'direct',
+              startSequence: 1,
+            },
+          })
+        } else if (request.method === 'flow/call') {
+          call = request
+          expect(p.channels).toEqual({
+            commands: 'commands:r',
+            replies: 'replies:s',
+            ...(mode.startsWith('observer') ? { events: 'events:s' } : {}),
+          })
+          expect(p.input.session).toEqual(
+            ['retained', 'missing-session', 'invalid-session'].includes(mode)
+              ? { retain: true }
+              : undefined,
+          )
+          if (mode === 'unavailable' || mode === 'observer-unavailable') {
+            nativeSettled = true
+            fail(call, 'UNAVAILABLE')
+          } else if (mode === 'root-cancel' || mode === 'observer-root-cancel') {
+            send({ jsonrpc: '2.0', method: 'request/cancel', params: { requestId: 'root' } })
+          } else if (mode === 'abandoned') {
+            // No result: callback returns while a real invocation remains live.
+          } else if (mode === 'malformed')
+            item({ type: 'result', turn: 7, result: { outcome: 'done', output: null } })
+          else terminal(0)
+        } else if (request.method === 'channel/next') {
+          if (p.endpoint === 'events:r') {
+            if (mode === 'observer-lagged') fail(request, 'LAGGED')
+            else if (mode === 'observer-disposal') fail(request, 'CANCELLED')
+            else if (eventQueue.length) ok(request, eventQueue.shift())
+            else if (nativeSettled) ok(request, { end: { lastSequence: 2 } })
+            else eventRead = request
+            continue
+          }
+          read = request
+          if (queues.length) {
+            ok(read, queues.shift())
+            read = undefined
+          }
+        } else if (request.method === 'channel/send') {
+          ok(request, null)
+          const command = p.value
+          item({ type: 'accepted', command: command.type, turn: command.turn })
+          if (command.type === 'prompt') {
+            if (mode === 'late-error') {
+              nativeSettled = true
+              fail(call, 'EXECUTION_FAILED')
+            } else if (!['interrupt', 'completion-race'].includes(mode)) terminal(command.turn)
+          } else if (command.type === 'interrupt')
+            terminal(command.turn, mode === 'interrupt' ? 'cancelled' : 'result')
+        } else if (request.method === 'channel/close') {
+          expect(p.endpoint).toBe('commands:s')
+          closed = true
+          ok(request, null)
+          if (call && !nativeSettled) {
+            nativeSettled = true
+            if (eventRead) {
+              ok(eventRead, { end: { lastSequence: 2 } })
+              eventRead = undefined
+            }
+            if (p.error) fail(call, 'EXECUTION_FAILED')
+            else
+              ok(call, {
+                outcome: 'done',
+                output: {
+                  turns: mode === 'callback-error' ? 1 : 2,
+                  ...(['retained', 'invalid-session', 'unsolicited-session'].includes(mode)
+                    ? {
+                        session: {
+                          status: 'retained',
+                          reference:
+                            mode === 'invalid-session'
+                              ? 'x'.repeat(36)
+                              : '013579ab-cdef-4567-89ab-0123456789ab',
+                        },
+                      }
+                    : {}),
+                },
+              })
+          }
+        } else if (request.method === 'channel/release') {
+          if (p.endpoint === 'events:r') {
+            ok(
+              request,
+              mode === 'observer-disposal'
+                ? { status: 'failed', code: 'LAGGED' }
+                : { status: 'released' },
+            )
+            continue
+          }
+          expect(['replies:r', ...(mode === 'partial-allocation' ? ['commands:r'] : [])]).toContain(
+            p.endpoint,
+          )
+          if (call) expect(nativeSettled).toBe(true)
+          if (mode === 'disposal-error') ok(request, { status: 'failed', code: 'LAGGED' })
+          else ok(request, { status: 'released' })
+        } else if (request.method === 'request/cancel') {
+          if (eventRead && eventRead.id === p.requestId) {
+            fail(eventRead, 'CANCELLED')
+            eventRead = undefined
+          } else if (read && read.id === p.requestId) {
+            fail(read, 'CANCELLED')
+            read = undefined
+          } else if (
+            (mode === 'root-cancel' || mode === 'observer-root-cancel') &&
+            call &&
+            call.id === p.requestId
+          ) {
+            nativeSettled = true
+            fail(call, 'CANCELLED')
+          } else if (
+            operations.some(
+              (operation) => operation.id === p.requestId && operation.method === 'channel/next',
+            )
+          ) {
+            // Cancellation may arrive after this fixture already answered the read.
+          } else
+            throw Error('Helper cancelled its invocation waiter instead of awaiting settlement')
+        } else throw Error(`unexpected method ${request.method}`)
+      }
+    }
+    expect(await process.exited, await errors).toBe(0)
+    if (mode === 'root-cancel' || mode === 'observer-root-cancel') {
+      expect(final?.error?.data?.code).toBe('CANCELLED')
+      return { output: null, operations }
+    }
+    expect(final?.result?.outcome).toBe('done')
+    expect(closed).toBe(true)
+    return { output: final.result.output, operations }
+  } finally {
+    clearTimeout(timer)
+    process.kill()
+    await process.exited
+  }
+}
+
+for (const mode of ['normal', 'interrupt', 'completion-race']) {
+  test(`public conversation helper: ${mode}`, async () => {
+    const { output } = await exercise(mode)
+    expect(output.turns).toHaveLength(2)
+    expect(output.value.second.type).toBe(mode === 'interrupt' ? 'cancelled' : 'result')
+    expect(output.settlement).toEqual({ outcome: 'done', output: { turns: 2 } })
+  })
+}
+test('helper filters live public events without caller channel coordination', async () => {
+  const { output } = await exercise('observer')
+  expect(output.displayed).toEqual(['visible draft'])
+  expect(output.observation).toEqual({ status: 'complete' })
+  expect(output.settlement).toEqual({ outcome: 'done', output: { turns: 2 } })
+})
+for (const mode of ['observer-throws', 'observer-async', 'observer-lagged', 'observer-disposal']) {
+  test(`${mode} leaves successful Agent settlement intact with explicit observation loss`, async () => {
+    const { output } = await exercise(mode)
+    expect(output.observation.status).toBe('incomplete')
+    expect(output.observation.errors.length).toBeGreaterThan(0)
+    expect(output.turns).toHaveLength(2)
+    expect(output.settlement).toEqual({ outcome: 'done', output: { turns: 2 } })
+  })
+}
+test('public conversation helper keeps requested retention on final settlement only', async () => {
+  const { output } = await exercise('retained')
+  expect(output.turns).toHaveLength(2)
+  expect(output.turns.every((turn: any) => turn.result.output.session === undefined)).toBe(true)
+  expect(output.settlement).toEqual({
+    outcome: 'done',
+    output: {
+      turns: 2,
+      session: { status: 'retained', reference: '013579ab-cdef-4567-89ab-0123456789ab' },
+    },
+  })
+})
+for (const mode of ['missing-session', 'invalid-session', 'unsolicited-session']) {
+  test(`public conversation helper refuses ${mode} while retaining settled turns`, async () => {
+    const { output } = await exercise(mode)
+    expect(output.errors).toContain('Agent omitted matching conversation settlement')
+    expect(output.turns).toHaveLength(2)
+    expect(output.settlement.output.turns).toBe(2)
+  })
+}
+
+for (const mode of [
+  'unavailable',
+  'late-error',
+  'malformed',
+  'partial-allocation',
+  'callback-error',
+  'abandoned',
+  'disposal-error',
+]) {
+  test(`public conversation helper retains honest ${mode}`, async () => {
+    const { output } = await exercise(mode)
+    expect(output.errors.length).toBeGreaterThan(0)
+    expect(output.turns).toHaveLength(
+      mode === 'disposal-error' ? 2 : ['late-error', 'callback-error'].includes(mode) ? 1 : 0,
+    )
+    if (mode === 'callback-error')
+      expect(output.settlement).toEqual({ outcome: 'done', output: { turns: 1 } })
+  })
+}
+
+test('root cancellation cannot become successful conversation recovery', async () => {
+  await exercise('root-cancel')
+  await exercise('observer-root-cancel')
+})
+test('a failed observed invocation settles without waiting for events that cannot arrive', async () => {
+  const { output } = await exercise('observer-unavailable')
+  expect(output.errors.length).toBeGreaterThan(0)
+  expect(output.turns).toHaveLength(0)
+})

package/test/json.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  canonicalJson,
+  decodeJson1,
+  JSON_1_LIMITS,
+  type JsonValue,
+  validateJson1,
+} from '../src/json.js'
+
+const bytes = (text: string) => new TextEncoder().encode(text)
+
+describe('local complete JSON/0 codec', () => {
+  test('decodes and canonicalizes portable scalars, magic names and Unicode', () => {
+    const value = decodeJson1(bytes('{"__proto__":1,"z":-0,"a":[true,false,null,"😀",1.25]}'))
+    expect(Object.getPrototypeOf(value)).toBeNull()
+    expect(new TextDecoder().decode(canonicalJson(value))).toBe(
+      '{"__proto__":1,"a":[true,false,null,"😀",1.25],"z":0}',
+    )
+    expect(decodeJson1(bytes('9007199254740991'))).toBe(Number.MAX_SAFE_INTEGER)
+    expect(Object.is(decodeJson1(bytes('-0')), -0)).toBe(true)
+  })
+
+  test('rejects duplicate keys, non-JSON syntax and out-of-domain numbers', () => {
+    for (const text of [
+      '',
+      '{"a":1,"\\u0061":2}',
+      '01',
+      '+1',
+      '.1',
+      '1.',
+      '1e',
+      'NaN',
+      '1e400',
+      '9007199254740993',
+      '-9007199254740992',
+      'true false',
+      '[1,]',
+      '{"a":1,}',
+      '"\\ud800"',
+      '"\\udc00"',
+      '\ufeff{}',
+    ]) {
+      expect(() => decodeJson1(bytes(text))).toThrow()
+    }
+    expect(() => decodeJson1(Uint8Array.from([0x22, 0xc0, 0xaf, 0x22]))).toThrow('UTF-8')
+  })
+
+  test('rejects encoded document, depth, node, container, key, string and token overflow', () => {
+    expect(() => decodeJson1(new Uint8Array(JSON_1_LIMITS.bytes + 1))).toThrow()
+    expect(() => decodeJson1(bytes('['.repeat(128) + '0' + ']'.repeat(128)))).toThrow('depth')
+    expect(() => validateJson1(Array(65_537).fill(0))).toThrow('array items')
+    expect(() => validateJson1(Array.from({ length: 4 }, () => Array(65_536).fill(0)))).toThrow(
+      'nodes',
+    )
+    expect(() => validateJson1({ ['a'.repeat(1025)]: 0 })).toThrow('string bytes')
+    expect(() => validateJson1('a'.repeat(8_388_609))).toThrow('string bytes')
+    expect(() => decodeJson1(bytes(`0.${'0'.repeat(128)}1`))).toThrow('number token')
+    expect(() => validateJson1(['\0'.repeat(3_000_000)])).toThrow('encoded bytes')
+  })
+
+  test('checks ordinary host data without invoking accessors or serialization hooks', () => {
+    let called = false
+    const object = {
+      get value() {
+        called = true
+        return 'unsafe'
+      },
+    }
+    expect(() => validateJson1(object)).toThrow()
+    expect(called).toBe(false)
+    const cycle: JsonValue[] = []
+    cycle.push(cycle)
+    for (const value of [
+      cycle,
+      new Date(),
+      new Map(),
+      undefined,
+      Infinity,
+      NaN,
+      '\udfff',
+      new Array(1),
+      { [Symbol('hidden')]: 1 },
+    ]) {
+      expect(() => validateJson1(value)).toThrow()
+    }
+  })
+})