@intx/db 0.1.2 → 0.2.2

package/dist/model-source-resolution.js

@@ -0,0 +1,165 @@
+import { and, eq } from "drizzle-orm";
+import { InvokerModelPreferences, ModelRequirements, } from "@intx/types";
+import { listVisibleOfferings, } from "./catalog-resolution.js";
+import { resolveCredentialById } from "./credential-resolution.js";
+import { agent } from "./schema/agents.js";
+function byPriority(a, b) {
+    if (a.offering.priority !== b.offering.priority) {
+        return a.offering.priority - b.offering.priority;
+    }
+    // Deterministic tiebreak so the head/defaultSource never flaps across
+    // resolutions. Equal-priority load balancing is future work.
+    return a.offering.id < b.offering.id ? -1 : 1;
+}
+/**
+ * Applies a provider preference over an already-priority-sorted candidate
+ * list. `pin` restricts to the named providers (ordered by the preference);
+ * `prefer` fronts the named providers in preference order and keeps the rest
+ * as fallback. With no preference the priority order stands.
+ */
+function applyPreference(candidates, preference) {
+    if (preference === undefined)
+        return candidates;
+    const rank = new Map(preference.order.map((name, i) => [name, i]));
+    // Partition by whether the preference names the provider, capturing the
+    // rank as we go. `ranked` only ever holds named providers, so the sort
+    // reads a concrete rank and never needs a fallback for a missing one.
+    const ranked = [];
+    const rest = [];
+    for (const offering of candidates) {
+        const position = rank.get(offering.provider.name);
+        if (position === undefined) {
+            rest.push(offering);
+        }
+        else {
+            ranked.push({ offering, rank: position });
+        }
+    }
+    ranked.sort((a, b) => a.rank - b.rank);
+    const named = ranked.map((entry) => entry.offering);
+    // `pin` drops every provider the preference did not name; `prefer` keeps
+    // the rest as fallback after the named providers.
+    return preference.mode === "pin" ? named : [...named, ...rest];
+}
+async function buildSource(db, tenantId, resolved) {
+    const { provider, model, offering } = resolved;
+    if (provider.credentialId === null) {
+        // No credential reference. A wallet-backed provider is a valid catalog
+        // row but not launchable in this credential-backed-only release;
+        // anything else is a misconfigured row.
+        if (provider.walletId !== null) {
+            return {
+                ok: false,
+                skip: { reason: "wallet_backed", provider: provider.name },
+            };
+        }
+        return {
+            ok: false,
+            skip: { reason: "provider_misconfigured", provider: provider.name },
+        };
+    }
+    // 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).
+    const credential = await resolveCredentialById(db, tenantId, provider.credentialId);
+    if (credential === null) {
+        return {
+            ok: false,
+            skip: { reason: "credential_unresolved", provider: provider.name },
+        };
+    }
+    return {
+        ok: true,
+        source: {
+            id: offering.id,
+            provider: provider.plugin,
+            baseURL: provider.baseURL,
+            apiKey: credential.secret,
+            model: model.canonicalName,
+            capabilities: offering.capabilities,
+        },
+    };
+}
+/**
+ * Resolves an agent's model requirements against the tenant catalog into an
+ * ordered `InferenceSource[]` for the harness.
+ *
+ * For each requirement, the tenant-visible offerings for the named model are
+ * filtered by the required capabilities, ordered by catalog priority, then
+ * reordered by the creator preference and finally the invoker preference
+ * (invoker preferences key on the canonical model name). Each surviving
+ * 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.
+ */
+export async function resolveModelSources(db, tenantId, requirements, opts) {
+    if (requirements.length === 0) {
+        return { ok: false, reason: "no_requirements" };
+    }
+    const visible = await listVisibleOfferings(db, tenantId);
+    const sources = [];
+    for (const requirement of requirements) {
+        let candidates = visible
+            .filter((o) => o.model.canonicalName === requirement.model)
+            .sort(byPriority);
+        if (requirement.capabilities && requirement.capabilities.length > 0) {
+            const required = requirement.capabilities;
+            candidates = candidates.filter((o) => required.every((c) => o.offering.capabilities.includes(c)));
+        }
+        candidates = applyPreference(candidates, requirement.providers);
+        candidates = applyPreference(candidates, opts?.invokerPreferences?.[requirement.model]);
+        const skips = [];
+        const modelSources = [];
+        for (const candidate of candidates) {
+            const built = await buildSource(db, tenantId, candidate);
+            if (built.ok) {
+                modelSources.push(built.source);
+            }
+            else {
+                skips.push(built.skip);
+            }
+        }
+        if (modelSources.length === 0) {
+            return {
+                ok: false,
+                reason: "model_unavailable",
+                model: requirement.model,
+                skips,
+            };
+        }
+        sources.push(...modelSources);
+    }
+    return { ok: true, sources };
+}
+/**
+ * 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
+ * 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)),
+    });
+    if (agentRow === undefined) {
+        return { ok: false, reason: "no_requirements" };
+    }
+    const requirements = agentRow.modelRequirements !== null
+        ? ModelRequirements.assert(agentRow.modelRequirements)
+        : [];
+    const preferences = instance.modelPreferences !== null
+        ? InvokerModelPreferences.assert(instance.modelPreferences)
+        : [];
+    const invokerPreferences = {};
+    for (const preference of preferences) {
+        invokerPreferences[preference.model] = preference.providers;
+    }
+    return resolveModelSources(db, tenantId, requirements, {
+        invokerPreferences,
+    });
+}

package/dist/parse-row.d.ts

@@ -0,0 +1,193 @@
+import type { agent, agentVersion, credential, gitToken, grant, modelOffering, modelProvider, oauthClient, offering, provider, tenant, transaction, turnPart, wallet } 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;
+    }[] | null;
+    modelRequirements: {
+        model: string;
+        capabilities?: ("vision" | "audio-input" | "tool-use" | "extended-thinking" | "structured-output" | "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;
+    }[] | null;
+    toolPackages: {
+        name: string;
+        version: string;
+    }[];
+    id: string;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+    tenantId: string;
+    status: "deployed" | "stopped";
+    creatorPrincipalId: string;
+    description: string | null;
+    systemPrompt: string | null;
+    currentVersion: string;
+};
+export declare function parseAgentVersionRow(row: typeof agentVersion.$inferSelect): {
+    status: "active" | "inactive" | "failed";
+    id: string;
+    createdAt: Date;
+    agentId: string;
+    version: string;
+};
+export declare function parseGrantRow(row: typeof grant.$inferSelect): {
+    effect: "allow" | "deny" | "ask";
+    origin: "role" | "system" | "creator" | "invoker";
+    conditions: Record<string, unknown> | null;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    expiresAt: Date | null;
+    tenantId: string;
+    roleId: string | null;
+    principalId: string | null;
+    resource: string;
+    action: string;
+};
+export declare function parseOfferingRow(row: typeof offering.$inferSelect): {
+    pricing: Record<string, unknown> | null;
+    schema: Record<string, unknown> | null;
+    id: string;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+    tenantId: string;
+    description: string | null;
+    agentId: string;
+};
+export declare function parseCredentialRow(row: typeof credential.$inferSelect): {
+    type: "api_key" | "oauth_token" | "certificate" | "other";
+    status: "active" | "expired" | "revoked" | "error";
+    metadata: Record<string, unknown> | null;
+    id: string;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+    expiresAt: Date | null;
+    providerId: string;
+    tenantId: string;
+    description: string | null;
+    principalId: string | null;
+    scopes: string[] | null;
+    oauthClientId: string | null;
+    secret: string;
+    refreshSecret: string | null;
+};
+export declare function parseProviderRow(row: typeof provider.$inferSelect): {
+    metadata: Record<string, unknown> | null;
+    id: string;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+    tenantId: string;
+    plugin: string;
+    authorizationUrl: string | null;
+    tokenUrl: string | null;
+    userInfoUrl: string | null;
+    scopes: string[] | null;
+};
+export declare function parseModelProviderRow(row: typeof modelProvider.$inferSelect): {
+    plugin: "anthropic" | "openai" | "openai-compatible" | "google-genai";
+    id: string;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+    tenantId: string;
+    walletId: string | null;
+    disabled: boolean;
+    baseURL: string;
+    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")[];
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    providerId: string;
+    tenantId: string;
+    disabled: boolean;
+    modelId: string;
+    priority: number;
+    deploymentTags: string[];
+};
+export declare function parseTenantRow(row: typeof tenant.$inferSelect): {
+    config: Record<string, unknown> | null;
+    domain: string;
+    id: string;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+    slug: string;
+    parentId: string | null;
+};
+export declare function parseWalletRow(row: typeof wallet.$inferSelect): {
+    backendType: "crypto" | "fiat" | "credits";
+    config: Record<string, unknown> | null;
+    id: string;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+    tenantId: string;
+    currency: string;
+    balance: string;
+};
+export declare function parseTransactionRow(row: typeof transaction.$inferSelect): {
+    direction: "inbound" | "outbound";
+    status: "failed" | "pending" | "completed";
+    id: string;
+    createdAt: Date;
+    agentId: string | null;
+    currency: string;
+    walletId: string;
+    amount: string;
+    recipientId: string | null;
+    senderId: string | null;
+    requestId: string | null;
+};
+export declare function parseOAuthClientRow(row: typeof oauthClient.$inferSelect): {
+    metadata: Record<string, unknown> | null;
+    id: string;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+    providerId: string;
+    tenantId: string;
+    clientId: string;
+    clientSecret: string;
+    redirectUris: string[] | null;
+    defaultScopes: string[] | null;
+};
+export declare function parseGitTokenRow(row: typeof gitToken.$inferSelect): {
+    kind: "pat" | "svc";
+    actions: ("init" | "writeTree" | "receivePack" | "createPack" | "resolveRef")[];
+    id: string;
+    name: string;
+    createdAt: Date;
+    userId: string;
+    expiresAt: Date;
+    tenantId: string | null;
+    principalId: string | null;
+    resource: string;
+    tokenHashSha256: Uint8Array<ArrayBufferLike>;
+    refPattern: string;
+    revokedAt: Date | null;
+};
+export declare function parseTurnPartType(partType: string): (typeof turnPart.$inferInsert)["type"];

package/dist/parse-row.js

@@ -0,0 +1,141 @@
+import { type } from "arktype";
+import { Capability, CredentialRequirement, GrantRequirement, grantEffects, grantOrigins, ModelProviderPlugin, ModelRequirements, } from "@intx/types";
+import { RepoAction } from "@intx/types/sidecar";
+import { ToolPackagePinArray } from "@intx/types/tool-packages";
+const JSONObject = type("Record<string, unknown>");
+const GrantEffectValidator = type.enumerated(...grantEffects);
+const GrantOriginValidator = type.enumerated(...grantOrigins);
+const agentVersionStatuses = ["active", "inactive", "failed"];
+const AgentVersionStatusValidator = type.enumerated(...agentVersionStatuses);
+const credentialTypes = [
+    "api_key",
+    "oauth_token",
+    "certificate",
+    "other",
+];
+const CredentialTypeValidator = type.enumerated(...credentialTypes);
+const credentialStatuses = ["active", "expired", "revoked", "error"];
+const CredentialStatusValidator = type.enumerated(...credentialStatuses);
+const walletBackendTypes = ["crypto", "fiat", "credits"];
+const WalletBackendTypeValidator = type.enumerated(...walletBackendTypes);
+const transactionDirections = ["inbound", "outbound"];
+const TransactionDirectionValidator = type.enumerated(...transactionDirections);
+const transactionStatuses = ["pending", "completed", "failed"];
+const TransactionStatusValidator = type.enumerated(...transactionStatuses);
+const gitTokenKinds = ["pat", "svc"];
+export const GitTokenKindValidator = type.enumerated(...gitTokenKinds);
+const turnPartTypes = [
+    "text",
+    "reasoning",
+    "tool",
+    "file",
+    "error",
+    "refusal",
+    "step-start",
+    "step-finish",
+    "snapshot",
+    "patch",
+];
+const TurnPartTypeValidator = type.enumerated(...turnPartTypes);
+export function parseAgentRow(row) {
+    return {
+        ...row,
+        contextConfig: row.contextConfig !== null ? JSONObject.assert(row.contextConfig) : null,
+        initialState: row.initialState !== null ? JSONObject.assert(row.initialState) : null,
+        modelConfig: row.modelConfig !== null ? JSONObject.assert(row.modelConfig) : null,
+        capabilities: row.capabilities !== null ? JSONObject.assert(row.capabilities) : null,
+        credentialRequirements: row.credentialRequirements !== null
+            ? CredentialRequirement.array().assert(row.credentialRequirements)
+            : null,
+        modelRequirements: row.modelRequirements !== null
+            ? ModelRequirements.assert(row.modelRequirements)
+            : null,
+        grantRequirements: row.grantRequirements !== null
+            ? GrantRequirement.array().assert(row.grantRequirements)
+            : null,
+        toolPackages: ToolPackagePinArray.assert(row.toolPackages),
+    };
+}
+export function parseAgentVersionRow(row) {
+    return {
+        ...row,
+        status: AgentVersionStatusValidator.assert(row.status),
+    };
+}
+export function parseGrantRow(row) {
+    return {
+        ...row,
+        effect: GrantEffectValidator.assert(row.effect),
+        origin: GrantOriginValidator.assert(row.origin),
+        conditions: row.conditions !== null ? JSONObject.assert(row.conditions) : null,
+    };
+}
+export function parseOfferingRow(row) {
+    return {
+        ...row,
+        pricing: row.pricing !== null ? JSONObject.assert(row.pricing) : null,
+        schema: row.schema !== null ? JSONObject.assert(row.schema) : null,
+    };
+}
+export function parseCredentialRow(row) {
+    return {
+        ...row,
+        type: CredentialTypeValidator.assert(row.type),
+        status: CredentialStatusValidator.assert(row.status),
+        metadata: row.metadata !== null ? JSONObject.assert(row.metadata) : null,
+    };
+}
+export function parseProviderRow(row) {
+    return {
+        ...row,
+        metadata: row.metadata !== null ? JSONObject.assert(row.metadata) : null,
+    };
+}
+export function parseModelProviderRow(row) {
+    return {
+        ...row,
+        plugin: ModelProviderPlugin.assert(row.plugin),
+    };
+}
+export function parseModelOfferingRow(row) {
+    return {
+        ...row,
+        capabilities: Capability.array().assert(row.capabilities),
+    };
+}
+export function parseTenantRow(row) {
+    return {
+        ...row,
+        config: row.config !== null ? JSONObject.assert(row.config) : null,
+    };
+}
+export function parseWalletRow(row) {
+    return {
+        ...row,
+        backendType: WalletBackendTypeValidator.assert(row.backendType),
+        config: row.config !== null ? JSONObject.assert(row.config) : null,
+    };
+}
+export function parseTransactionRow(row) {
+    return {
+        ...row,
+        direction: TransactionDirectionValidator.assert(row.direction),
+        status: TransactionStatusValidator.assert(row.status),
+    };
+}
+export function parseOAuthClientRow(row) {
+    return {
+        ...row,
+        metadata: row.metadata !== null ? JSONObject.assert(row.metadata) : null,
+    };
+}
+export function parseGitTokenRow(row) {
+    return {
+        ...row,
+        kind: GitTokenKindValidator.assert(row.kind),
+        actions: RepoAction.array().assert(row.actions),
+    };
+}
+export function parseTurnPartType(partType) {
+    return TurnPartTypeValidator.assert(partType);
+}

package/dist/pg-error.d.ts

@@ -0,0 +1,3 @@
+export declare const PG_UNIQUE_VIOLATION = "23505";
+export declare const PG_FOREIGN_KEY_VIOLATION = "23503";
+export declare function pgErrorCode(err: unknown): string | undefined;

package/dist/pg-error.js

@@ -0,0 +1,19 @@
+import { hasCode } from "@intx/types";
+// Postgres SQLSTATE codes. https://www.postgresql.org/docs/current/errcodes-appendix.html
+export const PG_UNIQUE_VIOLATION = "23505";
+export const PG_FOREIGN_KEY_VIOLATION = "23503";
+// Extract a Postgres SQLSTATE from an error that a driver or ORM may have
+// wrapped. postgres-js sets the code on the error it throws; Drizzle
+// re-wraps that as the `cause` of a DrizzleQueryError, so the code can sit
+// one or more levels down the cause chain. Walk the chain (depth-bounded so
+// a self-referential cause cannot loop) and return the first code found.
+export function pgErrorCode(err) {
+    let cur = err;
+    for (let depth = 0; cur != null && depth < 8; depth++) {
+        if (hasCode(cur)) {
+            return cur.code;
+        }
+        cur = cur.cause;
+    }
+    return undefined;
+}

package/dist/pricing.d.ts

@@ -0,0 +1,15 @@
+import type { modelPricing } from "./schema/catalog.js";
+export type ModelPricingRow = typeof modelPricing.$inferSelect;
+/**
+ * Selects the active pricing row per currency from an offering's append-only
+ * price history. For each currency, the active row is the one with the
+ * greatest `effectiveFrom` that is at or before `asOf`; rows dated after
+ * `asOf` are not yet in effect. The `(offeringId, currency, effectiveFrom)`
+ * uniqueness on the table guarantees no ties, so the selection is
+ * unambiguous.
+ *
+ * Pure: `asOf` is a parameter, never read from the clock, so the same
+ * function serves discovery (asOf = now) and historical cost attribution
+ * (asOf = the call's billing timestamp).
+ */
+export declare function resolveActivePrice(rows: ModelPricingRow[], asOf: Date): ModelPricingRow[];

