@sixb/core 0.1.8 → 0.1.9

package/src/errors/internal.ts

@@ -1,5 +1,6 @@
 import { cloneJsonValue, isJsonValue, isPlainRecord, type ReadonlyJsonValue } from "../json"
 import { SIXB_ERROR_CODES, SIXB_ERROR_DEFINITIONS } from "./catalog"
+import { createFailureRedactor } from "./redaction"
 import type { SixbErrorCode, SixbFailure } from "./types"
 
 export const SIXB_FAILURE_MAX_MESSAGE_BYTES = 4 * 1024
@@ -103,7 +104,11 @@ export function captureSixbFailure<const TCodes extends SixbErrorCodeTuple>(
 
 /** Identifies errors created by Sixb without making their class part of the contract. */
 export function isSixbError(error: unknown): error is SixbCodedError {
-  return error instanceof SixbError
+  try {
+    return error instanceof SixbError
+  } catch {
+    return false
+  }
 }
 
 /**
@@ -128,9 +133,12 @@ export function toSixbFailure(
     throw new Error(`[Sixb] Error code '${error.code}' is not allowed by this failure contract.`)
   }
   const code = error.code
-  const details = error.details
+  const redactor = createFailureRedactor()
+  const details = error.details === undefined ? undefined : redactor.context(error.details)
+  const { detail, truncated } = findFailureDetail(error, code)
+  const summary = SIXB_ERROR_DEFINITIONS[code].publicMessage
   const message = truncateUtf8(
-    SIXB_ERROR_DEFINITIONS[code].publicMessage,
+    redactor.text(detail && detail.message !== summary ? `${summary} ${detail.message}` : summary),
     SIXB_FAILURE_MAX_MESSAGE_BYTES
   )
   const failure: SixbFailure = {
@@ -139,7 +147,9 @@ export function toSixbFailure(
     retryable: SIXB_ERROR_DEFINITIONS[code].retryable,
     at: failureTimestamp(options.at),
     ...(details === undefined ? {} : { details: cloneJsonValue(details, "Sixb failure details") }),
-    ...(message.truncated ? { truncated: true } : {}),
+    ...(detail?.httpStatus === undefined ? {} : { httpStatus: detail.httpStatus }),
+    ...(redactor.redacted ? { redacted: true } : {}),
+    ...(message.truncated || truncated || redactor.truncated ? { truncated: true } : {}),
   }
 
   if (serializedByteLength(failure) <= SIXB_FAILURE_MAX_SERIALIZED_BYTES) return failure
@@ -149,10 +159,67 @@ export function toSixbFailure(
     message: failure.message,
     retryable: failure.retryable,
     at: failure.at,
+    ...(failure.httpStatus === undefined ? {} : { httpStatus: failure.httpStatus }),
+    ...(failure.redacted ? { redacted: true } : {}),
     truncated: true,
   }
 }
 
+const NETWORK_MESSAGES: Readonly<Record<string, string>> = {
+  ECONNREFUSED: "The remote service refused the connection.",
+  ECONNRESET: "The remote service reset the connection.",
+  ENOTFOUND: "The remote host could not be resolved.",
+  EAI_AGAIN: "DNS resolution temporarily failed.",
+  ETIMEDOUT: "The connection timed out.",
+}
+
+function isHttpStatus(value: unknown): value is number {
+  return typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599
+}
+
+/** Select one explanation along the causal chain; unrelated aggregate errors stay separate. */
+function findFailureDetail(
+  error: SixbCodedError,
+  boundaryCode: SixbErrorCode
+): { detail?: { message: string; httpStatus?: number }; truncated: boolean } {
+  const seen = new Set<object>()
+  let current: unknown = error
+  while (typeof current === "object" && current !== null && !seen.has(current)) {
+    if (seen.size === 8) return { truncated: true }
+    seen.add(current)
+    if (
+      isSixbError(current) &&
+      current.code !== boundaryCode &&
+      current.code !== "internal.unexpected"
+    ) {
+      return {
+        detail: { message: SIXB_ERROR_DEFINITIONS[current.code].publicMessage },
+        truncated: false,
+      }
+    }
+    try {
+      // Read only data properties: arbitrary messages and getters remain private.
+      const status =
+        Object.getOwnPropertyDescriptor(current, "status")?.value ??
+        Object.getOwnPropertyDescriptor(current, "statusCode")?.value
+      if (isHttpStatus(status)) {
+        return {
+          detail: { message: `Upstream request returned HTTP ${status}.`, httpStatus: status },
+          truncated: false,
+        }
+      }
+      const code = Object.getOwnPropertyDescriptor(current, "code")?.value
+      if (typeof code === "string" && Object.hasOwn(NETWORK_MESSAGES, code)) {
+        return { detail: { message: NETWORK_MESSAGES[code] }, truncated: false }
+      }
+      current = Object.getOwnPropertyDescriptor(current, "cause")?.value
+    } catch {
+      break
+    }
+  }
+  return { truncated: false }
+}
+
 /** Serializes a validated failure for durable storage. */
 export function serializeSixbFailure<const TCodes extends SixbErrorCodeTuple>(
   failure: SixbFailure<TCodes[number]>,
@@ -186,7 +253,7 @@ export function parseSixbFailure(
     throw invalidStoredFailure("expected a JSON object")
   }
 
-  const { code, message, retryable, at, details, truncated } = candidate
+  const { code, message, retryable, at, details, httpStatus, redacted, truncated } = candidate
   if (typeof code !== "string" || !SIXB_ERROR_CODE_SET.has(code)) {
     throw invalidStoredFailure("code is not a known Sixb error code")
   }
@@ -215,15 +282,28 @@ export function parseSixbFailure(
     throw invalidStoredFailure("truncated must be true when present")
   }
 
+  if (redacted !== undefined && redacted !== true) {
+    throw invalidStoredFailure("redacted must be true when present")
+  }
+  if (httpStatus !== undefined && !isHttpStatus(httpStatus)) {
+    throw invalidStoredFailure("httpStatus must be an integer HTTP status")
+  }
+  const redactor = createFailureRedactor()
+  const safeMessage = truncateUtf8(redactor.text(message), SIXB_FAILURE_MAX_MESSAGE_BYTES)
+  const safeDetails =
+    details === undefined ? undefined : redactor.context(details as ReadonlyJsonValue)
+
   const failure: SixbFailure = {
     code: code as SixbErrorCode,
-    message,
+    message: safeMessage.value,
     retryable,
     at,
-    ...(details === undefined
+    ...(safeDetails === undefined
       ? {}
-      : { details: cloneJsonValue(details, "Stored Sixb failure details") }),
-    ...(truncated === true ? { truncated: true } : {}),
+      : { details: cloneJsonValue(safeDetails, "Stored Sixb failure details") }),
+    ...(httpStatus === undefined ? {} : { httpStatus: httpStatus as number }),
+    ...(redacted || redactor.redacted ? { redacted: true } : {}),
+    ...(truncated || redactor.truncated || safeMessage.truncated ? { truncated: true } : {}),
   }
   if (serializedByteLength(failure) > SIXB_FAILURE_MAX_SERIALIZED_BYTES) {
     throw invalidStoredFailure(
@@ -255,7 +335,7 @@ function invalidStoredFailure(reason: string): Error {
  * Extracts a diagnostic message for an internal error or log entry.
  *
  * The result can contain provider data and must not be persisted or returned by an API.
- * `toSixbFailure()` selects the catalog-owned public message instead.
+ * `toSixbFailure()` constructs a message from recognized HTTP, network, or Sixb information instead.
  */
 export function summarizeErrorMessage(value: unknown, fallback?: string): string {
   const message = readStringProperty(value, "message")

package/src/errors/redaction.ts

@@ -0,0 +1,98 @@
+import type { ReadonlyJsonValue } from "../json"
+
+const REDACTED = "[REDACTED]"
+const MAX_CONTEXT_DEPTH = 12
+const MAX_CONTEXT_ENTRIES = 1024
+const SENSITIVE_KEY =
+  /password|passwd|passphrase|secret|token|credential|authorization|cookie|privatekey|apikey|accesskey|connectionstring|databaseurl|clientassertion|signature/i
+const PRIVATE_CONTAINER =
+  /^(?:request|response)(?:body|headers)?$|^(?:headers|body|payload|env|environment)$/i
+
+function isSensitiveKey(key: string): boolean {
+  const normalized = key.replace(/[^a-z0-9]/gi, "")
+  return SENSITIVE_KEY.test(normalized) || PRIVATE_CONTAINER.test(normalized)
+}
+
+/** Runtime credentials are additional protection for context; never a license to copy errors. */
+function environmentSecrets(): string[] {
+  return Object.entries(process.env)
+    .filter(([key, value]) => isSensitiveKey(key) && value !== undefined && value.length >= 4)
+    .map(([, value]) => value as string)
+    .sort((a, b) => b.length - a.length)
+}
+
+export function createFailureRedactor() {
+  const secrets = environmentSecrets()
+  let redacted = false
+  let truncated = false
+  let entries = 0
+
+  const text = (input: string): string => {
+    let value = input
+    for (const secret of secrets) {
+      value = value
+        .split(REDACTED)
+        .map((part) => part.split(secret).join(REDACTED))
+        .join(REDACTED)
+    }
+    value = value
+      .replace(
+        /-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?(?:-----END [^-]*PRIVATE KEY-----|$)/g,
+        REDACTED
+      )
+      .replace(/\b(?:Bearer|Basic)\s+[A-Za-z0-9+/_.~=-]+/gi, REDACTED)
+      .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, REDACTED)
+      .replace(
+        /\b(?:sk[-_](?:live[-_]|test[-_]|proj[-_])?[A-Za-z0-9_-]{12,}|gh[pousr]_[A-Za-z0-9_]{20,}|github_pat_[A-Za-z0-9_]+|AKIA[A-Z0-9]{16})\b/g,
+        REDACTED
+      )
+      // URLs may carry userinfo, signed query parameters, or credentials in the path.
+      .replace(/\b[a-z][a-z0-9+.-]*:\/\/[^\s<>"']+/gi, REDACTED)
+      .replace(
+        /["']?\b(?:password|passwd|passphrase|[a-z_-]*secret|[a-z_-]*token|api[-_]?key|authorization|cookie|credential|signature)["']?\s*[=:]\s*(?:"[^"\r\n]*"|'[^'\r\n]*'|[^\s,;]+)/gi,
+        REDACTED
+      )
+    if (value !== input) redacted = true
+    return value
+  }
+
+  const context = (value: ReadonlyJsonValue, depth = 0): ReadonlyJsonValue => {
+    if (depth > MAX_CONTEXT_DEPTH || entries++ >= MAX_CONTEXT_ENTRIES) {
+      truncated = true
+      return "[TRUNCATED]"
+    }
+    if (typeof value === "string") return text(value)
+    if (value === null || typeof value !== "object") return value
+    if (Array.isArray(value)) {
+      const available = Math.max(0, MAX_CONTEXT_ENTRIES - entries)
+      if (value.length > available) truncated = true
+      return value.slice(0, available).map((entry) => context(entry, depth + 1))
+    }
+    const result: Record<string, ReadonlyJsonValue> = Object.create(null)
+    for (const [key, entry] of Object.entries(value)) {
+      if (entries >= MAX_CONTEXT_ENTRIES) {
+        truncated = true
+        break
+      }
+      if (isSensitiveKey(key)) {
+        redacted = true
+        entries++
+        result[text(key)] = REDACTED
+      } else {
+        result[text(key)] = context(entry, depth + 1)
+      }
+    }
+    return result
+  }
+
+  return {
+    text,
+    context,
+    get redacted() {
+      return redacted
+    },
+    get truncated() {
+      return truncated
+    },
+  }
+}

package/src/errors/types.ts

@@ -16,6 +16,10 @@ export interface SixbFailure<TCode extends SixbErrorCode = SixbErrorCode> {
   /** ISO-8601 UTC timestamp of the failure occurrence. */
   readonly at: string
   readonly details?: ReadonlyJsonValue
+  /** Status returned by the failed upstream request, when one exists. */
+  readonly httpStatus?: number
+  /** Sensitive context was replaced before this record crossed a storage or API boundary. */
+  readonly redacted?: true
   /** Present when optional context exceeded the durable failure size budget and was omitted. */
   readonly truncated?: true
 }

package/src/execution/agent.ts

@@ -1,7 +1,7 @@
 import { type AgentExecutionAuthorization, agentServiceAccountId } from "../agents/authority"
 import type { OntologySource } from "../ontology"
 import { isBoundSixb, type Sixb } from "../runtime/sixb"
-import type { CreateExecutionInput, ExecutionRecord } from "../storage/executions"
+import type { ExecutionRecord } from "../storage/executions"
 import { ExecutionStorageError } from "../storage/executions"
 
 export { ensureExecutionRecord } from "./durable"
@@ -36,11 +36,12 @@ export function createAgentExecutionRecord(input: {
   readonly actorId: string
   readonly runId: string
   readonly principal: Extract<AuthorizablePrincipal, { readonly type: "serviceAccount" }>
-}): CreateExecutionInput {
+}): Omit<ExecutionRecord, "createdAt"> {
   assertAgentPrincipal(input.actorId, input.principal)
   return {
     id: input.id,
     projectId: input.parent.projectId,
+    requesterGroupIds: [...input.parent.requesterGroupIds],
     ...(input.parent.requestedBy === undefined
       ? {}
       : { requestedBy: structuredClone(input.parent.requestedBy) }),
@@ -59,7 +60,7 @@ export function createInheritedAgentExecutionRecord(input: {
   readonly id: string
   readonly parent: ExecutionRecord
   readonly runId: string
-}): CreateExecutionInput {
+}): Omit<ExecutionRecord, "createdAt"> {
   const authority = input.parent.authorizationRef
   if (
     authority.type !== "disabled" &&
@@ -78,6 +79,7 @@ export function createInheritedAgentExecutionRecord(input: {
   return {
     id: input.id,
     projectId: input.parent.projectId,
+    requesterGroupIds: [...input.parent.requesterGroupIds],
     ...(input.parent.requestedBy === undefined
       ? {}
       : { requestedBy: structuredClone(input.parent.requestedBy) }),

package/src/execution/durable.ts

@@ -82,6 +82,7 @@ type PrimitiveExecutionOrigin =
       >
       readonly correlationId: string
       readonly requestedBy?: CreateExecutionInput["requestedBy"]
+      readonly requesterGroupIds?: readonly string[]
     }
 
 /** Build an immutable primitive execution from its parent execution or automatic trigger. */
@@ -94,6 +95,7 @@ export function createPrimitiveExecutionRecord(input: {
     input.origin.type === "execution"
       ? {
           projectId: input.origin.parent.projectId,
+          requesterGroupIds: [...input.origin.parent.requesterGroupIds],
           ...(input.origin.parent.requestedBy === undefined
             ? {}
             : { requestedBy: structuredClone(input.origin.parent.requestedBy) }),
@@ -102,6 +104,9 @@ export function createPrimitiveExecutionRecord(input: {
         }
       : {
           projectId: input.origin.projectId,
+          ...(input.origin.requesterGroupIds === undefined
+            ? {}
+            : { requesterGroupIds: [...input.origin.requesterGroupIds] }),
           ...(input.origin.requestedBy === undefined
             ? {}
             : { requestedBy: structuredClone(input.origin.requestedBy) }),
@@ -171,7 +176,12 @@ function assertExecutionRecordMatches(
   input: CreateExecutionInput
 ): void {
   const { createdAt: _createdAt, ...stored } = existing
-  if (!isDeepStrictEqual(stored, input)) {
+  if (
+    !isDeepStrictEqual(stored, {
+      ...input,
+      requesterGroupIds: input.requesterGroupIds ?? stored.requesterGroupIds,
+    })
+  ) {
     throw new ExecutionStorageError(
       "duplicate_execution",
       `[Sixb] Execution '${input.id}' already exists with different immutable provenance.`

package/src/execution/primitive.ts

@@ -1,3 +1,4 @@
+import { bindModelExecutionAttempt, type ModelExecutionAttempt } from "../models/execution/binding"
 import type { OntologySource } from "../ontology"
 import type { OntologyMutationRuntime } from "../runtime/ontology-mutations"
 import { getOntologyMutationRuntime } from "../runtime/ontology-mutations"
@@ -24,9 +25,12 @@ export function bindDurablePrimitiveExecution(
   input: {
     readonly execution: ExecutionRecord
     readonly primitive: TrustedPrimitiveRef
+    readonly modelExecution?: ModelExecutionAttempt
   }
 ): BoundPrimitiveExecution {
-  return bindPrimitiveScope(host, restoreTrustedPrimitiveExecutionScope(input))
+  const bound = bindPrimitiveScope(host, restoreTrustedPrimitiveExecutionScope(input))
+  if (input.modelExecution) bindModelExecutionAttempt(bound.sixb.models, input.modelExecution)
+  return bound
 }
 
 function bindPrimitiveScope(

package/src/execution/request.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto"
 import type { AuthorizationContext } from "../authorization"
+import { bindModelExecutionAttempt } from "../models/execution/binding"
 import type { OntologySource } from "../ontology"
 import { isBoundSixb, type Sixb } from "../runtime/sixb"
 import {
@@ -32,6 +33,7 @@ export type { AuthorizationContext } from "../authorization"
 export type { DatasetsRuntime } from "../datasets/execution"
 export type { EventsRuntime } from "../events/execution"
 export type { LogsRuntime } from "../logging/execution"
+export type { LanguageModelsRuntime, ModelsRuntime } from "../models/generation-types"
 export type {
   ExecutionObjectByIdHandle,
   ExecutionObjectSet,
@@ -104,6 +106,7 @@ export function bindRequestExecution(
   if (!isBoundSixb(sixb)) {
     throw new Error("[Sixb] Request host did not return an execution-bound Sixb SDK.")
   }
+  bindModelExecutionAttempt(sixb.models, { attempt: 1, signal: input.request.signal })
   return sixb
 }
 

package/src/index.ts

@@ -55,7 +55,6 @@ export {
   prop,
   ref,
   stringEnum,
-  validateSchemaOrRefValue,
   valueTypeRef,
 } from "./ontology"
 
@@ -127,9 +126,6 @@ export {
   isObjectActionDefinition,
   optional,
   param,
-  requestAction,
-  requestActionAndWait,
-  waitForActionRun,
 } from "./actions"
 /**
  * `ctx.edits()` rejects an invalid batch with this, so it crosses a public boundary and users need
@@ -336,24 +332,26 @@ export {
 
 // ── Logging ─────────────────────────────────────────────────
 
+export type { ConsoleLoggerOptions } from "./logging/console-logger"
+export { ConsoleLogger, noopLogger, noopLoggerProvider } from "./logging/console-logger"
+export type {
+  LoggingService,
+  LogsObservabilityOptions,
+  ObservabilityOptions,
+} from "./logging/service"
 export type {
-  ConsoleLoggerOptions,
   LogContext,
   LogEntry,
   LogFields,
   Logger,
   LoggerProvider,
-  LoggingService,
   LogLevel,
   LogRecord,
   LogRunRef,
-  LogsObservabilityOptions,
-  ObservabilityOptions,
   SixbRunKind,
   StoredLogLine,
-} from "./logging"
+} from "./logging/types"
 export {
-  ConsoleLogger,
   isLevelEnabled,
   isLogLevel,
   isLogRecord,
@@ -361,10 +359,8 @@ export {
   isStoredLogLine,
   LOG_LEVELS,
   logLevelsAtOrAbove,
-  noopLogger,
-  noopLoggerProvider,
   SIXB_RUN_KINDS,
-} from "./logging"
+} from "./logging/types"
 
 // ── Predicates ─────────────────────────────────────────────
 
@@ -426,7 +422,6 @@ export type { AuthorizationContext, GrantIndex, GrantKind } from "./authorizatio
 export {
   AuthorizationError,
   canAccessApplication,
-  emptyGrantIndex,
   isAllowed,
   isApplicationAccessControlled,
   resolveAuthorizationContext,
@@ -592,12 +587,14 @@ export type {
   CommandResult,
   CreateSandboxOptions,
   ExecOptions,
+  ResumeSandboxOptions,
   RunCommandOptions,
   Sandbox,
   SandboxFactory,
   SandboxFileRecord,
   SandboxNetworkPolicy,
   SandboxNetworkTarget,
+  SandboxSessionOptions,
   SandboxStatus,
 } from "./sandboxes"
 export {
@@ -724,7 +721,7 @@ export type {
   SyncRunRequestResult,
   SyncTargetBuilder,
 } from "./syncs"
-export { defineSync, requestSyncRun } from "./syncs"
+export { defineSync } from "./syncs"
 
 // ── Schedules ───────────────────────────────────────────────
 
@@ -784,7 +781,6 @@ export {
   isPipelineDefinition,
   isPipelineStepDefinition,
   PipelineError,
-  requestPipelineRun,
 } from "./pipelines"
 
 // ── Workflows ───────────────────────────────────────────────
@@ -850,7 +846,6 @@ export {
   isInterventionDefinition,
   isStepDefinition,
   isWorkflowDefinition,
-  requestWorkflowRun,
   WorkflowDefinitionError,
   WorkflowValidationError,
 } from "./workflows"
@@ -1062,7 +1057,6 @@ export {
   MAX_AGENT_APP_STATE_ENTRY_BYTES,
   MAX_AGENT_APP_STATE_TOTAL_BYTES,
   MAX_AGENT_CONTEXT_ENTRIES,
-  requestAgentRun,
 } from "./agents"
 export type { AgentThreadRecord, ListAgentThreadsResult } from "./storage/agents"
 
@@ -1075,6 +1069,14 @@ export type {
   ModelCatalog,
   ModelCatalogInput,
 } from "./models"
+export type {
+  InferLanguageModelOutput,
+  LanguageModelGenerateInput,
+  LanguageModelGenerateResult,
+  LanguageModelOutputShape,
+  LanguageModelsRuntime,
+  ModelsRuntime,
+} from "./models/generation-types"
 
 // ── Scheduling ──────────────────────────────────────────────
 

package/src/logging/index.ts

@@ -1,25 +1,5 @@
-export {
-  ConsoleLogger,
-  type ConsoleLoggerOptions,
-  noopLogger,
-  noopLoggerProvider,
-} from "./console-logger"
-export {
-  LoggingService,
-  type LoggingServiceOptions,
-  type LogsObservabilityOptions,
-  type LogsPage,
-  type LogsReadInput,
-  type LogsSubscribeInput,
-  type LogsTailInput,
-  type ObservabilityOptions,
-  resolveLoggingService,
-} from "./service"
-export {
-  DEFAULT_LOGS_MAX_BYTES,
-  DEFAULT_LOGS_RETENTION,
-  LOGS_STREAM,
-} from "./stream"
+/** Browser-safe logging contracts and record readers. */
+export type * from "./types"
 export {
   isLevelEnabled,
   isLogLevel,
@@ -27,17 +7,6 @@ export {
   isSixbRunKind,
   isStoredLogLine,
   LOG_LEVELS,
-  type LogContext,
-  type LogEntry,
-  type LogFields,
-  type Logger,
-  type LoggerProvider,
-  type LogLevel,
-  type LogRecord,
-  type LogRunRef,
   logLevelsAtOrAbove,
-  normalizeLogError,
   SIXB_RUN_KINDS,
-  type SixbRunKind,
-  type StoredLogLine,
 } from "./types"

package/src/logging/internal.ts

@@ -0,0 +1,43 @@
+export {
+  ConsoleLogger,
+  type ConsoleLoggerOptions,
+  noopLogger,
+  noopLoggerProvider,
+} from "./console-logger"
+export {
+  LoggingService,
+  type LoggingServiceOptions,
+  type LogsObservabilityOptions,
+  type LogsPage,
+  type LogsReadInput,
+  type LogsSubscribeInput,
+  type LogsTailInput,
+  type ObservabilityOptions,
+  resolveLoggingService,
+} from "./service"
+export {
+  DEFAULT_LOGS_MAX_BYTES,
+  DEFAULT_LOGS_RETENTION,
+  LOGS_STREAM,
+} from "./stream"
+export {
+  isLevelEnabled,
+  isLogLevel,
+  isLogRecord,
+  isSixbRunKind,
+  isStoredLogLine,
+  LOG_LEVELS,
+  type LogContext,
+  type LogEntry,
+  type LogFields,
+  type Logger,
+  type LoggerProvider,
+  type LogLevel,
+  type LogRecord,
+  type LogRunRef,
+  logLevelsAtOrAbove,
+  normalizeLogError,
+  SIXB_RUN_KINDS,
+  type SixbRunKind,
+  type StoredLogLine,
+} from "./types"

package/src/models/errors.ts

@@ -43,6 +43,18 @@ export class ModelStreamError extends Error {
 
 export class UnsupportedModelFeatureError extends Error {
   readonly name = "UnsupportedModelFeatureError"
+
+  constructor(
+    message?: string,
+    options?: ErrorOptions & {
+      readonly reason?: "unsupported-model" | "unsupported-schema"
+    }
+  ) {
+    super(message, options)
+    this.reason = options?.reason
+  }
+
+  readonly reason?: "unsupported-model" | "unsupported-schema"
 }
 
 export class StructuredOutputError extends Error {

package/src/models/execution/binding.ts

@@ -0,0 +1,29 @@
+import type { ModelsRuntime } from "../generation-types"
+
+export interface ModelExecutionAttempt {
+  readonly attempt: number
+  readonly signal: AbortSignal
+}
+
+const bindings = new WeakMap<ModelsRuntime, (input: ModelExecutionAttempt) => void>()
+
+export function registerModelExecutionBinding(
+  models: ModelsRuntime,
+  bind: (input: ModelExecutionAttempt) => void
+): void {
+  bindings.set(models, bind)
+}
+
+/** Called once on a fresh facade at the request or worker delivery boundary. */
+export function bindModelExecutionAttempt(
+  models: ModelsRuntime,
+  input: ModelExecutionAttempt
+): void {
+  const bind = bindings.get(models)
+  if (!bind) throw new Error("[SixbModels] Model runtime has no execution binding.")
+  if (!Number.isSafeInteger(input.attempt) || input.attempt < 1) {
+    throw new TypeError("[SixbModels] Execution attempt must be a positive safe integer.")
+  }
+  bind(input)
+  bindings.delete(models)
+}

package/src/models/execution/errors.ts

@@ -0,0 +1,18 @@
+/** A provider call was not recorded synchronously, so its execution must stop. */
+export class ModelUsageRecordingError extends Error {
+  readonly name = "ModelUsageRecordingError"
+
+  constructor(
+    readonly executionId: string,
+    readonly callId: string,
+    readonly recoveryScheduled: boolean,
+    options?: ErrorOptions
+  ) {
+    super(
+      recoveryScheduled
+        ? `[SixbModels] AI usage for call '${callId}' in execution '${executionId}' was deferred to durable recovery.`
+        : `[SixbModels] Could not preserve AI usage for call '${callId}' in execution '${executionId}'.`,
+      options
+    )
+  }
+}