@sixb/core 0.1.8 → 0.1.9

package/src/models/execution/model-call-recorder.ts

@@ -0,0 +1,235 @@
+import { randomUUID } from "node:crypto"
+import type { ReadonlyJsonObject, RecordAiModelCallInput } from "../../storage"
+import type { ModelCallEndEvent, ModelUsage } from "../events"
+import type { LanguageModel, LanguageModelRequest } from "../language-model"
+import { ModelUsageRecordingError } from "./errors"
+import {
+  normalizeModelCallAccounting,
+  recordAiModelCallAccounting,
+  requireAccountingCapabilities,
+} from "./model-call-accounting"
+import {
+  aiModelCallOutputTokenAllowance,
+  type BeforeAiModelCall,
+  estimateAiModelCallInputTokens,
+  estimatedAiModelCallTotalTokens,
+} from "./model-call-admission"
+import type { AiModelCallLimitController } from "./model-call-limits"
+import { isPermanentAiUsageRecoveryError } from "./model-call-recovery"
+import type {
+  ModelCallAccountingStorage,
+  RecoverAiModelCall,
+  RecoverAiModelCallInput,
+} from "./types"
+import { aiModelCallUsageFromModel } from "./usage"
+
+const STORAGE_RETRY_DELAYS_MS = [50, 200, 600] as const
+
+export interface AiModelCallRecorderInput {
+  readonly storage: ModelCallAccountingStorage
+  readonly projectId: string
+  readonly executionId: string
+  readonly attempt: number
+  readonly requesterGroupIds: readonly string[]
+  readonly limits: AiModelCallLimitController
+  readonly recoverAiModelCall: RecoverAiModelCall
+}
+
+interface AiModelCallRecorderInternals {
+  readonly generateId?: () => string
+  readonly now?: () => Date
+  readonly retryDelaysMs?: readonly number[]
+  readonly sleep?: (ms: number) => Promise<void>
+  readonly recordAccounting?: (input: RecoverAiModelCallInput) => Promise<void>
+}
+
+/** Persist every completed provider call before another billable loop step can start. */
+export class AiModelCallRecorder {
+  private readonly generateId: () => string
+  private readonly now: () => Date
+  private readonly retryDelaysMs: readonly number[]
+  private readonly sleep: (ms: number) => Promise<void>
+  private readonly recordAccounting: (input: RecoverAiModelCallInput) => Promise<void>
+  private readonly reservations = new Set<string>()
+  private admissionError: unknown
+  private recordingError: ModelUsageRecordingError | undefined
+
+  constructor(
+    private readonly input: AiModelCallRecorderInput,
+    internals: AiModelCallRecorderInternals = {}
+  ) {
+    requireAccountingCapabilities(input.storage)
+    this.generateId = internals.generateId ?? (() => `ai_usage_${randomUUID()}`)
+    this.now = internals.now ?? (() => new Date())
+    this.retryDelaysMs = internals.retryDelaysMs ?? STORAGE_RETRY_DELAYS_MS
+    this.sleep = internals.sleep ?? sleep
+    this.recordAccounting =
+      internals.recordAccounting ??
+      (async (recovery) => {
+        await recordAiModelCallAccounting({ storage: this.input.storage, ...recovery })
+      })
+  }
+
+  /** Wrap the resolved model so all calls in an execution share admission. */
+  wrapModel(model: LanguageModel): LanguageModel {
+    return {
+      providerId: model.providerId,
+      modelId: model.modelId,
+      definition: model.definition,
+      costEstimator: model.costEstimator,
+      ...(model.validateResponseFormat === undefined
+        ? {}
+        : { validateResponseFormat: model.validateResponseFormat.bind(model) }),
+      stream: async (request) => {
+        this.assertHealthy()
+        const inputTokens = estimateAiModelCallInputTokens({
+          prompt: request.messages,
+          tools: request.tools,
+          responseFormat: request.responseFormat,
+        })
+        const outputTokenAllowance = aiModelCallOutputTokenAllowance(request.maxOutputTokens)
+        let decision: Awaited<ReturnType<BeforeAiModelCall>>
+        try {
+          decision = await this.input.limits.beforeModelCall({
+            ...this.identity(request),
+            requesterGroupIds: this.input.requesterGroupIds,
+            providerId: model.providerId,
+            modelId: model.modelId,
+            costEstimator: model.costEstimator,
+            inputTokens,
+            outputTokenAllowance,
+            estimatedTotalTokens: estimatedAiModelCallTotalTokens(
+              inputTokens,
+              outputTokenAllowance
+            ),
+          })
+        } catch (error) {
+          // Execution boundaries must retain the original coded admission failure.
+          this.admissionError = error
+          throw error
+        }
+        if (decision.reservation === "active") this.reservations.add(request.callId)
+        try {
+          return await model.stream(request)
+        } catch (error) {
+          if (this.reservations.has(request.callId)) {
+            await this.input.limits.markModelCallUnknown(this.identity(request))
+          }
+          throw error
+        }
+      },
+    }
+  }
+
+  private identity(request: Pick<LanguageModelRequest, "callId">) {
+    return {
+      projectId: this.input.projectId,
+      executionId: this.input.executionId,
+      attempt: this.input.attempt,
+      callId: request.callId,
+    }
+  }
+
+  readonly onModelCallEnd = async (event: ModelCallEndEvent): Promise<void> => {
+    // Calls already in flight still need their own accounting after another call fails.
+    // Only admission is gated by the execution's sticky failure.
+    try {
+      const occurredAt = this.now()
+      const record: RecordAiModelCallInput = {
+        id: this.generateId(),
+        projectId: this.input.projectId,
+        executionId: this.input.executionId,
+        attempt: this.input.attempt,
+        callId: event.callId,
+        requesterGroupIds: this.input.requesterGroupIds,
+        providerId: event.providerId,
+        ...(event.providerIds === undefined ? {} : { providerIds: event.providerIds }),
+        requestedModelId: event.modelId,
+        ...(event.requestedReasoning === undefined
+          ? {}
+          : { requestedReasoning: event.requestedReasoning }),
+        ...(event.responseModelId === undefined ? {} : { responseModelId: event.responseModelId }),
+        responseId: event.responseId,
+        usage: aiModelCallUsageFromModel(event.usage),
+        ...(event.usage.raw === undefined ? {} : { rawUsage: rawUsage(event.usage) }),
+        occurredAt,
+      }
+      const recoveryInput = normalizeModelCallAccounting({
+        usage: record,
+        cost: event.cost,
+        ...(event.estimate === undefined ? {} : { estimate: event.estimate }),
+        ...(event.route === undefined ? {} : { route: event.route }),
+        ratedAt: new Date(occurredAt),
+        ...(this.reservations.has(event.callId) ? { reconcileLimitReservation: true } : {}),
+      })
+
+      try {
+        await retryOperation(
+          () => this.recordAccounting(recoveryInput),
+          this.retryDelaysMs,
+          this.sleep,
+          (error) => !isPermanentAiUsageRecoveryError(error)
+        )
+      } catch (storageError) {
+        if (isPermanentAiUsageRecoveryError(storageError)) throw storageError
+
+        try {
+          await retryOperation(
+            () => this.input.recoverAiModelCall(recoveryInput),
+            this.retryDelaysMs,
+            this.sleep,
+            (error) => !isPermanentAiUsageRecoveryError(error)
+          )
+        } catch (recoveryError) {
+          throw new AggregateError(
+            [storageError, recoveryError],
+            "Direct AI accounting and durable recovery both failed."
+          )
+        }
+        throw new ModelUsageRecordingError(this.input.executionId, event.callId, true, {
+          cause: storageError,
+        })
+      }
+    } catch (error) {
+      const recordingError =
+        error instanceof ModelUsageRecordingError
+          ? error
+          : new ModelUsageRecordingError(this.input.executionId, event.callId, false, {
+              cause: error,
+            })
+      this.recordingError ??= recordingError
+      throw recordingError
+    }
+  }
+
+  assertHealthy(): void {
+    if (this.admissionError !== undefined) throw this.admissionError
+    if (this.recordingError) throw this.recordingError
+  }
+}
+
+function rawUsage(usage: ModelUsage): ReadonlyJsonObject {
+  return structuredClone(usage.raw ?? {})
+}
+
+async function retryOperation<TResult>(
+  operation: () => Promise<TResult>,
+  retryDelaysMs: readonly number[],
+  wait: (ms: number) => Promise<void>,
+  shouldRetry: (error: unknown) => boolean
+): Promise<TResult> {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await operation()
+    } catch (error) {
+      if (!shouldRetry(error)) throw error
+      const delay = retryDelaysMs[attempt]
+      if (delay === undefined) throw error
+      await wait(delay)
+    }
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/src/models/execution/model-call-recovery.ts

