@sixb/core 0.1.1 → 0.1.2

package/src/workflows/request.ts

@@ -1,10 +1,13 @@
-import { randomUUID } from "node:crypto"
-import { SYSTEM_PRINCIPAL } from "../auth"
+import { snapshotRequesterGroupIds } from "../auth/attribution"
 import { assertAuthorized } from "../authorization"
-import { reportRunFailure } from "../error-reporting/capability"
+import {
+  createPrimitiveExecutionRecord,
+  ensureExecutionRecord,
+  executionRecordInputFromRuntime,
+} from "../execution/durable"
+import type { ExecutionContext } from "../execution/types"
 import type { SixbRuntimeContext } from "../runtime/types"
-import { WorkflowValidationError } from "./errors"
-import { snapshotWorkflowInput } from "./snapshot"
+import { dispatchWorkflowRun } from "./run-dispatch"
 import type { WorkflowDefinition, WorkflowRunSource } from "./types"
 
 export interface WorkflowRunRequestOptions {
@@ -37,125 +40,43 @@ export interface WorkflowRunRequestResult {
  */
 export async function requestWorkflowRun(
   runtime: SixbRuntimeContext,
+  execution: ExecutionContext,
   workflow: WorkflowDefinition,
   options: WorkflowRunRequestOptions = {}
 ): Promise<WorkflowRunRequestResult> {
   assertAuthorized(runtime, { kind: "workflow.run", workflowId: workflow.id })
-  const storage = runtime.storage.workflowRuns
-  if (!storage) {
-    throw new WorkflowValidationError("[Sixb] Workflow run storage is not configured.")
-  }
-
-  const queue = runtime.queues.workflows
-  if (!queue) {
-    throw new WorkflowValidationError("[Sixb] Workflow run queue is not configured.")
-  }
-
-  const runId = createWorkflowRunId(options.runId)
-  const value = options.input ?? {}
-  // Validates the input against the workflow contract and rejects before any
-  // storage or queue write.
-  const snapshot = snapshotWorkflowInput({
+  const requesterGroupIds = execution.requestedBy
+    ? await snapshotRequesterGroupIds({
+        auth: runtime.storage.auth,
+        projectId: runtime.projectId,
+        principal: execution.requestedBy,
+      })
+    : []
+  return dispatchWorkflowRun({
+    errorReporterHost: runtime,
+    projectId: runtime.projectId,
     workflow,
-    value,
     valueTypesById: runtime.ontology.getValueTypesById(),
-  })
-
-  const existing = await storage.getById({ projectId: runtime.projectId, id: runId })
-  if (existing) {
-    if (existing.workflowId !== workflow.id) {
-      throw new WorkflowValidationError(
-        `[Sixb] Workflow run '${runId}' already exists for a different workflow '${existing.workflowId}'.`
-      )
-    }
-
-    return {
-      workflowId: workflow.id,
-      runId,
-      queuedAt: (existing.queuedAt ?? existing.startedAt).toISOString(),
-      created: false,
-    }
-  }
-
-  const queuedAt = new Date()
-  await storage.queue({
-    projectId: runtime.projectId,
-    id: runId,
-    workflowId: workflow.id,
-    input: snapshot,
-    queuedAt,
+    storage: runtime.storage,
+    queue: runtime.queues.workflows,
+    events: runtime.events,
+    runId: options.runId,
+    input: options.input,
     source: options.source,
-    requestedByPrincipal:
-      runtime.authorization?.principal ??
-      (options.source?.type === "schedule" ? options.source.principal : SYSTEM_PRINCIPAL),
-  })
-
-  let job: Awaited<ReturnType<typeof queue.enqueue>>[number] | undefined
-  try {
-    ;[job] = await queue.enqueue({
-      projectId: runtime.projectId,
-      jobs: [
-        {
-          type: "workflow.run.requested",
-          payload: { workflowId: workflow.id, runId, input: value },
-        },
-      ],
-    })
-  } catch (error) {
-    const failed = await storage.finish({
-      projectId: runtime.projectId,
-      id: runId,
-      status: "failed",
-      error: error instanceof Error ? error.message : String(error),
-    })
-    reportRunFailure(runtime, error, {
-      projectId: runtime.projectId,
-      occurredAt: failed.finishedAt,
-      run: {
-        kind: "workflow",
-        runId,
-        workflowId: workflow.id,
-      },
-    })
-    throw error
-  }
-
-  // Past this point the run row exists and the job is queued, so the run *will* execute. Rejecting
-  // here would report a failure for work already under way, and leave the run unmarked either way.
-  await runtime.events.emit(
-    {
-      events: [
-        {
-          type: "workflow.run.queued",
-          payload: {
-            workflowId: workflow.id,
-            runId,
-            queuedAt: queuedAt.toISOString(),
-            ...(job?.id ? { jobId: job.id } : {}),
-            ...(options.source ? { source: options.source } : {}),
-          },
-        },
-      ],
+    requesterGroupIds,
+    createExecution: async (executionId, runId) => {
+      const caller = await ensureExecutionRecord(
+        runtime.storage.executions,
+        executionRecordInputFromRuntime({
+          execution,
+          runtimeAuthorization: runtime.runtimeAuthorization,
+        })
+      )
+      return createPrimitiveExecutionRecord({
+        id: executionId,
+        primitive: { kind: "workflow", id: workflow.id, runId },
+        origin: { type: "execution", parent: caller },
+      })
     },
-    { source: "Sixb" }
-  )
-
-  return {
-    workflowId: workflow.id,
-    runId,
-    queuedAt: queuedAt.toISOString(),
-    jobId: job?.id,
-    created: true,
-  }
-}
-
-function createWorkflowRunId(runId: string | undefined): string {
-  if (runId !== undefined) {
-    if (!runId.trim()) {
-      throw new WorkflowValidationError("[Sixb] Workflow run id must not be empty")
-    }
-    return runId
-  }
-
-  return `run_${randomUUID()}`
+  })
 }

package/src/workflows/run-dispatch.ts

@@ -0,0 +1,359 @@
+import { randomUUID } from "node:crypto"
+import { isDeepStrictEqual } from "node:util"
+import { SYSTEM_PRINCIPAL } from "../auth"
+import { reportRunFailure } from "../error-reporting/capability"
+import { captureSixbFailure } from "../errors/internal"
+import type { DomainEventLog } from "../events"
+import type { RunDispatcher } from "../execution/dispatch"
+import { createPrimitiveExecutionRecord } from "../execution/durable"
+import type { ValueType } from "../ontology"
+import type { Queues } from "../queues"
+import type { SixbDefinitions } from "../runtime/definitions"
+import type { CreateExecutionInput, Storage, WorkflowRunRecord } from "../storage"
+import { WORKFLOW_RUN_FAILURE_CODES, WorkflowRunError } from "../storage"
+import { WorkflowValidationError } from "./errors"
+import type { WorkflowRunRequestResult } from "./request"
+import { snapshotWorkflowInput } from "./snapshot"
+import type { WorkflowDefinition, WorkflowIOSnapshot, WorkflowRunSource } from "./types"
+
+export type AutomaticWorkflowExecutionSource =
+  | { readonly type: "schedule"; readonly eventId: string }
+  | { readonly type: "event"; readonly eventId: string }
+
+/** One automatic match already resolved to a stable workflow run identity by the orchestrator. */
+export interface AutomaticWorkflowRunDispatchInput {
+  readonly workflowId: string
+  readonly runId: string
+  readonly input?: Readonly<Record<string, unknown>>
+  readonly scheduleId: string
+  readonly source: AutomaticWorkflowExecutionSource
+  readonly correlationId: string
+  readonly metadata?: Readonly<Record<string, string>>
+}
+
+export type WorkflowRunDispatchPort = RunDispatcher<
+  AutomaticWorkflowRunDispatchInput,
+  WorkflowRunRequestResult
+>
+
+export interface WorkflowRunDispatcherDependencies {
+  readonly id: string
+  readonly definitions: Pick<SixbDefinitions, "ontology" | "workflows">
+  readonly storage: Storage
+  readonly queues: Pick<Queues, "workflows">
+  readonly events: DomainEventLog
+}
+
+interface DispatchWorkflowRunInput {
+  readonly errorReporterHost: object
+  readonly projectId: string
+  readonly workflow: WorkflowDefinition
+  readonly valueTypesById: ReadonlyMap<string, ValueType>
+  readonly storage: Storage
+  readonly queue: Queues["workflows"]
+  readonly events: DomainEventLog
+  readonly runId?: string
+  readonly input?: Readonly<Record<string, unknown>>
+  readonly source?: WorkflowRunSource
+  readonly requesterGroupIds: readonly string[]
+  readonly metadata?: Readonly<Record<string, string>>
+  readonly queueJobId?: string
+  readonly createExecution: (executionId: string, runId: string) => Promise<CreateExecutionInput>
+}
+
+interface PreparedWorkflowRun {
+  readonly runId: string
+  readonly snapshot: WorkflowIOSnapshot
+}
+
+type PersistedWorkflowRun =
+  | {
+      readonly created: false
+      readonly run: WorkflowRunRecord
+    }
+  | {
+      readonly created: true
+      readonly run: WorkflowRunRecord
+      readonly execution: CreateExecutionInput
+      readonly queuedAt: Date
+    }
+
+/** Core-owned durable dispatch boundary used by automatic trigger runtimes. */
+export class WorkflowRunDispatcher implements WorkflowRunDispatchPort {
+  constructor(private readonly dependencies: WorkflowRunDispatcherDependencies) {}
+
+  async dispatch(input: AutomaticWorkflowRunDispatchInput): Promise<WorkflowRunRequestResult> {
+    assertAutomaticDispatchInput(input)
+    const workflow = this.dependencies.definitions.workflows.getById(input.workflowId)
+    if (!workflow) {
+      throw new WorkflowValidationError(`[Sixb] Unknown workflow '${input.workflowId}'`)
+    }
+
+    const result = await dispatchWorkflowRun({
+      errorReporterHost: this.dependencies,
+      projectId: this.dependencies.id,
+      workflow,
+      valueTypesById: this.dependencies.definitions.ontology.getValueTypesById(),
+      storage: this.dependencies.storage,
+      queue: this.dependencies.queues.workflows,
+      events: this.dependencies.events,
+      runId: input.runId,
+      input: input.input,
+      source: {
+        type: "schedule",
+        scheduleId: input.scheduleId,
+        eventId: input.source.eventId,
+        principal: SYSTEM_PRINCIPAL,
+      },
+      requesterGroupIds: [],
+      metadata: input.metadata,
+      queueJobId: input.runId,
+      createExecution: async (executionId, runId) =>
+        createPrimitiveExecutionRecord({
+          id: executionId,
+          primitive: { kind: "workflow", id: workflow.id, runId },
+          origin: {
+            type: "automatic",
+            projectId: this.dependencies.id,
+            source: input.source,
+            correlationId: input.correlationId,
+          },
+        }),
+    })
+    if (!result.created) {
+      await assertAutomaticExecutionIdentity(this.dependencies, input, result.runId)
+    }
+    return result
+  }
+}
+
+/** Persist a workflow execution and run before publishing its queue job. */
+export async function dispatchWorkflowRun(
+  input: DispatchWorkflowRunInput
+): Promise<WorkflowRunRequestResult> {
+  const request = prepareWorkflowRun(input)
+  const persisted = await persistWorkflowRun(input, request)
+  if (!persisted.created) return existingWorkflowRunResult(persisted.run)
+  return publishWorkflowRun(input, persisted)
+}
+
+function prepareWorkflowRun(input: DispatchWorkflowRunInput): PreparedWorkflowRun {
+  const value = input.input ?? {}
+  return {
+    runId: resolveWorkflowRunId(input.runId),
+    snapshot: snapshotWorkflowInput({
+      workflow: input.workflow,
+      value,
+      valueTypesById: input.valueTypesById,
+    }),
+  }
+}
+
+async function persistWorkflowRun(
+  input: DispatchWorkflowRunInput,
+  request: PreparedWorkflowRun
+): Promise<PersistedWorkflowRun> {
+  const workflowRuns = input.storage.workflowRuns
+  if (!workflowRuns) {
+    throw new WorkflowValidationError("[Sixb] Workflow run storage is not configured.")
+  }
+
+  const existing = await workflowRuns.getById({
+    projectId: input.projectId,
+    id: request.runId,
+  })
+  if (existing) {
+    assertExistingWorkflowRun(existing, input.workflow.id, request.snapshot)
+    return { run: existing, created: false }
+  }
+
+  const execution = await input.createExecution(`exec_${randomUUID()}`, request.runId)
+  const queuedAt = new Date()
+  try {
+    return await input.storage.transaction(
+      async (tx): Promise<PersistedWorkflowRun> => {
+        const raced = await tx.workflowRuns?.getById({
+          projectId: input.projectId,
+          id: request.runId,
+        })
+        if (raced) {
+          assertExistingWorkflowRun(raced, input.workflow.id, request.snapshot)
+          return { run: raced, created: false }
+        }
+        if (!tx.workflowRuns) {
+          throw new WorkflowValidationError("[Sixb] Workflow run storage is not configured.")
+        }
+
+        await tx.executions.create(execution)
+        const run = await tx.workflowRuns.queue({
+          projectId: input.projectId,
+          id: request.runId,
+          executionId: execution.id,
+          workflowId: input.workflow.id,
+          input: request.snapshot,
+          queuedAt,
+          requesterGroupIds: input.requesterGroupIds,
+        })
+        return { run, execution, queuedAt, created: true }
+      },
+      { isolation: "serializable" }
+    )
+  } catch (error) {
+    if (!(error instanceof WorkflowRunError)) throw error
+    const raced = await workflowRuns.getById({
+      projectId: input.projectId,
+      id: request.runId,
+    })
+    if (!raced) throw error
+    assertExistingWorkflowRun(raced, input.workflow.id, request.snapshot)
+    return { run: raced, created: false }
+  }
+}
+
+async function publishWorkflowRun(
+  input: DispatchWorkflowRunInput,
+  persisted: Extract<PersistedWorkflowRun, { readonly created: true }>
+): Promise<WorkflowRunRequestResult> {
+  let job: Awaited<ReturnType<Queues["workflows"]["enqueue"]>>[number] | undefined
+  try {
+    const jobs = await input.queue.enqueue({
+      projectId: input.projectId,
+      jobs: [
+        {
+          ...(input.queueJobId === undefined ? {} : { id: input.queueJobId }),
+          type: "workflow.run.requested",
+          payload: { runId: persisted.run.id },
+          ...(input.metadata === undefined ? {} : { metadata: input.metadata }),
+        },
+      ],
+    })
+    job = jobs[0]
+  } catch (error) {
+    await failWorkflowRunPublication(input, persisted.run, error)
+    throw error
+  }
+
+  await input.events.emit(
+    {
+      events: [
+        {
+          type: "workflow.run.queued",
+          payload: {
+            workflowId: persisted.run.workflowId,
+            runId: persisted.run.id,
+            queuedAt: persisted.queuedAt.toISOString(),
+            ...(job?.id ? { jobId: job.id } : {}),
+            ...(input.source === undefined ? {} : { source: input.source }),
+          },
+        },
+      ],
+      correlationId: persisted.execution.correlationId,
+    },
+    { source: "Sixb" }
+  )
+
+  return {
+    workflowId: persisted.run.workflowId,
+    runId: persisted.run.id,
+    queuedAt: persisted.queuedAt.toISOString(),
+    jobId: job?.id,
+    created: true,
+  }
+}
+
+async function failWorkflowRunPublication(
+  input: DispatchWorkflowRunInput,
+  run: WorkflowRunRecord,
+  error: unknown
+): Promise<void> {
+  const workflowRuns = input.storage.workflowRuns
+  if (!workflowRuns) {
+    throw new WorkflowValidationError("[Sixb] Workflow run storage is not configured.")
+  }
+  const failure = captureSixbFailure(error, {
+    allowedCodes: WORKFLOW_RUN_FAILURE_CODES,
+    defaultCode: "internal.unexpected",
+    details: { workflowId: run.workflowId, runId: run.id },
+  })
+  await workflowRuns.finish({
+    projectId: input.projectId,
+    id: run.id,
+    status: "failed",
+    error: failure,
+  })
+  reportRunFailure(input.errorReporterHost, error, {
+    projectId: input.projectId,
+    runKind: "workflow",
+    run: { runId: run.id, workflowId: run.workflowId },
+    failure,
+  })
+}
+
+function resolveWorkflowRunId(runId: string | undefined): string {
+  if (runId === undefined) return `run_${randomUUID()}`
+  if (!runId.trim()) {
+    throw new WorkflowValidationError("[Sixb] Workflow run id must not be empty")
+  }
+  return runId
+}
+
+function assertExistingWorkflowRun(
+  existing: WorkflowRunRecord,
+  workflowId: string,
+  input: WorkflowRunRecord["input"]
+): void {
+  if (existing.workflowId !== workflowId || !isDeepStrictEqual(existing.input, input)) {
+    throw new WorkflowValidationError(
+      `[Sixb] Workflow run '${existing.id}' already exists with a different request payload.`
+    )
+  }
+}
+
+function existingWorkflowRunResult(existing: WorkflowRunRecord): WorkflowRunRequestResult {
+  return {
+    workflowId: existing.workflowId,
+    runId: existing.id,
+    queuedAt: (existing.queuedAt ?? existing.startedAt).toISOString(),
+    created: false,
+  }
+}
+
+function assertAutomaticDispatchInput(input: AutomaticWorkflowRunDispatchInput): void {
+  assertNonBlank(input.workflowId, "Workflow id")
+  assertNonBlank(input.runId, "Workflow run id")
+  assertNonBlank(input.scheduleId, "Workflow schedule id")
+  assertNonBlank(input.source.eventId, "Workflow source event id")
+  assertNonBlank(input.correlationId, "Workflow correlation id")
+}
+
+async function assertAutomaticExecutionIdentity(
+  dependencies: WorkflowRunDispatcherDependencies,
+  input: AutomaticWorkflowRunDispatchInput,
+  runId: string
+): Promise<void> {
+  const run = await dependencies.storage.workflowRuns?.getById({
+    projectId: dependencies.id,
+    id: runId,
+  })
+  const execution = run
+    ? await dependencies.storage.executions.getById({
+        projectId: dependencies.id,
+        id: run.executionId,
+      })
+    : null
+  if (
+    !execution ||
+    execution.source.type !== input.source.type ||
+    execution.source.eventId !== input.source.eventId ||
+    execution.correlationId !== input.correlationId ||
+    execution.requestedBy !== undefined
+  ) {
+    throw new WorkflowValidationError(
+      `[Sixb] Workflow run '${runId}' already exists with different automatic provenance.`
+    )
+  }
+}
+
+function assertNonBlank(value: string, label: string): void {
+  if (!value.trim()) throw new WorkflowValidationError(`[Sixb] ${label} must not be empty.`)
+}

package/src/workflows/types.ts

@@ -4,14 +4,26 @@ import type {
   InferActionParams,
   ObjectActionDefinition,
 } from "../actions"
+import type { ActionsRuntime } from "../actions/execution"
+import type { AgentsRuntime } from "../agents/execution"
 import type { AgentDefinition } from "../agents/types"
 import type { Principal } from "../auth"
+import type { BlobsRuntime } from "../blob-storage/execution"
+import type { ConnectorRuntime } from "../connectors/execution"
+import type { DatasetsRuntime } from "../datasets/execution"
+import type { EventsRuntime } from "../events/execution"
 import type { JsonValue } from "../json"
 import type { Logger } from "../logging"
-import type { InferSchemaOrRef, ObjectRef, SchemaOrRef } from "../ontology"
-import type { Sixb } from "../runtime/sixb"
-import type { OntologySource } from "../runtime/types"
+import type { LogsRuntime } from "../logging/execution"
+import type { ObjectsRuntime } from "../objects/execution"
+import type { InferSchemaOrRef, ObjectRef, OntologySource, SchemaOrRef } from "../ontology"
+import type { PipelinesRuntime } from "../pipelines/execution"
+import type { ProjectionsRuntime } from "../projections/execution"
+import type { RulesRuntime } from "../rules/execution"
 import type { ScheduleDefinition, ScheduleDefinitionForEvent } from "../schedules"
+import type { SchedulesRuntime } from "../schedules/execution"
+import type { SyncsRuntime } from "../syncs/execution"
+import type { WorkflowsRuntime } from "./execution"
 
 type Simplify<T> = { [K in keyof T]: T[K] } & {}
 type Append<TValues extends readonly unknown[], TValue> = [...TValues, TValue]
@@ -37,10 +49,31 @@ export type DerivedWorkflowNodeKey<TId extends string> = string extends TId
 
 export interface StepRunContext<TInput extends Record<string, unknown>> {
   readonly input: TInput
-  readonly sixb: Sixb<readonly OntologySource[]>
+  readonly sixb: WorkflowRuntimeFacade
   readonly logger: Logger
 }
 
+/**
+ * Structural view of the public `Sixb` SDK used to close the recursive workflow-definition type.
+ * It is a type-level cycle break, not a separate runtime or compatibility surface.
+ */
+export interface WorkflowRuntimeFacade {
+  readonly objects: ObjectsRuntime<readonly OntologySource[]>
+  readonly actions: ActionsRuntime
+  readonly agents: AgentsRuntime
+  readonly datasets: DatasetsRuntime
+  readonly workflows: WorkflowsRuntime
+  readonly syncs: SyncsRuntime
+  readonly pipelines: PipelinesRuntime
+  readonly projections: ProjectionsRuntime
+  readonly rules: RulesRuntime
+  readonly events: EventsRuntime
+  readonly logs: LogsRuntime
+  readonly schedules: SchedulesRuntime
+  readonly connector: ConnectorRuntime
+  readonly blobs: BlobsRuntime
+}
+
 export type StepHandler<
   TInput extends Record<string, unknown>,
   TOutput extends Record<string, unknown>,
@@ -184,10 +217,8 @@ export type WorkflowTriggerDefinition = WorkflowScheduleTriggerDefinition
 /**
  * Origin of a workflow run request.
  *
- * Captured on the queued run record and emitted with `workflow.run.queued`
- * so downstream consumers can trace why a run started. Intentionally minimal
- * for now — additional sources (schedule, sync, pipeline, ...) can be added
- * when the triggers that produce them land.
+ * Emitted with `workflow.run.queued` for downstream consumers. The immutable execution record is
+ * the authoritative durable provenance; this event detail is descriptive only.
  */
 export type WorkflowRunSource =
   | { readonly type: "manual" }

package/dist/actions/runtime.d.ts

@@ -1,11 +0,0 @@
-import type { SixbRuntimeContext } from "../runtime/types";
-import type { ActionRunRecord } from "../storage";
-import { type RequestActionAndWaitInput, type RequestActionInput, type RequestActionResult, type WaitForActionRunInput } from "./request";
-export declare class ActionsRuntime {
-    private readonly runtime;
-    constructor(runtime: SixbRuntimeContext);
-    request(input: RequestActionInput): Promise<RequestActionResult>;
-    waitFor(input: WaitForActionRunInput): Promise<ActionRunRecord>;
-    requestAndWait(input: RequestActionAndWaitInput): Promise<ActionRunRecord>;
-}
-//# sourceMappingURL=runtime.d.ts.map

package/dist/actions/runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/actions/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EAGxB,KAAK,qBAAqB,EAE3B,MAAM,WAAW,CAAA;AAElB,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;gBAEhC,OAAO,EAAE,kBAAkB;IAIvC,OAAO,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAIhE,OAAO,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,eAAe,CAAC;IAI/D,cAAc,CAAC,KAAK,EAAE,yBAAyB,GAAG,OAAO,CAAC,eAAe,CAAC;CAG3E"}

package/dist/agents/runtime.d.ts

@@ -1,41 +0,0 @@
-import type { SixbRuntimeContext } from "../runtime/types";
-import type { AgentThreadRecord, ListAgentThreadsInput, ListAgentThreadsResult } from "../storage/agents";
-import { type RequestAgentRunInput, type RequestAgentRunResult } from "./request";
-import type { AgentDefinition } from "./types";
-/** The caller-supplied part of a thread listing; owner + grant filters are derived from the runtime. */
-export type ScopedListAgentThreadsInput = Omit<ListAgentThreadsInput, "projectId" | "agentIds" | "ownerPrincipal">;
-/**
- * Holds the agent definitions registered with a Sixb instance and exposes lookup + the run trigger.
- *
- * Definition lookup (`list` / `getById`) is what the worker uses to resolve a run's model (the model
- * is a non-serialisable language model, so it is never sent over the wire). `request(...)` is the
- * trigger surface, mirroring `sixb.actions.request`.
- *
- * Duplicate ids are rejected by the `Sixb` constructor before this is built.
- */
-export declare class AgentsRuntime {
-    private readonly runtime;
-    private readonly agentsById;
-    constructor(runtime: SixbRuntimeContext, agents: readonly AgentDefinition[]);
-    /** All registered agent definitions. */
-    list(): readonly AgentDefinition[];
-    /** Look up a registered agent definition by id. */
-    getById(agentId: string): AgentDefinition | null;
-    /** Trigger an agent turn: persist its queued run and user message, then dispatch the intent. */
-    request(input: RequestAgentRunInput): Promise<RequestAgentRunResult>;
-    /**
-     * Trigger an agent turn on behalf of an explicit runtime context, so scoped
-     * SDKs can enforce caller grants while reusing the registered definitions.
-     */
-    requestAs(runtime: SixbRuntimeContext, input: RequestAgentRunInput): Promise<RequestAgentRunResult>;
-    /**
-     * List threads visible to an explicit runtime. A scoped runtime is filtered to threads it owns and
-     * holds `run:agent` on (via the storage `agentIds` + `ownerPrincipal` filters); a privileged
-     * runtime sees all. Missing agent storage yields an empty page rather than throwing, so a
-     * listing on an agent-less deployment degrades gracefully.
-     */
-    listThreadsAs(runtime: SixbRuntimeContext, input?: ScopedListAgentThreadsInput): Promise<ListAgentThreadsResult>;
-    /** Read a single thread through the runtime's scope; returns null when absent or inaccessible. */
-    getThreadAs(runtime: SixbRuntimeContext, threadId: string): Promise<AgentThreadRecord | null>;
-}
-//# sourceMappingURL=runtime.d.ts.map

package/dist/agents/runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/agents/runtime.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAAE,KAAK,oBAAoB,EAAE,KAAK,qBAAqB,EAAmB,MAAM,WAAW,CAAA;AAClG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,wGAAwG;AACxG,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAC5C,qBAAqB,EACrB,WAAW,GAAG,UAAU,GAAG,gBAAgB,CAC5C,CAAA;AAkBD;;;;;;;;GAQG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsC;gBAErD,OAAO,EAAE,kBAAkB,EAAE,MAAM,EAAE,SAAS,eAAe,EAAE;IAK3E,wCAAwC;IACxC,IAAI,IAAI,SAAS,eAAe,EAAE;IAIlC,mDAAmD;IACnD,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI;IAIhD,gGAAgG;IAChG,OAAO,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAIpE;;;OAGG;IACH,SAAS,CACP,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,qBAAqB,CAAC;IAQjC;;;;;OAKG;IACG,aAAa,CACjB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,GAAE,2BAAgC,GACtC,OAAO,CAAC,sBAAsB,CAAC;IAoBlC,kGAAkG;IAC5F,WAAW,CACf,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;CAQrC"}