Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
15.8 KB
Raw Blame
import {
  automationRevisionSchema,
  automationRunSchema,
  automationSchema,
  type AutomationError,
  type AutomationRunEventType,
  type AutomationUsage,
} from "@omnirush/types/automations"
import {
  automationEngineAdmissionReceiptSchema,
  automationEngineAdmissionRequestSchema,
  automationEngineCancellationResultSchema,
  automationEngineCapabilityDeclarationSchema,
  automationEngineEventSchema,
  automationEnginePendingResultSchema,
  automationEngineReadResultSchema,
  automationEngineResultSchema,
  createAutomationEngineEventSequenceValidator,
  type AutomationEngineAdapter,
  type AutomationEngineAdmissionReceipt,
  type AutomationEngineAdmissionRequest,
  type AutomationEngineCapabilityDeclaration,
  type AutomationEngineEvent,
  type AutomationEngineExecutionState,
  type AutomationEngineResult,
} from "./engine.js"

type StoredExecution = {
  request: AutomationEngineAdmissionRequest
  receipt: AutomationEngineAdmissionReceipt
  events: AutomationEngineEvent[]
  state: AutomationEngineExecutionState
  result: AutomationEngineResult | null
  updatedAt: number
}

export interface FakeAutomationEngineHarness {
  adapter: AutomationEngineAdapter
  emit(input: {
    receipt: AutomationEngineAdmissionReceipt
    type: AutomationRunEventType
    payload: Record<string, unknown>
    createdAt: number
  }): AutomationEngineEvent
  complete(input: {
    receipt: AutomationEngineAdmissionReceipt
    status: "succeeded" | "failed" | "cancelled"
    threadId: string | null
    resultSummary: string | null
    usage: AutomationUsage
    error: AutomationError | null
    finishedAt: number
  }): AutomationEngineResult
}

function fakeCapabilities(input?: {
  adapterId?: string
  cancellation?: AutomationEngineCapabilityDeclaration["cancellation"]
}) {
  return automationEngineCapabilityDeclarationSchema.parse({
    adapterId: input?.adapterId ?? "fake-automation-engine",
    protocolVersion: 1,
    admission: "idempotent",
    reattachment: "receipt",
    eventDelivery: "ordered_at_least_once",
    resultPersistence: "durable",
    cancellation: input?.cancellation ?? "supported",
    isolation: {
      location: "cloud",
      filesystem: "none",
      shell: false,
      browser: false,
      computer: false,
      connect: "run-scoped",
      network: "provider-and-connect-only",
    },
  })
}