@@ -0,0 +1,125 @@
+import type { RecordAiModelCallInput, RecordAiModelCallResult } from "../../storage"
+import { AiCostStorageError, AiLimitStorageError, AiUsageStorageError } from "../../storage"
+import { normalizeAiModelCallRecord } from "../../storage/ai-usage/record"
+import { recordAiModelCallAccounting } from "./model-call-accounting"
+import type {
+  AiModelCallAccountingPayload,
+  AiModelCallRecordPayload,
+  AiModelCallRecoveryRecord,
+  ModelCallAccountingStorage,
+  RecoverAiModelCallInput,
+} from "./types"
+import { aiModelCallUsageFromModel } from "./usage"
+
+class InvalidAiUsageRecoveryJobError extends Error {
+  readonly name = "InvalidAiUsageRecoveryJobError"
+
+  constructor(message: string, options?: ErrorOptions) {
+    super(`[SixbModels] ${message}`, options)
+  }
+}
+
+/** Encode one failed accounting transaction for a durable, JSON-safe handoff. */
+export function modelCallRecoveryPayload(input: RecoverAiModelCallInput): {
+  readonly record: AiModelCallRecordPayload
+  readonly accounting: AiModelCallAccountingPayload
+} {
+  normalizeAiModelCallRecord(input.usage)
+  return {
+    record: toQueuePayload(input.usage),
+    accounting: toAccountingPayload(input),
+  }
+}
+
+/** Replay one durable handoff through the idempotent atomic accounting boundary. */
+export async function recordRecoveredAiModelCall(
+  storage: Pick<ModelCallAccountingStorage, "transaction">,
+  job: AiModelCallRecoveryRecord
+): Promise<RecordAiModelCallResult> {
+  const usage = fromQueuePayload(job)
+  const accounting = accountingFromQueuePayload(job)
+  return recordAiModelCallAccounting({ storage, usage, ...accounting })
+}
+
+/** Validation and referential-integrity failures cannot become valid through queue redelivery. */
+export function isPermanentAiUsageRecoveryError(error: unknown): boolean {
+  return (
+    error instanceof InvalidAiUsageRecoveryJobError ||
+    error instanceof TypeError ||
+    (error instanceof AiUsageStorageError &&
+      (error.code === "duplicate_id" || error.code === "missing_execution")) ||
+    (error instanceof AiCostStorageError &&
+      (error.code === "missing_usage" || error.code === "cost_mismatch")) ||
+    (error instanceof AiLimitStorageError &&
+      (error.code === "missing_execution" ||
+        error.code === "missing_reservation" ||
+        error.code === "missing_usage_record" ||
+        error.code === "usage_mismatch" ||
+        error.code === "reservation_conflict" ||
+        error.code === "reconciliation_conflict" ||
+        error.code === "invalid_reservation_state"))
+  )
+}
+
+function toQueuePayload(record: RecordAiModelCallInput): AiModelCallRecordPayload {
+  return {
+    id: record.id,
+    executionId: record.executionId,
+    attempt: record.attempt,
+    callId: record.callId,
+    requesterGroupIds: [...record.requesterGroupIds],
+    providerId: record.providerId,
+    ...(record.providerIds === undefined
+      ? {}
+      : { providerIds: structuredClone(record.providerIds) }),
+    requestedModelId: record.requestedModelId,
+    ...(record.requestedReasoning === undefined
+      ? {}
+      : { requestedReasoning: structuredClone(record.requestedReasoning) }),
+    ...(record.responseModelId === undefined ? {} : { responseModelId: record.responseModelId }),
+    responseId: record.responseId,
+    usage: aiModelCallUsageFromModel(record.usage),
+    ...(record.rawUsage === undefined ? {} : { rawUsage: structuredClone(record.rawUsage) }),
+    occurredAt: record.occurredAt.toISOString(),
+  }
+}
+
+function toAccountingPayload(input: RecoverAiModelCallInput): AiModelCallAccountingPayload {
+  return {
+    cost: structuredClone(input.cost),
+    ...(input.estimate === undefined ? {} : { estimate: structuredClone(input.estimate) }),
+    ...(input.route === undefined ? {} : { route: structuredClone(input.route) }),
+    ratedAt: input.ratedAt.toISOString(),
+    ...(input.reconcileLimitReservation ? { reconcileLimitReservation: true } : {}),
+  }
+}
+
+function fromQueuePayload(job: AiModelCallRecoveryRecord): RecordAiModelCallInput {
+  const occurredAt = parseDate(job.payload.record.occurredAt, job.id, "occurredAt")
+  return { ...job.payload.record, projectId: job.projectId, occurredAt }
+}
+
+function accountingFromQueuePayload(
+  job: AiModelCallRecoveryRecord
+): Omit<RecoverAiModelCallInput, "usage"> {
+  const accounting = job.payload.accounting
+  return {
+    cost: structuredClone(accounting.cost),
+    ...(accounting.estimate === undefined
+      ? {}
+      : { estimate: structuredClone(accounting.estimate) }),
+    ...(accounting.route === undefined ? {} : { route: structuredClone(accounting.route) }),
+    ratedAt: parseDate(accounting.ratedAt, job.id, "ratedAt"),
+    reconcileLimitReservation: accounting.reconcileLimitReservation === true,
+  }
+}
+
+function parseDate(value: string, jobId: string, field: string): Date {
+  const date = new Date(value)
+  if (!Number.isFinite(date.getTime())) {
+    throw new InvalidAiUsageRecoveryJobError(
+      `AI usage recovery job '${jobId}' has an invalid ${field} timestamp.`
+    )
+  }
+  return date
+}

