@sixb/core 0.1.10 → 0.1.12

package/src/shared/params/validation.ts

@@ -0,0 +1,114 @@
+import { isPlainRecord, type JsonValue } from "../../json"
+import type { SchemaOrRef, ValueType } from "../../ontology"
+import { OntologyValidationError } from "../../ontology/errors"
+import { validateSchemaOrRefValue } from "../../ontology/refs"
+import type { Schema } from "../../ontology/types"
+import { coerceSchemaValueToTyped, normalizeSchemaValue } from "../../ontology/validation"
+import type { ParamsConfig } from "./types"
+
+export interface ParamsOwner {
+  /** Lowercase singular name used in validation errors, for example `action` or `agent`. */
+  readonly kind: string
+  readonly id: string
+  /** Stable value path passed to ontology validation. Defaults to `id`. */
+  readonly path?: string
+}
+
+/** Validate declarative params and normalize them to their durable JSON representation. */
+export function normalizeParams(
+  valueTypesById: ReadonlyMap<string, ValueType>,
+  paramsConfig: ParamsConfig,
+  params: Record<string, unknown>,
+  owner: ParamsOwner
+): Record<string, JsonValue> {
+  if (!isPlainRecord(params)) {
+    throw new OntologyValidationError(`[Sixb] ${capitalize(owner.kind)} params must be an object.`)
+  }
+  const knownParamIds = new Set(Object.keys(paramsConfig))
+  const normalized: [string, JsonValue][] = []
+
+  for (const paramId of Object.keys(params)) {
+    if (!knownParamIds.has(paramId)) {
+      throw new OntologyValidationError(
+        `Unknown param '${paramId}' for ${owner.kind} '${owner.id}'`
+      )
+    }
+  }
+
+  for (const [paramId, paramDef] of Object.entries(paramsConfig)) {
+    const value = Object.hasOwn(params, paramId) ? params[paramId] : undefined
+
+    if (value === undefined) {
+      if (paramDef.required) {
+        throw new OntologyValidationError(
+          `Missing required param '${paramId}' for ${owner.kind} '${owner.id}'`
+        )
+      }
+      continue
+    }
+
+    const path = `${owner.path ?? owner.id}.${paramId}`
+    if (value === null) {
+      if (!paramDef.nullable) {
+        throw new OntologyValidationError(
+          `[Sixb] ${capitalize(owner.kind)} param ${path} cannot be null`
+        )
+      }
+      normalized.push([paramId, null])
+      continue
+    }
+
+    validateSchemaOrRefValue(paramDef.schema, value, path, valueTypesById)
+    normalized.push([
+      paramId,
+      normalizeSchemaOrRefValue(paramDef.schema, value, path, valueTypesById),
+    ])
+  }
+
+  return Object.fromEntries(normalized)
+}
+
+/** Re-hydrate normalized storage values for typed runtime consumers. */
+export function coerceParamsToTyped(
+  paramsConfig: ParamsConfig,
+  params: Record<string, unknown>,
+  valueTypesById: ReadonlyMap<string, ValueType>
+): Record<string, unknown> {
+  const coerced: Record<string, unknown> = { ...params }
+
+  for (const [paramId, paramDef] of Object.entries(paramsConfig)) {
+    if (!Object.hasOwn(params, paramId)) continue
+    const value = params[paramId]
+    if (value === undefined) continue
+
+    const schema = paramDef.schema
+    if (typeof schema === "object" && schema !== null && schema.type === "objectRef") {
+      continue
+    }
+
+    coerced[paramId] = coerceSchemaValueToTyped(schema as Schema, value, valueTypesById)
+  }
+
+  return coerced
+}
+
+function normalizeSchemaOrRefValue(
+  schema: SchemaOrRef,
+  value: unknown,
+  path: string,
+  valueTypesById: ReadonlyMap<string, ValueType>
+): JsonValue {
+  if (typeof schema === "object" && schema !== null && schema.type === "objectRef") {
+    const refValue = value as { objectTypeId: string; primaryId: string }
+    return {
+      objectTypeId: refValue.objectTypeId,
+      primaryId: refValue.primaryId,
+    }
+  }
+
+  return normalizeSchemaValue(schema as Schema, value, path, valueTypesById)
+}
+
+function capitalize(value: string): string {
+  return value.length === 0 ? value : `${value[0]?.toUpperCase()}${value.slice(1)}`
+}

