@intx/db 0.2.2 → 0.4.0

package/dist/model-source-resolution.js

@@ -1,8 +1,9 @@
 import { and, eq } from "drizzle-orm";
-import { InvokerModelPreferences, ModelRequirements, } from "@intx/types";
+import { InvokerModelPreferences, ModelRequirements, credentialAad, } from "@intx/types";
 import { listVisibleOfferings, } from "./catalog-resolution.js";
 import { resolveCredentialById } from "./credential-resolution.js";
-import { agent } from "./schema/agents.js";
+import { parseModelOfferingRow } from "./parse-row.js";
+import { workflowDefinition } from "./schema/workflow-definitions.js";
 function byPriority(a, b) {
     if (a.offering.priority !== b.offering.priority) {
         return a.offering.priority - b.offering.priority;
@@ -41,7 +42,7 @@ function applyPreference(candidates, preference) {
     // the rest as fallback after the named providers.
     return preference.mode === "pin" ? named : [...named, ...rest];
 }
-async function buildSource(db, tenantId, resolved) {
+async function buildSource(db, tenantId, resolved, credentialCipher) {
     const { provider, model, offering } = resolved;
     if (provider.credentialId === null) {
         // No credential reference. A wallet-backed provider is a valid catalog
@@ -60,7 +61,7 @@ async function buildSource(db, tenantId, resolved) {
     }
     // Resolve the secret through the tenant-scoped credential resolver so a
     // provider row referencing a credential outside the tenant's ancestor
-    // chain cannot leak that secret (INTR-203: the chain is the authority).
+    // chain cannot leak that secret (the chain is the authority).
     const credential = await resolveCredentialById(db, tenantId, provider.credentialId);
     if (credential === null) {
         return {
@@ -68,18 +69,84 @@ async function buildSource(db, tenantId, resolved) {
             skip: { reason: "credential_unresolved", provider: provider.name },
         };
     }
+    // Authority to use a credential through a catalog provider is ownership
+    // within the tenant hierarchy -- the same rule the tool-binding path resolves
+    // (`source: "tenant"`). `resolveCredentialById` above already proved the
+    // credential is reachable in this tenant's ancestor chain, so a tenant-owned
+    // credential (`principalId IS NULL`) is authorized here by ownership alone,
+    // with no personal grant and no role grant consulted. This runs live on every
+    // launch and rotation, so a catalog edit that adds an eligible credential is
+    // picked up without re-materializing any grant. A principal-owned credential
+    // is not usable through a shared catalog provider; fail closed.
+    if (credential.principalId !== null) {
+        return {
+            ok: false,
+            skip: { reason: "credential_unauthorized", provider: provider.name },
+        };
+    }
+    // Validate the row once at this DB-to-runtime boundary. This narrows the
+    // jsonb `quirks` from `unknown` to a `Record | null` and checks
+    // `capabilities` against the curated enum. `quirks` is spread in only when
+    // non-null so a source with no accommodations omits the key entirely
+    // (InferenceSource.quirks is present-or-absent, never null). The capability
+    // filter in resolveModelSources still reads the raw row's `capabilities`
+    // for its `.includes` check; that read-only comparison cannot be corrupted
+    // into a wrong routing decision, so it is left as-is.
+    // Decrypt the stored secret at the one point it is used. Strict: a
+    // non-ciphertext value (a row not yet re-keyed, or a write that failed to
+    // encrypt) throws rather than delivering a bad key -- fail closed. The secret
+    // rides the credential-material cell (keyed by `credentialId`), NOT the source
+    // config -- the source only references the credential by id, so no secret is
+    // inline in the pinned/persisted source.
+    const secret = await credentialCipher.decrypt(credential.secret, credentialAad(credential.id, "secret"));
+    const parsed = parseModelOfferingRow(offering);
     return {
         ok: true,
         source: {
             id: offering.id,
             provider: provider.plugin,
             baseURL: provider.baseURL,
-            apiKey: credential.secret,
+            credentialId: provider.credentialId,
             model: model.canonicalName,
-            capabilities: offering.capabilities,
+            capabilities: parsed.capabilities,
+            ...(parsed.quirks !== null ? { quirks: parsed.quirks } : {}),
+        },
+        material: {
+            credentialId: provider.credentialId,
+            providerKey: provider.plugin,
+            origin: provider.baseURL,
+            secret,
         },
     };
 }
+/**
+ * Rebuild an exact, ordered source chain from durable catalog offering ids.
+ * This is the recovery counterpart to launch-time source selection: it keeps
+ * secrets out of persisted launch specs and rechecks tenant visibility and
+ * credential ownership on every launch.
+ */
+export async function resolveSourcesByOfferingIds(db, tenantId, offeringIds, credentialCipher) {
+    const visible = await listVisibleOfferings(db, tenantId);
+    const byId = new Map(visible.map((entry) => [entry.offering.id, entry]));
+    const sources = [];
+    for (const offeringId of offeringIds) {
+        const offering = byId.get(offeringId);
+        if (offering === undefined) {
+            return { ok: false, reason: "offering_unavailable", offeringId };
+        }
+        const built = await buildSource(db, tenantId, offering, credentialCipher);
+        if (!built.ok) {
+            return {
+                ok: false,
+                reason: "offering_unavailable",
+                offeringId,
+                skip: built.skip,
+            };
+        }
+        sources.push(built.source);
+    }
+    return { ok: true, sources };
+}
 /**
  * Resolves an agent's model requirements against the tenant catalog into an
  * ordered `InferenceSource[]` for the harness.
@@ -91,13 +158,27 @@ async function buildSource(db, tenantId, resolved) {
  * offering is resolved to a credential-backed source; offerings that cannot
  * produce one are skipped. A required model that yields no source makes the
  * agent unlaunchable.
+ *
+ * A credential-backed source is emitted only when the launching tenant owns
+ * the referenced credential within its hierarchy (ownership is the authority);
+ * otherwise the offering is skipped (`credential_unauthorized`) and its secret
+ * is withheld.
  */
-export async function resolveModelSources(db, tenantId, requirements, opts) {
+export async function resolveModelSources(db, tenantId, requirements, 
+// Decrypts each resolved credential secret at its point of use in
+// `buildSource`. Required: the edge (the launch route / rotation push /
+// allocation service) owns the cipher and always supplies a real one; the
+// noop fallback for a keyless composition is resolved once at that edge
+// (`resolveCredentialCipher` in the hub app), never defaulted here.
+credentialCipher, opts) {
     if (requirements.length === 0) {
         return { ok: false, reason: "no_requirements" };
     }
     const visible = await listVisibleOfferings(db, tenantId);
     const sources = [];
+    // Dedupe material by credentialId across every requirement's chain: one
+    // credential backing several offerings is delivered once.
+    const materials = new Map();
     for (const requirement of requirements) {
         let candidates = visible
             .filter((o) => o.model.canonicalName === requirement.model)
@@ -110,10 +191,12 @@ export async function resolveModelSources(db, tenantId, requirements, opts) {
         candidates = applyPreference(candidates, opts?.invokerPreferences?.[requirement.model]);
         const skips = [];
         const modelSources = [];
+        const modelMaterials = [];
         for (const candidate of candidates) {
-            const built = await buildSource(db, tenantId, candidate);
+            const built = await buildSource(db, tenantId, candidate, credentialCipher);
             if (built.ok) {
                 modelSources.push(built.source);
+                modelMaterials.push(built.material);
             }
             else {
                 skips.push(built.skip);
@@ -128,29 +211,101 @@ export async function resolveModelSources(db, tenantId, requirements, opts) {
             };
         }
         sources.push(...modelSources);
+        for (const material of modelMaterials) {
+            if (!materials.has(material.credentialId)) {
+                materials.set(material.credentialId, material);
+            }
+        }
     }
-    return { ok: true, sources };
+    return { ok: true, sources, materials: [...materials.values()] };
+}
+/**
+ * Resolve an agent's model requirements to the credential-free
+ * `{ provider, model }` inference preferences a folded workflow definition
+ * carries on its step agent. Reuses `resolveModelSources` -- the same catalog
+ * + creator-grant resolution the instance launch path runs -- and projects its
+ * ordered sources to their `{ provider (plugin), model }` identity, dropping
+ * the credentials: a definition's inference preference is hash-only, and the
+ * credential-bearing sources are supplied per deploy on the workflow path.
+ *
+ * A requirement set that resolves to no source is a hard failure. A folded
+ * agent whose model is unresolvable is undeployable, so this raises rather
+ * than synthesizing an empty preference list that would silently strip the
+ * agent's inference. It also raises when the resolved sources are not
+ * injective on `(provider, model)` -- the projection would otherwise freeze
+ * an ambiguous preference list whose lost `offering.id` distinctions cannot be
+ * recovered after the agent's columns are dropped.
+ */
+export async function resolveInferencePreferences(db, tenantId, requirements, 
+// Required even though the result discards the credential: this reuses the
+// full `resolveModelSources` path, which decrypts each secret at its point of
+// use in `buildSource` before the `{provider, model}` projection drops it. So
+// the caller must still supply the edge's real cipher; a noop here would throw
+// the moment a tenant's secret is stored encrypted.
+credentialCipher) {
+    const resolution = await resolveModelSources(db, tenantId, requirements, credentialCipher);
+    if (!resolution.ok) {
+        throw new Error(`cannot resolve inference preferences for the folded definition: ${resolution.reason}`);
+    }
+    // The projection to `{ provider (plugin), model }` drops the `offering.id`
+    // that keys each resolved source. Two distinct offerings can share a
+    // provider plugin and canonical model -- the catalog permits two
+    // `model_provider` rows on the same plugin (uniqueness is on the provider
+    // name), each offering the same model -- so the projection is only
+    // well-defined when the resolved sources are injective on `(provider,
+    // model)`. If they collapse, the folded definition's inference preferences
+    // cannot distinguish which offering each entry meant, and once the agent's
+    // columns are dropped that distinction is unrecoverable. Refuse to
+    // synthesize an ambiguous preference list: fail loud so the collapse
+    // surfaces in the fold/materialize manifest rather than freezing silently.
+    const preferences = resolution.sources.map((source) => ({
+        provider: source.provider,
+        model: source.model,
+    }));
+    const seen = new Set();
+    for (const preference of preferences) {
+        // Join on a NUL: it cannot appear in a provider plugin or canonical model
+        // name, so the composite key is collision-free. Written as an explicit
+        // unicode escape rather than an invisible raw control byte in the source.
+        const key = `${preference.provider}\u0000${preference.model}`;
+        if (seen.has(key)) {
+            throw new Error(`cannot resolve inference preferences for the folded definition: ` +
+                `the model resolution is not injective on (provider, model) -- ` +
+                `two offerings collapse to (${preference.provider}, ${preference.model}); ` +
+                `a folded agent requires a distinguishable inference preference per source`);
+        }
+        seen.add(key);
+    }
+    return preferences;
 }
 /**
  * Resolves the ordered sources for a running instance from persisted state:
- * the agent definition's model requirements and the invoker's launch-time
- * preferences stored on the instance row. Launch, credential-rotation push,
- * and sidecar reconnect all resolve through this, so a running instance's
+ * the definition's model requirements and the invoker's launch-time
+ * preferences stored on the instance row. The credential-rotation and
+ * catalog-edit source push resolves through this, so a running instance's
  * source list is a pure function of persisted state — re-resolution
  * reproduces the launch ordering, including the invoker's reorder/restrict.
  */
-export async function resolveInstanceModelSources(db, tenantId, instance) {
-    // Scope the agent lookup to the resolving tenant, matching the launch
-    // route. A cross-tenant agentId resolves to nothing rather than
-    // contributing another tenant's model names or preferences.
-    const agentRow = await db.query.agent.findFirst({
-        where: and(eq(agent.id, instance.agentId), eq(agent.tenantId, tenantId)),
+export async function resolveInstanceModelSources(db, tenantId, instance, credentialCipher) {
+    // Resolve from the run's own definition by primary key. This is the SAME row
+    // the launch resolves its requirements from, so a rotation or catalog edit
+    // reproduces the launch's model resolution rather than drifting. Scope to the
+    // resolving tenant, matching the launch route: a definition in another tenant
+    // resolves to nothing rather than contributing another tenant's models. A
+    // definition with no creator principal cannot authorize a credential-backed
+    // source, so it fails closed like a missing definition.
+    const definitionRow = await db.query.workflowDefinition.findFirst({
+        where: and(eq(workflowDefinition.id, instance.definitionId), eq(workflowDefinition.tenantId, tenantId)),
     });
-    if (agentRow === undefined) {
+    // A credential-backed source is authorized by tenant ownership of the
+    // credential (walked in `buildSource`), not by the definition's creator, so a
+    // definition with no creator can still launch a tenant-owned inference
+    // source. Only a missing definition (or one in another tenant) fails closed.
+    if (definitionRow === undefined) {
         return { ok: false, reason: "no_requirements" };
     }
-    const requirements = agentRow.modelRequirements !== null
-        ? ModelRequirements.assert(agentRow.modelRequirements)
+    const requirements = definitionRow.modelRequirements !== null
+        ? ModelRequirements.assert(definitionRow.modelRequirements)
         : [];
     const preferences = instance.modelPreferences !== null
         ? InvokerModelPreferences.assert(instance.modelPreferences)
@@ -159,7 +314,7 @@ export async function resolveInstanceModelSources(db, tenantId, instance) {
     for (const preference of preferences) {
         invokerPreferences[preference.model] = preference.providers;
     }
-    return resolveModelSources(db, tenantId, requirements, {
+    return resolveModelSources(db, tenantId, requirements, credentialCipher, {
         invokerPreferences,
     });
 }

package/dist/parse-row.d.ts

@@ -1,52 +1,48 @@
-import type { agent, agentVersion, credential, gitToken, grant, modelOffering, modelProvider, oauthClient, offering, provider, tenant, transaction, turnPart, wallet } from "./schema/index.js";
+import type { approval, credential, gitToken, grant, modelOffering, modelProvider, oauthClient, offering, principal, principalKey, provider, signalCorrelation, tenant, transaction, turnPart, wallet, workflowDefinition, workflowDefinitionVersion, workflowRun, workflowRunDispatch, workflowRunLaunchSpec } from "./schema/index.js";
 export declare const GitTokenKindValidator: import("arktype/internal/variants/string.ts").StringType<"pat" | "svc", {}>;
-export declare function parseAgentRow(row: typeof agent.$inferSelect): {
-    contextConfig: Record<string, unknown> | null;
-    initialState: Record<string, unknown> | null;
-    modelConfig: Record<string, unknown> | null;
-    capabilities: Record<string, unknown> | null;
-    credentialRequirements: {
-        providerName: string;
-        source: "tenant" | "creator" | "invoker";
-        scopes?: string[];
-        name?: string;
+export declare function parseWorkflowDefinitionRow(row: typeof workflowDefinition.$inferSelect): {
+    status: "deployed" | "stopped";
+    grantRequirements: {
+        resource: string;
+        action: string;
+        source: "creator" | "invoker";
+        effect?: "allow" | "deny" | "ask";
+        conditions?: Record<string, unknown> | null;
     }[] | null;
     modelRequirements: {
         model: string;
-        capabilities?: ("vision" | "audio-input" | "tool-use" | "extended-thinking" | "structured-output" | "long-context" | "prompt-caching")[];
+        capabilities?: ("plain-text" | "plain-text-streaming" | "function-calling" | "function-calling-multi-turn" | "function-calling-multi-turn-streaming" | "function-calling-with-thinking" | "function-calling-with-thinking-streaming" | "vision-input" | "vision-input-streaming" | "audio-input" | "audio-input-streaming" | "video-input" | "video-input-streaming" | "document-input" | "document-input-streaming" | "image-output" | "image-output-streaming" | "code-execution" | "code-execution-streaming" | "reasoning-content" | "reasoning-content-streaming" | "grounding" | "grounding-streaming" | "files-api-reference" | "files-api-reference-streaming" | "redacted-thinking" | "redacted-thinking-streaming" | "structured-output" | "structured-output-streaming" | "long-context" | "prompt-caching")[];
         providers?: {
             mode: "prefer" | "pin";
             order: string[];
         };
     }[] | null;
-    grantRequirements: {
-        resource: string;
-        action: string;
-        source: "creator" | "invoker";
-        effect?: "allow" | "deny" | "ask";
-        conditions?: Record<string, unknown> | null;
+    credentialBindings: {
+        package: string;
+        handle: string;
+        provider: string;
+        locator: "tenant";
+        name?: string;
     }[] | null;
-    toolPackages: {
-        name: string;
-        version: string;
-    }[];
     id: string;
     name: string;
     createdAt: Date;
     updatedAt: Date;
     tenantId: string;
-    status: "deployed" | "stopped";
-    creatorPrincipalId: string;
+    creatorPrincipalId: string | null;
+    assetId: string | null;
+    wireHash: string | null;
     description: string | null;
-    systemPrompt: string | null;
     currentVersion: string;
 };
-export declare function parseAgentVersionRow(row: typeof agentVersion.$inferSelect): {
+export declare function parseWorkflowDefinitionVersionRow(row: typeof workflowDefinitionVersion.$inferSelect): {
     status: "active" | "inactive" | "failed";
     id: string;
     createdAt: Date;
-    agentId: string;
+    definitionId: string;
     version: string;
+    approvedWireHash: string | null;
+    grantSnapshot: unknown;
 };
 export declare function parseGrantRow(row: typeof grant.$inferSelect): {
     effect: "allow" | "deny" | "ask";
@@ -57,11 +53,216 @@ export declare function parseGrantRow(row: typeof grant.$inferSelect): {
     updatedAt: Date;
     expiresAt: Date | null;
     tenantId: string;
-    roleId: string | null;
     principalId: string | null;
+    roleId: string | null;
     resource: string;
     action: string;
 };
+export declare function parseApprovalRow(row: typeof approval.$inferSelect): {
+    scope: "always" | "once" | null;
+    status: "pending" | "approved" | "rejected" | "timeout" | "expired";
+    toolDefinition: Record<string, unknown>;
+    toolArguments: Record<string, unknown>;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    tenantId: string;
+    anchorRunId: string;
+    runId: string;
+    agentAddress: string;
+    correlationId: string;
+    timeoutAt: Date | null;
+    resolvedAt: Date | null;
+};
+export declare function parsePrincipalRow(row: typeof principal.$inferSelect): {
+    kind: "user" | "agent" | "workflow";
+    status: "active" | "suspended" | "invited" | "deactivated";
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    tenantId: string;
+    refId: string;
+};
+export declare function parsePrincipalKeyRow(row: typeof principalKey.$inferSelect): {
+    status: "active" | "retired";
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    principalId: string;
+    publicKey: string;
+    privateKey: string;
+};
+export declare function parseSignalCorrelationRow(row: typeof signalCorrelation.$inferSelect): {
+    kind: "approval";
+    createdAt: Date;
+    tenantId: string;
+    anchorRunId: string;
+    runId: string;
+    agentAddress: string;
+    correlationId: string;
+    resolvedAt: Date | null;
+    signalName: string;
+    signalId: string | null;
+};
+export declare function parseWorkflowRunRow(row: typeof workflowRun.$inferSelect): {
+    status: "deployed" | "failed" | "running" | "completed" | "cancelled";
+    modelPreferences: {
+        model: string;
+        providers: {
+            mode: "prefer" | "pin";
+            order: string[];
+        };
+    }[] | null;
+    id: string;
+    createdAt: Date;
+    tenantId: string;
+    principalId: string | null;
+    publicKey: string | null;
+    definitionId: string;
+    anchorRunId: string | null;
+    address: string | null;
+    sidecarId: string | null;
+    kernelId: string | null;
+    credentialRefs: import("./schema/index.js").WorkflowRunCredentialRefs | null;
+    endedAt: Date | null;
+};
+export declare function parseWorkflowRunLaunchSpecRow(row: typeof workflowRunLaunchSpec.$inferSelect): {
+    frozenApprovalBundle: {
+        source: {
+            kind: "registry";
+            registry: string;
+        } | {
+            kind: "asset";
+            assetId: string;
+            package: {
+                format: "tarball";
+            } | {
+                format: "source";
+                commitSha: string;
+                packageName?: string;
+            };
+        };
+        entry: string;
+        projection: {
+            id: string;
+            triggers: unknown[];
+            stepOrder: string[];
+            steps: {
+                [x: string]: unknown;
+            };
+            state?: Record<string, unknown>;
+            credentialBindings?: {
+                package: string;
+                handle: string;
+                provider: string;
+                locator: "tenant";
+                name?: string;
+            }[];
+            sidecarPlacement?: {
+                capabilities?: {
+                    capability: string;
+                    effect: "require" | "block";
+                }[];
+            };
+            inboundMailPolicy?: {
+                untrustedFrom?: "reject" | "admit";
+                invalid?: "reject" | "admit";
+                missing?: "reject" | "admit";
+                unknown?: "reject" | "admit";
+            };
+        };
+        closure: {
+            schemaVersion: "1";
+            topLevel: {
+                name: string;
+                version: string;
+                credentials?: {
+                    handle: string;
+                    scopes?: string[];
+                }[];
+            }[];
+            entries: {
+                name: string;
+                version: string;
+                source: {
+                    kind: "registry";
+                    registry: string;
+                    integrity: string;
+                } | {
+                    kind: "asset";
+                    assetId: string;
+                    package: {
+                        format: "tarball";
+                        path: string;
+                        integrity: string;
+                    } | {
+                        format: "source";
+                        commitSha: string;
+                        packageDir: string;
+                        treeOid: string;
+                    };
+                };
+                os?: string[];
+                cpu?: string[];
+                tarballUrl?: string;
+            }[];
+        };
+        approvedWireHash: string;
+        approvedGrants: (string | {
+            resource: string;
+            action: string;
+            source: "creator" | "invoker";
+            effect?: "allow" | "deny" | "ask";
+            conditions?: Record<string, unknown> | null;
+        })[];
+    };
+    sourceOfferingIds: string[];
+    deployContent: Record<string, unknown>;
+    toolPackagePins: {
+        name: string;
+        version: string;
+    }[] | null;
+    createdAt: Date;
+    anchorRunId: string;
+    sessionId: string;
+    schemaVersion: number;
+    deploymentDomain: string;
+    sourceAuthorityPrincipalId: string;
+    defaultSourceOfferingId: string;
+};
+export declare function parseWorkflowRunDispatchRow(row: typeof workflowRunDispatch.$inferSelect): {
+    kind: "signal" | "mail";
+    status: "failed" | "pending" | "acknowledged" | "settled";
+    stepGrants: {
+        id: string;
+        resource: string;
+        action: string;
+        effect: "allow" | "deny" | "ask";
+        origin: "role" | "system" | "creator" | "invoker";
+        conditions: {
+            [x: string]: unknown;
+        } | null;
+        expiresAt: Date | null;
+        roleId: string | null;
+        principalId: string | null;
+    }[];
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    anchorRunId: string;
+    messageId: string;
+    nextAttemptAt: Date | null;
+    failureCode: string | null;
+    failureMessage: string | null;
+    senderAddress: string | null;
+    rawMessage: Uint8Array<ArrayBufferLike>;
+    acknowledgedGeneration: number | null;
+    attemptCount: number;
+    deliveryLeaseId: string | null;
+    deliveryLeaseExpiresAt: Date | null;
+    acknowledgedAt: Date | null;
+    settledAt: Date | null;
+};
 export declare function parseOfferingRow(row: typeof offering.$inferSelect): {
     pricing: Record<string, unknown> | null;
     schema: Record<string, unknown> | null;
@@ -75,7 +276,7 @@ export declare function parseOfferingRow(row: typeof offering.$inferSelect): {
 };
 export declare function parseCredentialRow(row: typeof credential.$inferSelect): {
     type: "api_key" | "oauth_token" | "certificate" | "other";
-    status: "active" | "expired" | "revoked" | "error";
+    status: "active" | "error" | "expired" | "revoked";
     metadata: Record<string, unknown> | null;
     id: string;
     name: string;
@@ -84,8 +285,8 @@ export declare function parseCredentialRow(row: typeof credential.$inferSelect):
     expiresAt: Date | null;
     providerId: string;
     tenantId: string;
-    description: string | null;
     principalId: string | null;
+    description: string | null;
     scopes: string[] | null;
     oauthClientId: string | null;
     secret: string;
@@ -99,6 +300,7 @@ export declare function parseProviderRow(row: typeof provider.$inferSelect): {
     updatedAt: Date;
     tenantId: string;
     plugin: string;
+    apiBaseUrl: string | null;
     authorizationUrl: string | null;
     tokenUrl: string | null;
     userInfoUrl: string | null;
@@ -117,7 +319,8 @@ export declare function parseModelProviderRow(row: typeof modelProvider.$inferSe
     credentialId: string | null;
 };
 export declare function parseModelOfferingRow(row: typeof modelOffering.$inferSelect): {
-    capabilities: ("vision" | "audio-input" | "tool-use" | "extended-thinking" | "structured-output" | "long-context" | "prompt-caching")[];
+    capabilities: ("plain-text" | "plain-text-streaming" | "function-calling" | "function-calling-multi-turn" | "function-calling-multi-turn-streaming" | "function-calling-with-thinking" | "function-calling-with-thinking-streaming" | "vision-input" | "vision-input-streaming" | "audio-input" | "audio-input-streaming" | "video-input" | "video-input-streaming" | "document-input" | "document-input-streaming" | "image-output" | "image-output-streaming" | "code-execution" | "code-execution-streaming" | "reasoning-content" | "reasoning-content-streaming" | "grounding" | "grounding-streaming" | "files-api-reference" | "files-api-reference-streaming" | "redacted-thinking" | "redacted-thinking-streaming" | "structured-output" | "structured-output-streaming" | "long-context" | "prompt-caching")[];
+    quirks: Record<string, unknown> | null;
     id: string;
     createdAt: Date;
     updatedAt: Date;
@@ -129,7 +332,15 @@ export declare function parseModelOfferingRow(row: typeof modelOffering.$inferSe
     deploymentTags: string[];
 };
 export declare function parseTenantRow(row: typeof tenant.$inferSelect): {
-    config: Record<string, unknown> | null;
+    config: {
+        [x: string]: unknown;
+        sidecarPlacement?: {
+            capabilities?: {
+                capability: string;
+                effect: "require" | "block";
+            }[];
+        };
+    } | null;
     domain: string;
     id: string;
     name: string;
@@ -151,10 +362,10 @@ export declare function parseWalletRow(row: typeof wallet.$inferSelect): {
 };
 export declare function parseTransactionRow(row: typeof transaction.$inferSelect): {
     direction: "inbound" | "outbound";
-    status: "failed" | "pending" | "completed";
+    status: "failed" | "completed" | "pending";
     id: string;
     createdAt: Date;
-    agentId: string | null;
+    runId: string | null;
     currency: string;
     walletId: string;
     amount: string;