package/src/models/execution/recovery-queue.ts

@@ -0,0 +1,31 @@
+import { createSixbError } from "../../errors/internal"
+import type { AgentQueueJob, Queue } from "../../queues"
+import { modelCallRecoveryPayload } from "./model-call-recovery"
+import type { RecoverAiModelCallInput } from "./types"
+
+/** Stable queue identity: a lost enqueue response can safely retry the same accounting handoff. */
+function agentAiUsageRecoveryJobId(recordId: string): string {
+  return `agt_usage_job_${recordId}`
+}
+
+/** Transport adapter for the agent worker's existing durable recovery lane. */
+export async function enqueueAiModelCallRecovery(
+  queue: Pick<Queue<AgentQueueJob>, "enqueue">,
+  input: RecoverAiModelCallInput
+): Promise<void> {
+  const payload = modelCallRecoveryPayload(input)
+  const record = input.usage
+  const jobId = agentAiUsageRecoveryJobId(record.id)
+  const [job] = await queue.enqueue({
+    projectId: record.projectId,
+    jobs: [{ id: jobId, type: "agent.ai-usage.record.requested", payload }],
+  })
+
+  if (job?.id !== jobId || job.type !== "agent.ai-usage.record.requested") {
+    throw createSixbError(
+      "internal.unexpected",
+      `[SixbModels] Agent queue did not confirm AI usage recovery job '${jobId}'.`,
+      { details: { jobId } }
+    )
+  }
+}