export function createFakeAutomationEngineAdapter(input?: {
  adapterId?: string
  cancellation?: AutomationEngineCapabilityDeclaration["cancellation"]
  now?: () => number
}): FakeAutomationEngineHarness {
  const capabilities = fakeCapabilities(input)
  const now = input?.now ?? Date.now
  const executions = new Map<string, StoredExecution>()
  const admissions = new Map<string, string>()
  let nextExecution = 1

  function stored(receipt: AutomationEngineAdmissionReceipt): StoredExecution | null {
    if (receipt.adapterId !== capabilities.adapterId) return null
    const execution = executions.get(receipt.executionId)
    if (!execution || execution.receipt.runId !== receipt.runId) return null
    return execution
  }

  function appendEvent(
    execution: StoredExecution,
    input: {
      type: AutomationRunEventType
      payload: Record<string, unknown>
      createdAt: number
    },
  ): AutomationEngineEvent {
    if (execution.result) throw new Error("Cannot append an event after a terminal result")
    const sequence = execution.events.length + 1
    const event = automationEngineEventSchema.parse({
      id: `${execution.receipt.executionId}:event:${sequence}`,
      idempotencyKey: `${execution.receipt.admissionKey}:event:${sequence}`,
      executionId: execution.receipt.executionId,
      runId: execution.receipt.runId,
      sequence,
      type: input.type,
      payload: input.payload,
      createdAt: input.createdAt,
    })
    execution.events.push(event)
    execution.state = "running"
    execution.updatedAt = input.createdAt
    return event
  }

  function finish(
    execution: StoredExecution,
    input: {
      status: "succeeded" | "failed" | "cancelled"
      threadId: string | null
      resultSummary: string | null
      usage: AutomationUsage
      error: AutomationError | null
      finishedAt: number
    },
  ): AutomationEngineResult {
    if (execution.result) return execution.result
    const result = automationEngineResultSchema.parse({
      executionId: execution.receipt.executionId,
      runId: execution.receipt.runId,
      status: input.status,
      threadId: input.threadId,
      resultSummary: input.resultSummary,
      usage: input.usage,
      error: input.error,
      finalSequence: execution.events.length,
      finishedAt: input.finishedAt,
    })
    execution.result = result
    execution.state = input.status
    execution.updatedAt = input.finishedAt
    return result
  }

  const adapter: AutomationEngineAdapter = {
    capabilities() {
      return Promise.resolve(automationEngineCapabilityDeclarationSchema.parse(capabilities))
    },

    admit(rawRequest) {
      const request = automationEngineAdmissionRequestSchema.parse(rawRequest)
      const existingId = admissions.get(request.admissionKey)
      if (existingId) {
        const existing = executions.get(existingId)
        if (!existing) throw new Error("Fake Automation engine admission index is corrupt")
        if (
          existing.request.run.id !== request.run.id
          || existing.request.automation.id !== request.automation.id
          || existing.request.revision.id !== request.revision.id
        ) {
          throw new Error("Automation engine admission key was reused for different work")
        }
        return Promise.resolve(automationEngineAdmissionReceiptSchema.parse(existing.receipt))
      }
      const executionId = `${capabilities.adapterId}:execution:${nextExecution}`
      nextExecution += 1
      const receipt = automationEngineAdmissionReceiptSchema.parse({
        receiptVersion: 1,
        adapterId: capabilities.adapterId,
        executionId,
        admissionKey: request.admissionKey,
        runId: request.run.id,
        admittedAt: request.requestedAt,
        attachment: { handle: executionId },
      })
      executions.set(executionId, {
        request,
        receipt,
        events: [],
        state: "admitted",
        result: null,
        updatedAt: request.requestedAt,
      })
      admissions.set(request.admissionKey, executionId)
      return Promise.resolve(receipt)
    },

    observe(rawReceipt, options) {
      const receipt = automationEngineAdmissionReceiptSchema.parse(rawReceipt)
      const execution = stored(receipt)
      const afterSequence = options?.afterSequence ?? 0
      if (!Number.isSafeInteger(afterSequence) || afterSequence < 0) {
        throw new Error("Automation engine event cursor must be a non-negative integer")
      }
      const events = execution?.events
        .filter((event) => event.sequence > afterSequence) ?? []
      const signal = options?.signal
      return (async function* observeEvents() {
        for (const event of events) {
          if (signal?.aborted) return
          yield automationEngineEventSchema.parse(event)
        }
      })()
    },

    read(rawReceipt) {
      const receipt = automationEngineAdmissionReceiptSchema.parse(rawReceipt)
      const execution = stored(receipt)
      if (!execution) return Promise.resolve(null)
      if (execution.result) {
        return Promise.resolve(automationEngineReadResultSchema.parse(execution.result))
      }
      return Promise.resolve(automationEnginePendingResultSchema.parse({
        status: "pending",
        state: execution.state,
        executionId: execution.receipt.executionId,
        runId: execution.receipt.runId,
        latestSequence: execution.events.length,
        updatedAt: execution.updatedAt,
      }))
    },

    cancel(rawReceipt) {
      const receipt = automationEngineAdmissionReceiptSchema.parse(rawReceipt)
      const requestedAt = now()
      const execution = stored(receipt)
      if (!execution) {
        return Promise.resolve(automationEngineCancellationResultSchema.parse({
          executionId: receipt.executionId,
          runId: receipt.runId,
          outcome: "not_found",
          requestedAt,
        }))
      }
      if (execution.result) {
        return Promise.resolve(automationEngineCancellationResultSchema.parse({
          executionId: receipt.executionId,
          runId: receipt.runId,
          outcome: "already_terminal",
          requestedAt,
        }))
      }
      if (capabilities.cancellation === "unsupported") {
        return Promise.resolve(automationEngineCancellationResultSchema.parse({
          executionId: receipt.executionId,
          runId: receipt.runId,
          outcome: "unsupported",
          requestedAt,
        }))
      }
      appendEvent(execution, {
        type: "terminal",
        payload: { status: "cancelled" },
        createdAt: requestedAt,
      })
      finish(execution, {
        status: "cancelled",
        threadId: null,
        resultSummary: null,
        usage: { inputTokens: null, outputTokens: null, costMicros: null },
        error: {
          code: "cancelled",
          message: "The Automation engine execution was cancelled.",
          retryable: false,
        },
        finishedAt: requestedAt,
      })
      return Promise.resolve(automationEngineCancellationResultSchema.parse({
        executionId: receipt.executionId,
        runId: receipt.runId,
        outcome: "requested",
        requestedAt,
      }))
    },
  }

  return {
    adapter,
    emit(eventInput) {
      const execution = stored(eventInput.receipt)
      if (!execution) throw new Error("Unknown fake Automation engine receipt")
      return appendEvent(execution, eventInput)
    },
    complete(resultInput) {
      const execution = stored(resultInput.receipt)
      if (!execution) throw new Error("Unknown fake Automation engine receipt")
      return finish(execution, resultInput)
    },
  }
}

