weave-typescript 0.51.2 → 0.52.0

package/dist/weavesql/weavedb/inference_provider_sql.d.ts

@@ -0,0 +1,125 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const createInferenceProviderConfigurationQuery = "-- name: CreateInferenceProviderConfiguration :one\nINSERT INTO weave.inference_provider_configuration (\n    organization_id,\n    kind,\n    name,\n    slug,\n    base_url\n) VALUES (\n    $1,\n    $2,\n    $3,\n    $4,\n    $5::text\n)\nRETURNING id, organization_id, kind, name, slug, base_url, created_at, updated_at";
+export interface CreateInferenceProviderConfigurationArgs {
+    organizationId: string;
+    kind: string;
+    name: string;
+    slug: string;
+    baseUrl: string | null;
+}
+export interface CreateInferenceProviderConfigurationRow {
+    id: string;
+    organizationId: string;
+    kind: string;
+    name: string;
+    slug: string;
+    baseUrl: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function createInferenceProviderConfiguration(client: Client, args: CreateInferenceProviderConfigurationArgs): Promise<CreateInferenceProviderConfigurationRow | null>;
+export declare const getInferenceProviderConfigurationQuery = "-- name: GetInferenceProviderConfiguration :one\nSELECT id, organization_id, kind, name, slug, base_url, created_at, updated_at FROM weave.inference_provider_configuration\nWHERE organization_id = $1\n  AND id = $2";
+export interface GetInferenceProviderConfigurationArgs {
+    organizationId: string;
+    inferenceProviderConfigurationId: string;
+}
+export interface GetInferenceProviderConfigurationRow {
+    id: string;
+    organizationId: string;
+    kind: string;
+    name: string;
+    slug: string;
+    baseUrl: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function getInferenceProviderConfiguration(client: Client, args: GetInferenceProviderConfigurationArgs): Promise<GetInferenceProviderConfigurationRow | null>;
+export declare const updateInferenceProviderConfigurationQuery = "-- name: UpdateInferenceProviderConfiguration :one\nUPDATE weave.inference_provider_configuration\nSET kind = $1,\n    name = $2,\n    slug = $3,\n    base_url = $4::text\nWHERE organization_id = $5\n  AND id = $6\nRETURNING id, organization_id, kind, name, slug, base_url, created_at, updated_at";
+export interface UpdateInferenceProviderConfigurationArgs {
+    kind: string;
+    name: string;
+    slug: string;
+    baseUrl: string | null;
+    organizationId: string;
+    inferenceProviderConfigurationId: string;
+}
+export interface UpdateInferenceProviderConfigurationRow {
+    id: string;
+    organizationId: string;
+    kind: string;
+    name: string;
+    slug: string;
+    baseUrl: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function updateInferenceProviderConfiguration(client: Client, args: UpdateInferenceProviderConfigurationArgs): Promise<UpdateInferenceProviderConfigurationRow | null>;
+export declare const deleteInferenceProviderConfigurationQuery = "-- name: DeleteInferenceProviderConfiguration :exec\nDELETE FROM weave.inference_provider_configuration\nWHERE organization_id = $1\n  AND id = $2";
+export interface DeleteInferenceProviderConfigurationArgs {
+    organizationId: string;
+    inferenceProviderConfigurationId: string;
+}
+export declare function deleteInferenceProviderConfiguration(client: Client, args: DeleteInferenceProviderConfigurationArgs): Promise<void>;
+export declare const listInferenceProviderConfigurationsQuery = "-- name: ListInferenceProviderConfigurations :many\nSELECT id, organization_id, kind, name, slug, base_url, created_at, updated_at\nFROM weave.inference_provider_configuration\nWHERE organization_id = $1\nORDER BY name ASC, id ASC\nLIMIT COALESCE($3::integer, 100)\nOFFSET COALESCE($2::integer, 0)";
+export interface ListInferenceProviderConfigurationsArgs {
+    organizationId: string;
+    pageOffset: number | null;
+    pageSize: number | null;
+}
+export interface ListInferenceProviderConfigurationsRow {
+    id: string;
+    organizationId: string;
+    kind: string;
+    name: string;
+    slug: string;
+    baseUrl: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function listInferenceProviderConfigurations(client: Client, args: ListInferenceProviderConfigurationsArgs): Promise<ListInferenceProviderConfigurationsRow[]>;
+export declare const getInferenceProviderCredentialQuery = "-- name: GetInferenceProviderCredential :one\nSELECT c.inference_provider_configuration_id, c.credential_kind, c.encrypted_credentials, c.credential_hint, c.key_id, c.last_rotated_at, c.created_at, c.updated_at\nFROM weave.inference_provider_credential c\n         JOIN weave.inference_provider_configuration p\n              ON p.id = c.inference_provider_configuration_id\nWHERE p.organization_id = $1\n  AND c.inference_provider_configuration_id = $2";
+export interface GetInferenceProviderCredentialArgs {
+    organizationId: string;
+    inferenceProviderConfigurationId: string;
+}
+export interface GetInferenceProviderCredentialRow {
+    inferenceProviderConfigurationId: string;
+    credentialKind: string;
+    encryptedCredentials: Buffer;
+    credentialHint: string;
+    keyId: string;
+    lastRotatedAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function getInferenceProviderCredential(client: Client, args: GetInferenceProviderCredentialArgs): Promise<GetInferenceProviderCredentialRow | null>;
+export declare const deleteInferenceProviderCredentialQuery = "-- name: DeleteInferenceProviderCredential :exec\nDELETE FROM weave.inference_provider_credential c\nUSING weave.inference_provider_configuration p\nWHERE p.organization_id = $1\n  AND p.id = $2\n  AND c.inference_provider_configuration_id = p.id";
+export interface DeleteInferenceProviderCredentialArgs {
+    organizationId: string;
+    inferenceProviderConfigurationId: string;
+}
+export declare function deleteInferenceProviderCredential(client: Client, args: DeleteInferenceProviderCredentialArgs): Promise<void>;
+export declare const upsertInferenceProviderCredentialQuery = "-- name: UpsertInferenceProviderCredential :one\nINSERT INTO weave.inference_provider_credential (\n    inference_provider_configuration_id,\n    credential_kind,\n    encrypted_credentials,\n    credential_hint,\n    key_id,\n    last_rotated_at\n)\nSELECT\n    p.id,\n    $1,\n    $2,\n    COALESCE($3::text, ''),\n    $4,\n    now()\nFROM weave.inference_provider_configuration p\nWHERE p.organization_id = $5\n  AND p.id = $6\nON CONFLICT (inference_provider_configuration_id)\n    DO UPDATE SET\n        credential_kind = EXCLUDED.credential_kind,\n        encrypted_credentials = EXCLUDED.encrypted_credentials,\n        credential_hint = EXCLUDED.credential_hint,\n        key_id = EXCLUDED.key_id,\n        last_rotated_at = EXCLUDED.last_rotated_at\nRETURNING inference_provider_configuration_id, credential_kind, encrypted_credentials, credential_hint, key_id, last_rotated_at, created_at, updated_at";
+export interface UpsertInferenceProviderCredentialArgs {
+    credentialKind: string;
+    encryptedCredentials: Buffer;
+    credentialHint: string | null;
+    keyId: string;
+    organizationId: string;
+    inferenceProviderConfigurationId: string;
+}
+export interface UpsertInferenceProviderCredentialRow {
+    inferenceProviderConfigurationId: string;
+    credentialKind: string;
+    encryptedCredentials: Buffer;
+    credentialHint: string;
+    keyId: string;
+    lastRotatedAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function upsertInferenceProviderCredential(client: Client, args: UpsertInferenceProviderCredentialArgs): Promise<UpsertInferenceProviderCredentialRow | null>;
+export {};

package/dist/weavesql/weavedb/inference_provider_sql.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertInferenceProviderCredentialQuery = exports.deleteInferenceProviderCredentialQuery = exports.getInferenceProviderCredentialQuery = exports.listInferenceProviderConfigurationsQuery = exports.deleteInferenceProviderConfigurationQuery = exports.updateInferenceProviderConfigurationQuery = exports.getInferenceProviderConfigurationQuery = exports.createInferenceProviderConfigurationQuery = void 0;
+exports.createInferenceProviderConfiguration = createInferenceProviderConfiguration;
+exports.getInferenceProviderConfiguration = getInferenceProviderConfiguration;
+exports.updateInferenceProviderConfiguration = updateInferenceProviderConfiguration;
+exports.deleteInferenceProviderConfiguration = deleteInferenceProviderConfiguration;
+exports.listInferenceProviderConfigurations = listInferenceProviderConfigurations;
+exports.getInferenceProviderCredential = getInferenceProviderCredential;
+exports.deleteInferenceProviderCredential = deleteInferenceProviderCredential;
+exports.upsertInferenceProviderCredential = upsertInferenceProviderCredential;
+exports.createInferenceProviderConfigurationQuery = `-- name: CreateInferenceProviderConfiguration :one
+INSERT INTO weave.inference_provider_configuration (
+    organization_id,
+    kind,
+    name,
+    slug,
+    base_url
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5::text
+)
+RETURNING id, organization_id, kind, name, slug, base_url, created_at, updated_at`;
+async function createInferenceProviderConfiguration(client, args) {
+    const result = await client.query({
+        text: exports.createInferenceProviderConfigurationQuery,
+        values: [args.organizationId, args.kind, args.name, args.slug, args.baseUrl],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        kind: row[2],
+        name: row[3],
+        slug: row[4],
+        baseUrl: row[5],
+        createdAt: row[6],
+        updatedAt: row[7]
+    };
+}
+exports.getInferenceProviderConfigurationQuery = `-- name: GetInferenceProviderConfiguration :one
+SELECT id, organization_id, kind, name, slug, base_url, created_at, updated_at FROM weave.inference_provider_configuration
+WHERE organization_id = $1
+  AND id = $2`;
+async function getInferenceProviderConfiguration(client, args) {
+    const result = await client.query({
+        text: exports.getInferenceProviderConfigurationQuery,
+        values: [args.organizationId, args.inferenceProviderConfigurationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        kind: row[2],
+        name: row[3],
+        slug: row[4],
+        baseUrl: row[5],
+        createdAt: row[6],
+        updatedAt: row[7]
+    };
+}
+exports.updateInferenceProviderConfigurationQuery = `-- name: UpdateInferenceProviderConfiguration :one
+UPDATE weave.inference_provider_configuration
+SET kind = $1,
+    name = $2,
+    slug = $3,
+    base_url = $4::text
+WHERE organization_id = $5
+  AND id = $6
+RETURNING id, organization_id, kind, name, slug, base_url, created_at, updated_at`;
+async function updateInferenceProviderConfiguration(client, args) {
+    const result = await client.query({
+        text: exports.updateInferenceProviderConfigurationQuery,
+        values: [args.kind, args.name, args.slug, args.baseUrl, args.organizationId, args.inferenceProviderConfigurationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        kind: row[2],
+        name: row[3],
+        slug: row[4],
+        baseUrl: row[5],
+        createdAt: row[6],
+        updatedAt: row[7]
+    };
+}
+exports.deleteInferenceProviderConfigurationQuery = `-- name: DeleteInferenceProviderConfiguration :exec
+DELETE FROM weave.inference_provider_configuration
+WHERE organization_id = $1
+  AND id = $2`;
+async function deleteInferenceProviderConfiguration(client, args) {
+    await client.query({
+        text: exports.deleteInferenceProviderConfigurationQuery,
+        values: [args.organizationId, args.inferenceProviderConfigurationId],
+        rowMode: "array"
+    });
+}
+exports.listInferenceProviderConfigurationsQuery = `-- name: ListInferenceProviderConfigurations :many
+SELECT id, organization_id, kind, name, slug, base_url, created_at, updated_at
+FROM weave.inference_provider_configuration
+WHERE organization_id = $1
+ORDER BY name ASC, id ASC
+LIMIT COALESCE($3::integer, 100)
+OFFSET COALESCE($2::integer, 0)`;
+async function listInferenceProviderConfigurations(client, args) {
+    const result = await client.query({
+        text: exports.listInferenceProviderConfigurationsQuery,
+        values: [args.organizationId, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            kind: row[2],
+            name: row[3],
+            slug: row[4],
+            baseUrl: row[5],
+            createdAt: row[6],
+            updatedAt: row[7]
+        };
+    });
+}
+exports.getInferenceProviderCredentialQuery = `-- name: GetInferenceProviderCredential :one
+SELECT c.inference_provider_configuration_id, c.credential_kind, c.encrypted_credentials, c.credential_hint, c.key_id, c.last_rotated_at, c.created_at, c.updated_at
+FROM weave.inference_provider_credential c
+         JOIN weave.inference_provider_configuration p
+              ON p.id = c.inference_provider_configuration_id
+WHERE p.organization_id = $1
+  AND c.inference_provider_configuration_id = $2`;
+async function getInferenceProviderCredential(client, args) {
+    const result = await client.query({
+        text: exports.getInferenceProviderCredentialQuery,
+        values: [args.organizationId, args.inferenceProviderConfigurationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        inferenceProviderConfigurationId: row[0],
+        credentialKind: row[1],
+        encryptedCredentials: row[2],
+        credentialHint: row[3],
+        keyId: row[4],
+        lastRotatedAt: row[5],
+        createdAt: row[6],
+        updatedAt: row[7]
+    };
+}
+exports.deleteInferenceProviderCredentialQuery = `-- name: DeleteInferenceProviderCredential :exec
+DELETE FROM weave.inference_provider_credential c
+USING weave.inference_provider_configuration p
+WHERE p.organization_id = $1
+  AND p.id = $2
+  AND c.inference_provider_configuration_id = p.id`;
+async function deleteInferenceProviderCredential(client, args) {
+    await client.query({
+        text: exports.deleteInferenceProviderCredentialQuery,
+        values: [args.organizationId, args.inferenceProviderConfigurationId],
+        rowMode: "array"
+    });
+}
+exports.upsertInferenceProviderCredentialQuery = `-- name: UpsertInferenceProviderCredential :one
+INSERT INTO weave.inference_provider_credential (
+    inference_provider_configuration_id,
+    credential_kind,
+    encrypted_credentials,
+    credential_hint,
+    key_id,
+    last_rotated_at
+)
+SELECT
+    p.id,
+    $1,
+    $2,
+    COALESCE($3::text, ''),
+    $4,
+    now()
+FROM weave.inference_provider_configuration p
+WHERE p.organization_id = $5
+  AND p.id = $6
+ON CONFLICT (inference_provider_configuration_id)
+    DO UPDATE SET
+        credential_kind = EXCLUDED.credential_kind,
+        encrypted_credentials = EXCLUDED.encrypted_credentials,
+        credential_hint = EXCLUDED.credential_hint,
+        key_id = EXCLUDED.key_id,
+        last_rotated_at = EXCLUDED.last_rotated_at
+RETURNING inference_provider_configuration_id, credential_kind, encrypted_credentials, credential_hint, key_id, last_rotated_at, created_at, updated_at`;
+async function upsertInferenceProviderCredential(client, args) {
+    const result = await client.query({
+        text: exports.upsertInferenceProviderCredentialQuery,
+        values: [args.credentialKind, args.encryptedCredentials, args.credentialHint, args.keyId, args.organizationId, args.inferenceProviderConfigurationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        inferenceProviderConfigurationId: row[0],
+        credentialKind: row[1],
+        encryptedCredentials: row[2],
+        credentialHint: row[3],
+        keyId: row[4],
+        lastRotatedAt: row[5],
+        createdAt: row[6],
+        updatedAt: row[7]
+    };
+}

package/dist/weavesql/weavedb/initialization_sql.d.ts

@@ -0,0 +1,15 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const lockInitializationQuery = "-- name: LockInitialization :exec\nSELECT pg_advisory_xact_lock(9135620421857066401)";
+export interface LockInitializationRow {
+    pgAdvisoryXactLock: string;
+}
+export declare function lockInitialization(client: Client): Promise<void>;
+export declare const getInitializationStateQuery = "-- name: GetInitializationState :one\nSELECT EXISTS(\n    SELECT 1\n    FROM weave.organization\n) AS initialized";
+export interface GetInitializationStateRow {
+    initialized: boolean;
+}
+export declare function getInitializationState(client: Client): Promise<GetInitializationStateRow | null>;
+export {};

package/dist/weavesql/weavedb/initialization_sql.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInitializationStateQuery = exports.lockInitializationQuery = void 0;
+exports.lockInitialization = lockInitialization;
+exports.getInitializationState = getInitializationState;
+exports.lockInitializationQuery = `-- name: LockInitialization :exec
+SELECT pg_advisory_xact_lock(9135620421857066401)`;
+async function lockInitialization(client) {
+    await client.query({
+        text: exports.lockInitializationQuery,
+        values: [],
+        rowMode: "array"
+    });
+}
+exports.getInitializationStateQuery = `-- name: GetInitializationState :one
+SELECT EXISTS(
+    SELECT 1
+    FROM weave.organization
+) AS initialized`;
+async function getInitializationState(client) {
+    const result = await client.query({
+        text: exports.getInitializationStateQuery,
+        values: [],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        initialized: row[0]
+    };
+}

package/dist/weavesql/weavedb/model_catalog_sql.d.ts

@@ -2,7 +2,7 @@ import { QueryArrayConfig, QueryArrayResult } from "pg";
 interface Client {
     query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
 }
-export declare const upsertModelCatalogModelQuery = "-- name: UpsertModelCatalogModel :one\nINSERT INTO weave.llm_model_catalog_models (\n    provider_kind,\n    model_id,\n    display_name,\n    primary_type,\n    capabilities,\n    pricing,\n    params,\n    max_input_tokens,\n    max_output_tokens,\n    release_order,\n    catalog_revision,\n    synced_at\n) VALUES (\n    $1,\n    $2,\n    $3,\n    $4,\n    $5,\n    $6,\n    $7,\n    $8,\n    $9,\n    $10,\n    $11,\n    $12\n)\nON CONFLICT (provider_kind, model_id) DO UPDATE\nSET\n    display_name = EXCLUDED.display_name,\n    primary_type = EXCLUDED.primary_type,\n    capabilities = EXCLUDED.capabilities,\n    pricing = EXCLUDED.pricing,\n    params = EXCLUDED.params,\n    max_input_tokens = EXCLUDED.max_input_tokens,\n    max_output_tokens = EXCLUDED.max_output_tokens,\n    release_order = EXCLUDED.release_order,\n    catalog_revision = EXCLUDED.catalog_revision,\n    synced_at = EXCLUDED.synced_at,\n    updated_at = now()\nRETURNING\n    provider_kind,\n    model_id,\n    display_name,\n    primary_type,\n    capabilities,\n    pricing,\n    params,\n    max_input_tokens,\n    max_output_tokens,\n    release_order,\n    catalog_revision,\n    synced_at,\n    updated_at";
+export declare const upsertModelCatalogModelQuery = "-- name: UpsertModelCatalogModel :one\nINSERT INTO weave.inference_model_catalog (\n    provider_kind,\n    model_id,\n    display_name,\n    primary_type,\n    capabilities,\n    pricing,\n    params,\n    max_input_tokens,\n    max_output_tokens,\n    release_order,\n    catalog_revision,\n    synced_at\n) VALUES (\n    $1,\n    $2,\n    $3,\n    $4,\n    $5,\n    $6,\n    $7,\n    $8,\n    $9,\n    $10,\n    $11,\n    $12\n)\nON CONFLICT (provider_kind, model_id) DO UPDATE\nSET\n    display_name = EXCLUDED.display_name,\n    primary_type = EXCLUDED.primary_type,\n    capabilities = EXCLUDED.capabilities,\n    pricing = EXCLUDED.pricing,\n    params = EXCLUDED.params,\n    max_input_tokens = EXCLUDED.max_input_tokens,\n    max_output_tokens = EXCLUDED.max_output_tokens,\n    release_order = EXCLUDED.release_order,\n    catalog_revision = EXCLUDED.catalog_revision,\n    synced_at = EXCLUDED.synced_at,\n    updated_at = now()\nRETURNING\n    provider_kind,\n    model_id,\n    display_name,\n    primary_type,\n    capabilities,\n    pricing,\n    params,\n    max_input_tokens,\n    max_output_tokens,\n    release_order,\n    catalog_revision,\n    synced_at,\n    updated_at";
 export interface UpsertModelCatalogModelArgs {
     providerKind: string;
     modelId: string;
@@ -33,16 +33,16 @@ export interface UpsertModelCatalogModelRow {
     updatedAt: Date;
 }
 export declare function upsertModelCatalogModel(client: Client, args: UpsertModelCatalogModelArgs): Promise<UpsertModelCatalogModelRow | null>;
-export declare const deleteModelCatalogModelsByProviderQuery = "-- name: DeleteModelCatalogModelsByProvider :execrows\nDELETE FROM weave.llm_model_catalog_models\nWHERE provider_kind = $1";
+export declare const deleteModelCatalogModelsByProviderQuery = "-- name: DeleteModelCatalogModelsByProvider :execrows\nDELETE FROM weave.inference_model_catalog\nWHERE provider_kind = $1";
 export interface DeleteModelCatalogModelsByProviderArgs {
     providerKind: string;
 }
-export declare const listModelCatalogProvidersQuery = "-- name: ListModelCatalogProviders :many\nSELECT DISTINCT provider_kind\nFROM weave.llm_model_catalog_models\nORDER BY provider_kind ASC";
+export declare const listModelCatalogProvidersQuery = "-- name: ListModelCatalogProviders :many\nSELECT DISTINCT provider_kind\nFROM weave.inference_model_catalog\nORDER BY provider_kind ASC";
 export interface ListModelCatalogProvidersRow {
     providerKind: string;
 }
 export declare function listModelCatalogProviders(client: Client): Promise<ListModelCatalogProvidersRow[]>;
-export declare const listModelCatalogModelsByProviderQuery = "-- name: ListModelCatalogModelsByProvider :many\nSELECT\n    provider_kind,\n    model_id,\n    display_name,\n    primary_type,\n    capabilities,\n    pricing,\n    params,\n    max_input_tokens,\n    max_output_tokens,\n    release_order,\n    catalog_revision,\n    synced_at,\n    updated_at\nFROM weave.llm_model_catalog_models\nWHERE provider_kind = $1\nORDER BY release_order ASC, model_id ASC";
+export declare const listModelCatalogModelsByProviderQuery = "-- name: ListModelCatalogModelsByProvider :many\nSELECT\n    provider_kind,\n    model_id,\n    display_name,\n    primary_type,\n    capabilities,\n    pricing,\n    params,\n    max_input_tokens,\n    max_output_tokens,\n    release_order,\n    catalog_revision,\n    synced_at,\n    updated_at\nFROM weave.inference_model_catalog\nWHERE provider_kind = $1\nORDER BY release_order ASC, model_id ASC";
 export interface ListModelCatalogModelsByProviderArgs {
     providerKind: string;
 }
@@ -62,7 +62,7 @@ export interface ListModelCatalogModelsByProviderRow {
     updatedAt: Date;
 }
 export declare function listModelCatalogModelsByProvider(client: Client, args: ListModelCatalogModelsByProviderArgs): Promise<ListModelCatalogModelsByProviderRow[]>;
-export declare const getModelCatalogModelByProviderAndIDQuery = "-- name: GetModelCatalogModelByProviderAndID :one\nSELECT\n    provider_kind,\n    model_id,\n    display_name,\n    primary_type,\n    capabilities,\n    pricing,\n    params,\n    max_input_tokens,\n    max_output_tokens,\n    release_order,\n    catalog_revision,\n    synced_at,\n    updated_at\nFROM weave.llm_model_catalog_models\nWHERE provider_kind = $1\n  AND model_id = $2";
+export declare const getModelCatalogModelByProviderAndIDQuery = "-- name: GetModelCatalogModelByProviderAndID :one\nSELECT\n    provider_kind,\n    model_id,\n    display_name,\n    primary_type,\n    capabilities,\n    pricing,\n    params,\n    max_input_tokens,\n    max_output_tokens,\n    release_order,\n    catalog_revision,\n    synced_at,\n    updated_at\nFROM weave.inference_model_catalog\nWHERE provider_kind = $1\n  AND model_id = $2";
 export interface GetModelCatalogModelByProviderAndIDArgs {
     providerKind: string;
     modelId: string;
@@ -83,7 +83,7 @@ export interface GetModelCatalogModelByProviderAndIDRow {
     updatedAt: Date;
 }
 export declare function getModelCatalogModelByProviderAndID(client: Client, args: GetModelCatalogModelByProviderAndIDArgs): Promise<GetModelCatalogModelByProviderAndIDRow | null>;
-export declare const getLatestModelCatalogRevisionQuery = "-- name: GetLatestModelCatalogRevision :one\nSELECT catalog_revision\nFROM weave.llm_model_catalog_models\nORDER BY synced_at DESC, updated_at DESC\nLIMIT 1";
+export declare const getLatestModelCatalogRevisionQuery = "-- name: GetLatestModelCatalogRevision :one\nSELECT catalog_revision\nFROM weave.inference_model_catalog\nORDER BY synced_at DESC, updated_at DESC\nLIMIT 1";
 export interface GetLatestModelCatalogRevisionRow {
     catalogRevision: string;
 }

package/dist/weavesql/weavedb/model_catalog_sql.js

@@ -7,7 +7,7 @@ exports.listModelCatalogModelsByProvider = listModelCatalogModelsByProvider;
 exports.getModelCatalogModelByProviderAndID = getModelCatalogModelByProviderAndID;
 exports.getLatestModelCatalogRevision = getLatestModelCatalogRevision;
 exports.upsertModelCatalogModelQuery = `-- name: UpsertModelCatalogModel :one
-INSERT INTO weave.llm_model_catalog_models (
+INSERT INTO weave.inference_model_catalog (
     provider_kind,
     model_id,
     display_name,
@@ -88,11 +88,11 @@ async function upsertModelCatalogModel(client, args) {
     };
 }
 exports.deleteModelCatalogModelsByProviderQuery = `-- name: DeleteModelCatalogModelsByProvider :execrows
-DELETE FROM weave.llm_model_catalog_models
+DELETE FROM weave.inference_model_catalog
 WHERE provider_kind = $1`;
 exports.listModelCatalogProvidersQuery = `-- name: ListModelCatalogProviders :many
 SELECT DISTINCT provider_kind
-FROM weave.llm_model_catalog_models
+FROM weave.inference_model_catalog
 ORDER BY provider_kind ASC`;
 async function listModelCatalogProviders(client) {
     const result = await client.query({
@@ -121,7 +121,7 @@ SELECT
     catalog_revision,
     synced_at,
     updated_at
-FROM weave.llm_model_catalog_models
+FROM weave.inference_model_catalog
 WHERE provider_kind = $1
 ORDER BY release_order ASC, model_id ASC`;
 async function listModelCatalogModelsByProvider(client, args) {
@@ -163,7 +163,7 @@ SELECT
     catalog_revision,
     synced_at,
     updated_at
-FROM weave.llm_model_catalog_models
+FROM weave.inference_model_catalog
 WHERE provider_kind = $1
   AND model_id = $2`;
 async function getModelCatalogModelByProviderAndID(client, args) {
@@ -194,7 +194,7 @@ async function getModelCatalogModelByProviderAndID(client, args) {
 }
 exports.getLatestModelCatalogRevisionQuery = `-- name: GetLatestModelCatalogRevision :one
 SELECT catalog_revision
-FROM weave.llm_model_catalog_models
+FROM weave.inference_model_catalog
 ORDER BY synced_at DESC, updated_at DESC
 LIMIT 1`;
 async function getLatestModelCatalogRevision(client) {