package/src/models/execution/types.ts

@@ -0,0 +1,58 @@
+import type {
+  AiCostStorage,
+  AiLimitStorage,
+  AiUsageStorage,
+  RecordAiModelCallInput,
+  Storage,
+} from "../../storage"
+import type { ModelRoute } from "../events"
+import type { ModelCallCost, ModelCostEstimate } from "../pricing"
+
+/** Only the stores and transaction boundary needed by model-call accounting. */
+export interface ModelCallAccountingStorage extends Pick<Storage, "transaction"> {
+  readonly aiUsage: AiUsageStorage
+  readonly aiCosts: AiCostStorage
+  readonly aiLimits: AiLimitStorage
+}
+
+export interface RecoverAiModelCallInput {
+  readonly usage: RecordAiModelCallInput
+  readonly cost: ModelCallCost
+  readonly estimate?: ModelCostEstimate
+  readonly route?: ModelRoute
+  readonly ratedAt: Date
+  /** True only when admission created an aggregate-budget reservation for this provider attempt. */
+  readonly reconcileLimitReservation?: boolean
+}
+
+export type RecoverAiModelCall = (input: RecoverAiModelCallInput) => Promise<void>
+
+/** JSON-safe ledger input shared by durable recovery transports. */
+export type AiModelCallRecordPayload = Omit<
+  RecordAiModelCallInput,
+  "projectId" | "usage" | "occurredAt" | "recordedAt"
+> & {
+  readonly usage: {
+    readonly [Field in keyof RecordAiModelCallInput["usage"]]: RecordAiModelCallInput["usage"][Field]
+  }
+  readonly occurredAt: string
+}
+
+export interface AiModelCallAccountingPayload {
+  readonly estimate?: ModelCostEstimate
+  readonly cost: ModelCallCost
+  readonly route?: ModelRoute
+  readonly ratedAt: string
+  /** True when admission created a reservation that recovery must reconcile. */
+  readonly reconcileLimitReservation?: boolean
+}
+
+/** Transport identity is used only for recovery diagnostics, not accounting identity. */
+export interface AiModelCallRecoveryRecord {
+  readonly id: string
+  readonly projectId: string
+  readonly payload: {
+    readonly record: AiModelCallRecordPayload
+    readonly accounting: AiModelCallAccountingPayload
+  }
+}