package/dist/pricing.js

@@ -0,0 +1,24 @@
+/**
+ * Selects the active pricing row per currency from an offering's append-only
+ * price history. For each currency, the active row is the one with the
+ * greatest `effectiveFrom` that is at or before `asOf`; rows dated after
+ * `asOf` are not yet in effect. The `(offeringId, currency, effectiveFrom)`
+ * uniqueness on the table guarantees no ties, so the selection is
+ * unambiguous.
+ *
+ * Pure: `asOf` is a parameter, never read from the clock, so the same
+ * function serves discovery (asOf = now) and historical cost attribution
+ * (asOf = the call's billing timestamp).
+ */
+export function resolveActivePrice(rows, asOf) {
+    const byCurrency = new Map();
+    for (const row of rows) {
+        if (row.effectiveFrom > asOf)
+            continue;
+        const current = byCurrency.get(row.currency);
+        if (current === undefined || row.effectiveFrom > current.effectiveFrom) {
+            byCurrency.set(row.currency, row);
+        }
+    }
+    return Array.from(byCurrency.values());
+}

package/dist/schema/agent-assets.d.ts

@@ -0,0 +1,109 @@
+export declare const agentAsset: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "agent_asset";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "agent_asset";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        agentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_id";
+            tableName: "agent_asset";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        assetId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "asset_id";
+            tableName: "agent_asset";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ref: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ref";
+            tableName: "agent_asset";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        accessMode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "access_mode";
+            tableName: "agent_asset";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "agent_asset";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/schema/agent-assets.js

@@ -0,0 +1,15 @@
+import { pgTable, text, timestamp, unique } from "drizzle-orm/pg-core";
+import { agent } from "./agents.js";
+import { asset } from "./assets.js";
+export const agentAsset = pgTable("agent_asset", {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id")
+        .notNull()
+        .references(() => agent.id, { onDelete: "cascade" }),
+    assetId: text("asset_id")
+        .notNull()
+        .references(() => asset.id, { onDelete: "cascade" }),
+    ref: text("ref").notNull(),
+    accessMode: text("access_mode").notNull().default("read-only"),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+}, (t) => [unique("agent_asset_agent_asset").on(t.agentId, t.assetId)]);