function conformanceAdmission(input?: {
  admissionKey?: string
  runId?: string
}): AutomationEngineAdmissionRequest {
  const automation = automationSchema.parse({
    id: "automation_engine_conformance",
    organizationId: "organization_engine_conformance",
    ownerMemberId: "member_engine_conformance",
    name: "Engine conformance Automation",
    state: "active",
    currentRevisionId: "revision_engine_conformance",
    nextDueAt: 20_000,
    latestRunAt: null,
    needsAttentionReason: null,
    createdAt: 1_000,
    updatedAt: 1_000,
    archivedAt: null,
  })
  const revision = automationRevisionSchema.parse({
    id: automation.currentRevisionId,
    automationId: automation.id,
    version: 1,
    instructions: "Return the word ready.",
    schedule: { kind: "daily", timezone: "UTC", hour: 9, minute: 0 },
    model: { providerId: "provider_engine_conformance", modelId: "model_engine_conformance" },
    executionTarget: "desktop",
    maximumRuntimeMs: 60_000,
    digest: "0123456789abcdef",
    createdAt: 1_000,
  })
  const run = automationRunSchema.parse({
    id: input?.runId ?? "run_engine_conformance",
    automationId: automation.id,
    revisionId: revision.id,
    trigger: "scheduled",
    scheduledFor: 20_000,
    idempotencyKey: "automation:engine-conformance",
    status: "claimed",
    leaseOwner: "den_conformance",
    leaseExpiresAt: 60_000,
    heartbeatAt: 20_000,
    attemptCount: 1,
    executionTarget: "desktop",
    executionThread: null,
    providerId: revision.model.providerId,
    modelId: revision.model.modelId,
    startedAt: null,
    finishedAt: null,
    error: null,
    resultSummary: null,
    usage: { inputTokens: null, outputTokens: null, costMicros: null },
    createdAt: 20_000,
    updatedAt: 20_000,
  })
  return automationEngineAdmissionRequestSchema.parse({
    admissionKey: input?.admissionKey ?? "admission_engine_conformance",
    automation,
    revision,
    run,
    capabilityAccess: {
      endpoint: `https://den.example.test/mcp/automation-runs/${run.id}`,
      bearerToken: "ephemeral-engine-conformance-token",
      expiresAt: 120_000,
    },
    requestedAt: 20_000,
  })
}