package/src/models/execution/usage.ts

@@ -0,0 +1,23 @@
+import type { AiModelCallUsageInput } from "../../storage"
+import type { ModelUsage } from "../events"
+
+/** Map one provider-neutral model call into Sixb's durable accounting vocabulary. */
+export function aiModelCallUsageFromModel(usage: ModelUsage): AiModelCallUsageInput {
+  return {
+    ...(usage.inputTokens === undefined ? {} : { inputTokens: usage.inputTokens }),
+    ...(usage.outputTokens === undefined ? {} : { outputTokens: usage.outputTokens }),
+    ...(usage.uncachedInputTokens === undefined
+      ? {}
+      : { uncachedInputTokens: usage.uncachedInputTokens }),
+    ...(usage.cacheReadInputTokens === undefined
+      ? {}
+      : { cacheReadInputTokens: usage.cacheReadInputTokens }),
+    ...(usage.cacheWriteInputTokens === undefined
+      ? {}
+      : { cacheWriteInputTokens: usage.cacheWriteInputTokens }),
+    ...(usage.textOutputTokens === undefined ? {} : { textOutputTokens: usage.textOutputTokens }),
+    ...(usage.reasoningOutputTokens === undefined
+      ? {}
+      : { reasoningOutputTokens: usage.reasoningOutputTokens }),
+  }
+}

package/src/models/execution.ts