package/src/storage/agents/in-memory.ts

@@ -14,7 +14,9 @@ import {
   assertCreateAgentContextCheckpointInput,
   assertCreateSubagentRunInput,
   assertSubagentRunResult,
+  snapshotAgentThreadSandboxParams,
   subagentRunMatchesCreateInput,
+  transitionAgentThreadSandbox,
 } from "./provider"
 import type {
   AgentContextCheckpointRecord,
@@ -26,6 +28,7 @@ import type {
   AgentRunStore,
   AgentStorage,
   AgentThreadRecord,
+  AgentThreadSandboxState,
   AgentThreadStore,
   AppendAgentMessageInput,
   ConfirmAgentRunExecutionOwnershipInput,
@@ -46,6 +49,7 @@ import type {
   ReclaimAgentRunInput,
   StartAgentRunInput,
   SubagentRunRecord,
+  TransitionAgentThreadSandboxInput,
 } from "./types"
 import { AGENT_RUN_FAILURE_CODES } from "./types"
 
@@ -56,7 +60,7 @@ function normalizeFailure(
 }
 
 function key(projectId: string, id: string): string {
-  return `${projectId}:${id}`
+  return JSON.stringify([projectId, id])
 }
 
 function clone<T>(value: T): T {
@@ -118,7 +122,26 @@ export interface InMemoryAgentStorageSnapshot {
 class InMemoryAgentThreadStore implements AgentThreadStore {
   constructor(private readonly state: AgentStoreState) {}
 
+  async transitionSandbox(
+    input: TransitionAgentThreadSandboxInput
+  ): Promise<AgentThreadSandboxState> {
+    const threadKey = key(input.projectId, input.id)
+    const thread = this.state.threads.get(threadKey) ?? null
+    const run =
+      input.action === "recreate"
+        ? null
+        : (this.state.runs.get(key(input.projectId, input.runId)) ?? null)
+    const sandboxState = transitionAgentThreadSandbox(thread, run, input)
+    if (!thread) throw new AgentStorageError("thread_not_found", "[Sixb] Thread not found.")
+    this.state.threads.set(threadKey, { ...thread, sandboxState: clone(sandboxState) })
+    return clone(sandboxState)
+  }
+
   async create(input: CreateAgentThreadInput): Promise<AgentThreadRecord> {
+    const sandboxParams =
+      input.sandboxParams === undefined
+        ? undefined
+        : snapshotAgentThreadSandboxParams(input.sandboxParams)
     const threadKey = key(input.projectId, input.id)
     if (this.state.threads.has(threadKey)) {
       throw new AgentStorageError(
@@ -132,6 +155,7 @@ class InMemoryAgentThreadStore implements AgentThreadStore {
       id: input.id,
       projectId: input.projectId,
       ownerPrincipal: clone(input.ownerPrincipal),
+      ...(sandboxParams === undefined ? {} : { sandboxParams }),
       ...(input.title === undefined ? {} : { title: input.title }),
       status: input.status ?? "active",
       activeRunId: null,

package/src/storage/agents/index.ts

@@ -22,6 +22,8 @@ export type {
   AgentRunStore,
   AgentStorage,
   AgentThreadRecord,
+  AgentThreadSandboxParams,
+  AgentThreadSandboxState,
   AgentThreadStatus,
   AgentThreadStore,
   AppendAgentMessageInput,
@@ -46,6 +48,7 @@ export type {
   SubagentRunRecord,
   SubagentRunResult,
   SubagentRunSpec,
+  TransitionAgentThreadSandboxInput,
 } from "./types"
 export {
   AGENT_RUN_DIAGNOSTIC_CODES,

package/src/storage/agents/provider.ts

@@ -1,6 +1,7 @@
 import { isDeepStrictEqual } from "node:util"
 import { AGENT_REASONING_LEVELS } from "../../agents/types"
 import { isFileRef } from "../../blob-storage"
+import { isJsonObject, isPlainRecord } from "../../json"
 import { isModelReasoning } from "../../models/language-model"
 import type { ExecutionRecord, ExecutionStorage } from "../executions"
 import { findAgentRunExecution } from "../executions/run-link"
@@ -10,13 +11,117 @@ import type {
   AgentMessageRecord,
   AgentRunRecord,
   AgentThreadRecord,
+  AgentThreadSandboxParams,
+  AgentThreadSandboxState,
   ConversationAgentRunSpec,
   CreateAgentContextCheckpointInput,
   CreateSubagentRunInput,
   SubagentRunRecord,
   SubagentRunResult,
+  TransitionAgentThreadSandboxInput,
 } from "./types"
 
+/** Shared state machine. Providers must lock the run, then thread, around this decision/write. */
+export function transitionAgentThreadSandbox(
+  thread: AgentThreadRecord | null,
+  run: AgentRunRecord | null,
+  input: TransitionAgentThreadSandboxInput
+): AgentThreadSandboxState {
+  const fail = (message: string): never => {
+    throw new AgentStorageError("invalid_state", `[Sixb] Sandbox ${message}`)
+  }
+  if (!thread?.sandboxParams) return fail("is not configured on this thread.")
+  if (!/^[a-zA-Z0-9-]{1,80}$/.test(input.name)) return fail("name is invalid.")
+  const state = thread.sandboxState
+  if (input.action === "recreate") {
+    if (thread.activeRunId !== null) return fail("cannot be recreated during an active run.")
+    if (!state || state.name !== input.expectedSandboxName || input.name === state.name)
+      return fail("changed; reload before recreating.")
+    if (!["busy", "blocked", "unavailable"].includes(state.status)) {
+      return fail("does not require recovery.")
+    }
+    return {
+      name: input.name,
+      status: "new",
+      initialized: false,
+      resetAt: new Date().toISOString(),
+    }
+  }
+  if (
+    run?.kind !== "conversation" ||
+    run.threadId !== thread.id ||
+    run.status !== "running" ||
+    thread.activeRunId !== run.id ||
+    run.id !== input.runId ||
+    run.execution?.token !== input.executionToken ||
+    run.execution.queueLeaseExpiresAt.getTime() <= Date.now()
+  ) {
+    throw new AgentStorageError("execution_lost", "[Sixb] Sandbox execution ownership was lost.")
+  }
+  if (input.action === "acquire") {
+    if (state && state.status !== "new" && state.status !== "ready") {
+      return fail("requires recovery; previous operations may still be in flight.")
+    }
+    if (state && state.name !== input.name) return fail("name changed.")
+    if (!/^[a-f0-9]{64}$/.test(input.sourceFingerprint))
+      return fail("source fingerprint is invalid.")
+    if (state?.sourceFingerprint && state.sourceFingerprint !== input.sourceFingerprint) {
+      return fail("source identity changed; the existing checkout was not opened.")
+    }
+    return {
+      name: input.name,
+      status: "busy",
+      initialized: state?.initialized ?? false,
+      ...(state?.resetAt ? { resetAt: state.resetAt } : {}),
+      sourceFingerprint: input.sourceFingerprint,
+      owner: { runId: input.runId, executionToken: input.executionToken },
+    }
+  }
+  if (
+    state?.status !== "busy" ||
+    state.name !== input.name ||
+    state.owner?.runId !== input.runId ||
+    state.owner.executionToken !== input.executionToken
+  ) {
+    return fail("is not owned by this execution.")
+  }
+  if (input.action === "replace") {
+    if (
+      !state.initialized ||
+      input.nextName === state.name ||
+      !/^[a-zA-Z0-9-]{1,80}$/.test(input.nextName)
+    ) {
+      return fail("replacement requires initialized state and a fresh valid name.")
+    }
+    // Only the owning worker may report confirmed loss; retain its fence across replacement.
+    return {
+      ...state,
+      name: input.nextName,
+      initialized: false,
+      resetAt: new Date().toISOString(),
+    }
+  }
+  if (input.status === "ready" && !input.initialized) return fail("initialization is incomplete.")
+  return {
+    name: state.name,
+    status: input.status,
+    initialized: input.initialized,
+    sourceFingerprint: state.sourceFingerprint,
+    ...(state.resetAt ? { resetAt: state.resetAt } : {}),
+  }
+}
+
+/** Snapshot application parameters independently of worker-owned sandbox state. */
+export function snapshotAgentThreadSandboxParams(value: unknown): AgentThreadSandboxParams {
+  if (!isPlainRecord(value) || !isJsonObject(value)) {
+    throw new AgentStorageError(
+      "invalid_input",
+      "[Sixb] Thread sandbox must contain only JSON params."
+    )
+  }
+  return structuredClone(value)
+}
+
 /** Validate the provider-neutral model selection captured for a conversational turn. */
 export function assertConversationAgentRunSpec(
   spec: ConversationAgentRunSpec,

package/src/storage/agents/types.ts

@@ -10,12 +10,63 @@ import type { LanguageModelRef } from "../../models"
 
 export type AgentThreadStatus = "active" | "archived"
 
+/** Immutable, non-secret application input. Never store resolved env or credentials here. */
+export type AgentThreadSandboxParams = Readonly<Record<string, JsonValue>>
+
+/** Worker-owned state, independent from the immutable application binding. */
+export interface AgentThreadSandboxState {
+  /** Exact name passed to the provider. Replacements always receive a fresh name. */
+  readonly name: string
+  readonly status: "new" | "busy" | "ready" | "blocked" | "unavailable"
+  readonly sourceFingerprint?: string
+  readonly initialized: boolean
+  /** Durable context boundary: local files from before this reset are no longer available. */
+  readonly resetAt?: string
+  /** Never expires automatically: a delayed provider operation must not reach a successor. */
+  readonly owner?: { readonly runId: string; readonly executionToken: string }
+}
+
+export type TransitionAgentThreadSandboxInput = {
+  readonly projectId: string
+  readonly id: string
+} & (
+  | {
+      readonly action: "acquire"
+      readonly runId: string
+      readonly executionToken: string
+      readonly name: string
+      readonly sourceFingerprint: string
+    }
+  | {
+      readonly action: "replace"
+      readonly runId: string
+      readonly executionToken: string
+      readonly name: string
+      readonly nextName: string
+    }
+  | {
+      readonly action: "settle"
+      readonly runId: string
+      readonly executionToken: string
+      readonly name: string
+      readonly status: "ready" | "blocked" | "unavailable"
+      readonly initialized: boolean
+    }
+  | {
+      readonly action: "recreate"
+      readonly expectedSandboxName: string
+      readonly name: string
+    }
+)
+
 export interface AgentThreadRecord {
   readonly id: string
   readonly projectId: string
   /** Who owns/opened the thread. Reuses the canonical auth principal (gains `agent` later for free). */
   readonly ownerPrincipal: Principal
   readonly title?: string
+  readonly sandboxParams?: AgentThreadSandboxParams
+  readonly sandboxState?: AgentThreadSandboxState
   readonly status: AgentThreadStatus
   /** Single-flight anchor: the id of the one run currently allowed to write, or `null` when idle. */
   readonly activeRunId: string | null
@@ -30,6 +81,7 @@ export interface CreateAgentThreadInput {
   readonly projectId: string
   readonly ownerPrincipal: Principal
   readonly title?: string
+  readonly sandboxParams?: AgentThreadSandboxParams
   readonly status?: AgentThreadStatus
   readonly createdAt?: Date
   readonly updatedAt?: Date
@@ -416,6 +468,8 @@ export interface CreateAgentContextCheckpointInput {
 // ── Store ───────────────────────────────────────────────────────────────────────────────────────
 
 export interface AgentThreadStore {
+  /** Atomic run-fenced transition, or explicit idle-thread recreation. */
+  transitionSandbox(input: TransitionAgentThreadSandboxInput): Promise<AgentThreadSandboxState>
   create(input: CreateAgentThreadInput): Promise<AgentThreadRecord>
   getById(params: { projectId: string; id: string }): Promise<AgentThreadRecord | null>
   list(input: ListAgentThreadsInput): Promise<ListAgentThreadsResult>

package/src/storage/ai-cost/analytics.ts

@@ -1,9 +1,4 @@
-import {
-  type AiModelCallUsage,
-  type AiModelCallUsageRecord,
-  aggregateAiModelCallUsage,
-  normalizeAiModelCallUsage,
-} from "../ai-usage"
+import { type AiModelCallUsageRecord, normalizeAiModelCallUsage } from "../ai-usage"
 import type {
   AiAccountingAgentBreakdown,
   AiAccountingAggregate,
@@ -65,6 +60,7 @@ export interface AiAccountingAggregateFragment {
   readonly modelCallCount: string
   readonly usage: {
     readonly reportedCallCount: string
+    readonly completeCallCount: string
     readonly inputTokens: AiAccountingUsageMeterFragment
     readonly outputTokens: AiAccountingUsageMeterFragment
     readonly uncachedInputTokens: AiAccountingUsageMeterFragment
@@ -358,9 +354,21 @@ export function aiAccountingBucketStart(at: Date, bucket: AiAccountingBucket): D
 function aggregateAccountingItems(
   items: readonly AiAccountingRecordSetItem[]
 ): AiAccountingAggregate {
+  const value = aggregateFragmentAccumulator()
+  value.modelCallCount = BigInt(items.length)
+  for (const item of items) {
+    const usage = normalizeAiModelCallUsage(item.usage.usage)
+    if (usage.reportingStatus !== "unavailable") value.reportedUsageCallCount += 1n
+    if (usage.reportingStatus === "complete") value.completeUsageCallCount += 1n
+    for (const field of AGGREGATE_USAGE_FIELDS) {
+      if (usage[field] === undefined) continue
+      value.usage[field].presentCallCount += 1n
+      value.usage[field].total += BigInt(usage[field])
+    }
+  }
   return {
     modelCallCount: items.length,
-    usage: aggregateAiModelCallUsage(items.map((item) => item.usage.usage)),
+    ...finishAggregateUsage(value),
     costs: aggregateCosts(items),
   }
 }
@@ -405,6 +413,7 @@ type AggregateUsageField = (typeof AGGREGATE_USAGE_FIELDS)[number]
 interface AggregateFragmentAccumulator {
   modelCallCount: bigint
   reportedUsageCallCount: bigint
+  completeUsageCallCount: bigint
   usage: Record<AggregateUsageField, { presentCallCount: bigint; total: bigint }>
   amounts: Map<string, bigint>
   ratedCallCount: bigint
@@ -416,6 +425,7 @@ function aggregateFragmentAccumulator(): AggregateFragmentAccumulator {
   return {
     modelCallCount: 0n,
     reportedUsageCallCount: 0n,
+    completeUsageCallCount: 0n,
     usage: Object.fromEntries(
       AGGREGATE_USAGE_FIELDS.map((field) => [field, { presentCallCount: 0n, total: 0n }])
     ) as AggregateFragmentAccumulator["usage"],
@@ -446,6 +456,10 @@ function appendAggregateFragment(
     fragment.usage.reportedCallCount,
     "reported usage call count"
   )
+  target.completeUsageCallCount += naturalBigInt(
+    fragment.usage.completeCallCount,
+    "complete usage call count"
+  )
   for (const field of AGGREGATE_USAGE_FIELDS) {
     const source = fragment.usage[field]
     const presentCallCount = naturalBigInt(source.presentCallCount, `${field} call count`)
@@ -473,6 +487,7 @@ function finishAggregateFragment(value: AggregateFragmentAccumulator): AiAccount
   if (
     classifiedCallCount !== value.modelCallCount ||
     value.reportedUsageCallCount > value.modelCallCount ||
+    value.completeUsageCallCount > value.reportedUsageCallCount ||
     AGGREGATE_USAGE_FIELDS.some(
       (field) => value.usage[field].presentCallCount > value.modelCallCount
     )
@@ -480,22 +495,9 @@ function finishAggregateFragment(value: AggregateFragmentAccumulator): AiAccount
     throw new TypeError("[Sixb] AI accounting SQL aggregate counts are inconsistent.")
   }
   const modelCallCount = safeAggregateNumber(value.modelCallCount, "model-call count")
-  const usageInput: Partial<Record<AggregateUsageField, number>> = {}
-  if (value.modelCallCount > 0n) {
-    for (const field of AGGREGATE_USAGE_FIELDS) {
-      const aggregate = value.usage[field]
-      if (aggregate.presentCallCount === value.modelCallCount) {
-        usageInput[field] = safeAggregateNumber(aggregate.total, field)
-      }
-    }
-  }
-  let usage: AiModelCallUsage = normalizeAiModelCallUsage(usageInput)
-  if (usage.reportingStatus === "unavailable" && value.reportedUsageCallCount > 0n) {
-    usage = { ...usage, reportingStatus: "partial" }
-  }
   return {
     modelCallCount,
-    usage,
+    ...finishAggregateUsage(value),
     costs: {
       amounts: [...value.amounts]
         .sort(([left], [right]) => left.localeCompare(right))
@@ -510,6 +512,42 @@ function finishAggregateFragment(value: AggregateFragmentAccumulator): AiAccount
   }
 }
 
+function finishAggregateUsage(
+  value: AggregateFragmentAccumulator
+): Pick<AiAccountingAggregate, "usage" | "usageCoverage"> {
+  const counts: Partial<Record<AggregateUsageField | "totalTokens", number>> = {}
+  const fieldCallCounts = {} as Record<AggregateUsageField, number>
+  for (const field of AGGREGATE_USAGE_FIELDS) {
+    const aggregate = value.usage[field]
+    fieldCallCounts[field] = safeAggregateNumber(aggregate.presentCallCount, `${field} call count`)
+    if (aggregate.presentCallCount > 0n) {
+      counts[field] = safeAggregateNumber(aggregate.total, field)
+    }
+  }
+  // Only the top-level meters contribute: cache/reasoning partitions overlap them.
+  if (counts.inputTokens !== undefined || counts.outputTokens !== undefined) {
+    counts.totalTokens = safeAggregateNumber(
+      value.usage.inputTokens.total + value.usage.outputTokens.total,
+      "totalTokens"
+    )
+  }
+  return {
+    usage: {
+      ...counts,
+      reportingStatus:
+        value.reportedUsageCallCount === 0n
+          ? "unavailable"
+          : value.completeUsageCallCount === value.modelCallCount
+            ? "complete"
+            : "partial",
+    },
+    usageCoverage: {
+      completeCallCount: safeAggregateNumber(value.completeUsageCallCount, "complete call count"),
+      fieldCallCounts,
+    },
+  }
+}
+
 function naturalBigInt(value: string, field: string): bigint {
   if (!/^(0|[1-9]\d*)$/.test(value)) {
     throw new TypeError(`[Sixb] AI accounting SQL ${field} must be a natural integer.`)

package/src/storage/ai-cost/index.ts

@@ -14,6 +14,7 @@ export type {
   AiAccountingOverview,
   AiAccountingRange,
   AiAccountingTimeBucket,
+  AiAccountingUsage,
   AiAccountingWorkflowBreakdown,
   AiBillableMeter,
   AiBillingIdentity,

package/src/storage/ai-cost/types.ts

@@ -1,4 +1,8 @@
-import type { AiModelCallUsageRecord } from "../ai-usage"
+import type {
+  AiModelCallUsageInput,
+  AiModelCallUsageRecord,
+  AiUsageReportingStatus,
+} from "../ai-usage"
 
 /** Token meters supported by deterministic local rate cards. */
 export type AiBillableMeter =
@@ -141,9 +145,22 @@ export interface ListAiModelCallAccountingInput extends AiAccountingRange {
   readonly offset?: number
 }
 
+/** Observed meter sums. Unreported meters are absent; incomplete sums are lower bounds. */
+export interface AiAccountingUsage extends AiModelCallUsageInput {
+  /** Sum of available input and output counts, including one-sided reports. */
+  readonly totalTokens?: number
+  /** Complete only when every call reports both input and output; details have separate coverage. */
+  readonly reportingStatus: AiUsageReportingStatus
+}
+
 export interface AiAccountingAggregate {
   readonly modelCallCount: number
-  readonly usage: AiModelCallUsageRecord["usage"]
+  readonly usage: AiAccountingUsage
+  readonly usageCoverage: {
+    /** Calls reporting both inputTokens and outputTokens. */
+    readonly completeCallCount: number
+    readonly fieldCallCounts: Readonly<Record<keyof AiModelCallUsageInput, number>>
+  }
   readonly costs: AiCostSummary
 }
 

package/src/storage/connector-connections/in-memory.ts

@@ -413,6 +413,20 @@ export class InMemoryConnectorConnectionStorage implements ConnectorConnectionSt
     return structuredClone(finished)
   }
 
+  async listPendingConnectionRuns(
+    input: Parameters<ConnectorConnectionStorage["listPendingConnectionRuns"]>[0]
+  ): Promise<readonly ConnectorConnectionRunRecord[]> {
+    return [...this.connectionRuns.values()]
+      .filter(
+        (run) =>
+          run.projectId === input.projectId &&
+          run.connectorId === input.connectorId &&
+          (run.status === "running" ||
+            (run.status === "waiting" && run.waitingFor === "account_selection"))
+      )
+      .map((run) => structuredClone(run))
+  }
+
   async getConnectionRun(
     input: GetConnectorConnectionRunInput
   ): Promise<ConnectorConnectionRunRecord | null> {
@@ -855,7 +869,7 @@ export class InMemoryConnectorConnectionStorage implements ConnectorConnectionSt
     input: PutConnectorConnectionInput,
     now: Date
   ): PutConnectorConnectionResult {
-    let authorization = this.authorizations.get(input.authorizationId)
+    const authorization = this.authorizations.get(input.authorizationId)
     if (
       !sameAuthorizationScope(authorization, input) ||
       !isSelectable(authorization.status) ||
@@ -863,20 +877,6 @@ export class InMemoryConnectorConnectionStorage implements ConnectorConnectionSt
     ) {
       throw authorizationConflict()
     }
-    if (
-      authorization.status === "pending_selection" &&
-      authorization.selectionExpiresAt!.getTime() <= now.getTime()
-    ) {
-      authorization = {
-        ...authorization,
-        status: "revocation_pending",
-        selectionExpiresAt: undefined,
-        revision: authorization.revision + 1,
-        updatedAt: now,
-      }
-      this.authorizations.set(authorization.id, authorization)
-      throw authorizationConflict()
-    }
     const account = authorization.accounts.find((candidate) => candidate.id === input.account.id)
     if (!account) {
       throw new ConnectorConnectionStorageError(
@@ -1078,6 +1078,7 @@ export class InMemoryConnectorConnectionStorage implements ConnectorConnectionSt
     const run = this.connectionRuns.get(runId)
     if (!run || (run.status !== "waiting" && run.status !== "running")) return run
 
+    if (run.status === "waiting" && run.waitingFor === "account_selection") return run
     const now = this.now()
     if (run.expiresAt.getTime() > now.getTime()) return run
 
@@ -1086,9 +1087,6 @@ export class InMemoryConnectorConnectionStorage implements ConnectorConnectionSt
       if (attempt) this.attempts.delete(attempt.id)
     }
     if (run.status === "waiting") {
-      if (run.kind === "connect" && run.waitingFor === "account_selection") {
-        this.markPendingAuthorizationForCleanup(run.connectorId, run.authorizationId, now)
-      }
       const expired = expireConnectionRun(run, now)
       this.connectionRuns.set(run.id, expired)
       return expired

package/src/storage/connector-connections/provider/connections.ts

@@ -165,7 +165,7 @@ export class DurableConnectorConnections extends ConnectorConnectionOperations {
     input: PutConnectorConnectionInput,
     now: Date
   ): Promise<PutConnectorConnectionResult | CommittedConnectorConnectionError> {
-    let authorization = await persistence.getAuthorization(input.authorizationId)
+    const authorization = await persistence.getAuthorization(input.authorizationId)
     if (
       !authorization ||
       !isSelectable(authorization.status) ||
@@ -173,20 +173,6 @@ export class DurableConnectorConnections extends ConnectorConnectionOperations {
     ) {
       throw authorizationConflict()
     }
-    if (
-      authorization.status === "pending_selection" &&
-      authorization.selectionExpiresAt!.getTime() <= now.getTime()
-    ) {
-      authorization = {
-        ...authorization,
-        status: "revocation_pending",
-        selectionExpiresAt: undefined,
-        revision: authorization.revision + 1,
-        updatedAt: now,
-      }
-      await persistence.updateAuthorization(authorization)
-      return { error: authorizationConflict() }
-    }
     const account = authorization.accounts.find((candidate) => candidate.id === input.account.id)
     if (!account) {
       throw new ConnectorConnectionStorageError(