export async function verifyFakeAutomationEngineAdapterConformance(
  harness: FakeAutomationEngineHarness = createFakeAutomationEngineAdapter(),
): Promise<string[]> {
  const checked: string[] = []
  const capabilities = automationEngineCapabilityDeclarationSchema.parse(
    await harness.adapter.capabilities(),
  )
  if (capabilities.reattachment !== "receipt") {
    throw new Error("Automation engine must support receipt reattachment")
  }
  checked.push("capability declaration")

  const request = conformanceAdmission()
  const firstReceipt = automationEngineAdmissionReceiptSchema.parse(
    await harness.adapter.admit(request),
  )
  const duplicateReceipt = automationEngineAdmissionReceiptSchema.parse(
    await harness.adapter.admit(request),
  )
  if (JSON.stringify(firstReceipt) !== JSON.stringify(duplicateReceipt)) {
    throw new Error("Automation engine admission was not idempotent")
  }
  checked.push("idempotent admission")

  harness.emit({
    receipt: firstReceipt,
    type: "assistant",
    payload: { text: "ready" },
    createdAt: 21_000,
  })
  harness.emit({
    receipt: firstReceipt,
    type: "usage",
    payload: { inputTokens: 1, outputTokens: 1 },
    createdAt: 22_000,
  })
  const firstEvents: AutomationEngineEvent[] = []
  const firstValidator = createAutomationEngineEventSequenceValidator(firstReceipt)
  for await (const event of harness.adapter.observe(firstReceipt)) {
    firstValidator.accept(event)
    firstEvents.push(event)
  }
  const replayedEvents: AutomationEngineEvent[] = []
  for await (const event of harness.adapter.observe(firstReceipt)) {
    replayedEvents.push(event)
  }
  if (JSON.stringify(firstEvents) !== JSON.stringify(replayedEvents)) {
    throw new Error("Automation engine replay changed durable event identity")
  }
  const persistedReceipt = automationEngineAdmissionReceiptSchema.parse(
    JSON.parse(JSON.stringify(firstReceipt)),
  )
  const persistedCursor = firstEvents[0]?.sequence ?? 0
  const resumedEvents: AutomationEngineEvent[] = []
  const resumedValidator = createAutomationEngineEventSequenceValidator(
    persistedReceipt,
    persistedCursor,
  )
  for await (const event of harness.adapter.observe(persistedReceipt, {
    afterSequence: persistedCursor,
  })) {
    resumedValidator.accept(event)
    resumedEvents.push(event)
  }
  if (resumedEvents[0]?.sequence !== 2 || resumedValidator.cursor !== 2) {
    throw new Error("Automation engine did not resume from the persisted event cursor")
  }
  checked.push("ordered idempotent events")

  harness.complete({
    receipt: firstReceipt,
    status: "succeeded",
    threadId: "thread_engine_conformance",
    resultSummary: "ready",
    usage: { inputTokens: 1, outputTokens: 1, costMicros: null },
    error: null,
    finishedAt: 23_000,
  })
  const firstRead = await harness.adapter.read(persistedReceipt)
  const secondRead = await harness.adapter.read(persistedReceipt)
  if (
    firstRead?.status !== "succeeded"
    || JSON.stringify(firstRead) !== JSON.stringify(secondRead)
  ) {
    throw new Error("Automation engine terminal result was not durable across reattachment")
  }
  checked.push("restart reattachment")
  checked.push("durable terminal result")

  const cancelReceipt = await harness.adapter.admit(conformanceAdmission({
    admissionKey: "admission_engine_cancellation",
    runId: "run_engine_cancellation",
  }))
  const cancellation = await harness.adapter.cancel(cancelReceipt)
  const cancelledResult = await harness.adapter.read(cancelReceipt)
  if (
    capabilities.cancellation === "unsupported"
      ? cancellation.outcome !== "unsupported"
        || cancelledResult?.status !== "pending"
        || cancelledResult.state !== "admitted"
      : cancellation.outcome !== "requested" || cancelledResult?.status !== "cancelled"
  ) {
    throw new Error("Automation engine did not honor its cancellation declaration")
  }
  checked.push("declared cancellation")
  return checked
}