@@ -0,0 +1,207 @@
+import { runModelLoop } from "../agents/model-loop"
+import { assertProviderAccess } from "../authorization"
+import type { ExecutionContext } from "../execution"
+import { ensureExecutionRecord, executionRecordInputFromRuntime } from "../execution/durable"
+import type { SixbRuntimeContext } from "../runtime/types"
+import type { ModelCatalog } from "./catalog"
+import { ModelProviderError, ModelStreamError, UnsupportedModelFeatureError } from "./errors"
+import type { ModelCallEndEvent } from "./events"
+import { type ModelExecutionAttempt, registerModelExecutionBinding } from "./execution/binding"
+import { requireAccountingCapabilities } from "./execution/model-call-accounting"
+import { aiModelCallOutputTokenAllowance } from "./execution/model-call-admission"
+import { createAiModelCallLimitController } from "./execution/model-call-limits"
+import { AiModelCallRecorder } from "./execution/model-call-recorder"
+import { enqueueAiModelCallRecovery } from "./execution/recovery-queue"
+import type {
+  InferLanguageModelOutput,
+  LanguageModelGenerateInput,
+  LanguageModelGenerateResult,
+  LanguageModelOutputShape,
+  ModelsRuntime,
+} from "./generation-types"
+import { modelReasoningSupportIssue } from "./language-model"
+import type { ModelMessage } from "./messages"
+import { languageModelOutput } from "./output"
+import { resolveLanguageModel } from "./resolve"
+
+export function createModelsRuntime(
+  runtime: SixbRuntimeContext,
+  execution: ExecutionContext,
+  catalog: ModelCatalog | undefined
+): ModelsRuntime {
+  let binding: ModelExecutionAttempt | undefined
+  let recorder: Promise<AiModelCallRecorder> | undefined
+
+  async function createRecorder(): Promise<AiModelCallRecorder> {
+    const storage = {
+      ...requireAccountingCapabilities(runtime.storage),
+      transaction: runtime.storage.transaction.bind(runtime.storage),
+    }
+    if (!binding) {
+      throw new Error(
+        "[SixbModels] Generation requires a bound request or worker execution attempt."
+      )
+    }
+    const { requesterGroupIds } = await ensureExecutionRecord(
+      runtime.storage.executions,
+      executionRecordInputFromRuntime({
+        execution,
+        runtimeAuthorization: runtime.runtimeAuthorization,
+      })
+    )
+    return new AiModelCallRecorder({
+      storage,
+      projectId: runtime.projectId,
+      executionId: execution.id,
+      attempt: binding.attempt,
+      requesterGroupIds,
+      limits: createAiModelCallLimitController({
+        storage,
+        projectId: runtime.projectId,
+        requestedBy: execution.requestedBy,
+        requesterGroupIds,
+      }),
+      recoverAiModelCall: (input) => enqueueAiModelCallRecovery(runtime.queues.agents, input),
+    })
+  }
+
+  function generate<const TShape extends LanguageModelOutputShape | undefined = undefined>(
+    input: LanguageModelGenerateInput<TShape>
+  ): Promise<
+    LanguageModelGenerateResult<
+      TShape extends LanguageModelOutputShape ? InferLanguageModelOutput<TShape> : string
+    >
+  >
+  async function generate(
+    input: LanguageModelGenerateInput<LanguageModelOutputShape | undefined>
+  ): Promise<LanguageModelGenerateResult<unknown>> {
+    assertProviderAccess(runtime, execution, "models.language.generate")
+    const messages = generationMessages(input)
+    if (!binding) {
+      throw new Error(
+        "[SixbModels] Generation requires a bound request or worker execution attempt."
+      )
+    }
+    const signal = input.signal ? AbortSignal.any([binding.signal, input.signal]) : binding.signal
+    signal.throwIfAborted()
+    const selected = input.model
+      ? catalog
+        ? catalog.language.getByRef({
+            provider: input.model.providerId,
+            modelId: input.model.modelId,
+          })?.model
+        : input.model
+      : catalog?.language.default.model
+    if (!selected) {
+      throw new Error(
+        input.model
+          ? `[SixbModels] Model '${input.model.providerId}/${input.model.modelId}' is not configured in models.language.`
+          : "[SixbModels] Configure models.language in createSixb() or supply a model to generate()."
+      )
+    }
+    const output =
+      input.output === undefined
+        ? undefined
+        : languageModelOutput(input.output, runtime.ontology.getValueTypesById())
+    const model = await resolveLanguageModel(selected)
+    const reasoningIssue = modelReasoningSupportIssue(
+      model.definition.capabilities.reasoning,
+      input.reasoning
+    )
+    if (reasoningIssue) throw new UnsupportedModelFeatureError(`[SixbModels] ${reasoningIssue}.`)
+    if (output && model.definition.capabilities.nativeStructuredOutput === false) {
+      throw new UnsupportedModelFeatureError(
+        "[SixbModels] Model does not support native structured output."
+      )
+    }
+    const maxOutputTokens = Math.min(
+      aiModelCallOutputTokenAllowance(input.maxOutputTokens ?? model.definition.maxOutputTokens),
+      model.definition.maxOutputTokens ?? Infinity
+    )
+    if (typeof input.reasoning === "object" && input.reasoning.budgetTokens >= maxOutputTokens) {
+      throw new TypeError("[SixbModels] Output allowance must exceed the reasoning token budget.")
+    }
+    recorder ??= createRecorder()
+    const accounting = await recorder
+    accounting.assertHealthy()
+    signal.throwIfAborted()
+    let event: ModelCallEndEvent | undefined
+    const options = {
+      model: accounting.wrapModel(model),
+      messages,
+      maxSteps: 1,
+      rejectLocalToolCalls: true,
+      maxOutputTokens,
+      reasoning: input.reasoning,
+      caching: input.caching,
+      signal,
+      onModelCallEnd: async (completed: ModelCallEndEvent) => {
+        await accounting.onModelCallEnd(completed)
+        event = completed
+      },
+    }
+    const result = output ? await runModelLoop({ ...options, output }) : await runModelLoop(options)
+    if (result.status === "aborted") {
+      signal.throwIfAborted()
+      throw new DOMException("Model generation aborted", "AbortError")
+    }
+    if (result.finishReason === "error" || result.finishReason === "content-filter") {
+      throw new ModelProviderError(
+        `[SixbModels] Generation ended with '${result.finishReason}'.`,
+        model.providerId,
+        model.modelId
+      )
+    }
+    if (!event)
+      throw new ModelStreamError("[SixbModels] Generation completed without accounting metadata.")
+    return {
+      output: result.output,
+      usage: event.usage,
+      cost: event.cost,
+      callId: event.callId,
+      finishReason: result.finishReason,
+    }
+  }
+
+  const models: ModelsRuntime = {
+    language: { generate },
+  }
+  registerModelExecutionBinding(models, (input) => {
+    binding = { attempt: input.attempt, signal: input.signal }
+  })
+  return models
+}
+
+function generationMessages(
+  input: LanguageModelGenerateInput<LanguageModelOutputShape | undefined>
+): readonly ModelMessage[] {
+  if ((input.prompt === undefined) === (input.messages === undefined)) {
+    throw new TypeError("[SixbModels] Supply exactly one of prompt or messages.")
+  }
+  if (input.prompt !== undefined && typeof input.prompt !== "string") {
+    throw new TypeError("[SixbModels] prompt must be a string.")
+  }
+  if (input.messages !== undefined && !Array.isArray(input.messages)) {
+    throw new TypeError("[SixbModels] messages must be an array.")
+  }
+  if (input.instructions !== undefined && typeof input.instructions !== "string") {
+    throw new TypeError("[SixbModels] instructions must be a string.")
+  }
+  if (
+    input.maxOutputTokens !== undefined &&
+    (!Number.isSafeInteger(input.maxOutputTokens) || input.maxOutputTokens <= 0)
+  ) {
+    throw new TypeError("[SixbModels] maxOutputTokens must be a positive safe integer.")
+  }
+  if (input.caching !== undefined && input.caching !== "auto" && input.caching !== "off") {
+    throw new TypeError("[SixbModels] caching must be 'auto' or 'off'.")
+  }
+  return [
+    ...(input.instructions === undefined
+      ? []
+      : [{ role: "system" as const, content: input.instructions }]),
+    ...(input.prompt !== undefined
+      ? [{ role: "user" as const, content: [{ type: "text" as const, text: input.prompt }] }]
+      : (input.messages ?? [])),
+  ]
+}