@axiom-lattice/local-stores 3.1.21 → 3.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/local-stores",
-  "version": "3.1.21",
+  "version": "3.1.22",
   "description": "Local SQLite-based stores for Axiom Lattice framework",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -25,8 +25,8 @@
     "@types/sql.js": "^1.4.11",
     "sql.js": "^1.14.1",
     "uuid": "^14.0.1",
-    "@axiom-lattice/core": "6.0.0",
-    "@axiom-lattice/protocols": "4.5.0"
+    "@axiom-lattice/core": "6.1.0",
+    "@axiom-lattice/protocols": "4.6.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/createLocalStoreConfig.ts

@@ -32,6 +32,7 @@ import { LocalDatabaseConfigStore } from "./stores/LocalDatabaseConfigStore";
 import { LocalConnectionStore } from "./stores/LocalConnectionStore";
 import { LocalMetricsServerConfigStore } from "./stores/LocalMetricsServerConfigStore";
 import { LocalMcpServerConfigStore } from "./stores/LocalMcpServerConfigStore";
+import { LocalModelProviderStore } from "./stores/LocalModelProviderStore";
 import { LocalWorkflowTrackingStore } from "./stores/LocalWorkflowTrackingStore";
 import { LocalEvalStore } from "./stores/LocalEvalStore";
 import { LocalChannelBindingStore } from "./stores/LocalChannelBindingStore";
@@ -84,6 +85,7 @@ export async function createLocalStoreConfig(options: LocalStoreConfigOptions =
     connection: new LocalConnectionStore(db),
     metrics: new LocalMetricsServerConfigStore(db),
     mcp: new LocalMcpServerConfigStore(db),
+    modelProvider: new LocalModelProviderStore(db),
     workflowTracking: new LocalWorkflowTrackingStore(db),
     eval: new LocalEvalStore(db),
     channelBinding: new LocalChannelBindingStore(db),

package/src/index.ts

@@ -43,6 +43,7 @@ export { LocalDatabaseConfigStore } from "./stores/LocalDatabaseConfigStore";
 export { LocalConnectionStore } from "./stores/LocalConnectionStore";
 export { LocalMetricsServerConfigStore } from "./stores/LocalMetricsServerConfigStore";
 export { LocalMcpServerConfigStore } from "./stores/LocalMcpServerConfigStore";
+export { LocalModelProviderStore } from "./stores/LocalModelProviderStore";
 export { LocalWorkflowTrackingStore } from "./stores/LocalWorkflowTrackingStore";
 export { LocalEvalStore } from "./stores/LocalEvalStore";
 export { LocalChannelBindingStore } from "./stores/LocalChannelBindingStore";

package/src/stores/LocalModelProviderStore.ts

@@ -0,0 +1,506 @@
+/**
+ * Local SQLite implementation of ModelProviderStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  ModelProviderStore,
+  ModelProviderEntry,
+  ModelProviderModelEntry,
+  ModelProviderStatus,
+  ModelProviderWireProtocol,
+  ModelProviderApiStyle,
+  ModelProviderLlmProvider,
+  CreateModelProviderRequest,
+  UpdateModelProviderRequest,
+  ProviderModelInput,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+import { encrypt, decrypt } from "@axiom-lattice/core";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_model_providers (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  display_name TEXT,
+  protocol TEXT NOT NULL,
+  api_style TEXT NOT NULL DEFAULT 'chat-completions',
+  llm_provider TEXT NOT NULL,
+  base_url TEXT NOT NULL,
+  api_key_enc TEXT,
+  api_key_hint TEXT,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  status TEXT NOT NULL DEFAULT 'unknown',
+  last_error TEXT,
+  last_discovered_at TEXT,
+  created_by TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_lt_model_providers_name
+  ON lt_model_providers(tenant_id, name);
+
+CREATE TABLE IF NOT EXISTS lt_model_provider_models (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  provider_id TEXT NOT NULL,
+  model_id TEXT NOT NULL,
+  display_name TEXT,
+  owned_by TEXT,
+  upstream_created TEXT,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  stale INTEGER NOT NULL DEFAULT 0,
+  raw TEXT,
+  discovered_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, provider_id, model_id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_model_provider_models_tenant
+  ON lt_model_provider_models(tenant_id, model_id);
+`;
+
+interface ProviderRow {
+  id: string;
+  tenant_id: string;
+  name: string;
+  display_name: string | null;
+  protocol: string;
+  api_style: string;
+  llm_provider: string;
+  base_url: string;
+  api_key_enc: string | null;
+  api_key_hint: string | null;
+  enabled: number;
+  status: string;
+  last_error: string | null;
+  last_discovered_at: string | null;
+  created_by: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+interface ModelRow {
+  id: string;
+  tenant_id: string;
+  provider_id: string;
+  model_id: string;
+  display_name: string | null;
+  owned_by: string | null;
+  upstream_created: string | null;
+  enabled: number;
+  stale: number;
+  discovered_at: string;
+}
+
+/**
+ * SQLite implementation of ModelProviderStore.
+ *
+ * Mirrors the PostgreSQL store's semantics: tenant-scoped, API keys encrypted
+ * at rest, and `enabled` preserved across a re-discovery.
+ */
+export class LocalModelProviderStore implements ModelProviderStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+    // `CREATE TABLE IF NOT EXISTS` cannot add a column to a table that already
+    // exists, and this one gained `api_style` after it shipped — the same gap
+    // the PostgreSQL path needed v183 for.
+    this.ensureColumn(
+      "lt_model_providers",
+      "api_style",
+      "api_style TEXT NOT NULL DEFAULT 'chat-completions'"
+    );
+    this.ensureColumn(
+      "lt_model_provider_models",
+      "stale",
+      "stale INTEGER NOT NULL DEFAULT 0"
+    );
+  }
+
+  /** Add a column if it does not exist (SQLite version compatible). */
+  private ensureColumn(table: string, column: string, ddl: string): void {
+    const cols = this.db
+      .prepare(`PRAGMA table_info(${table})`)
+      .all() as unknown as Array<{ name: string }>;
+
+    if (!cols.some((c) => c.name === column)) {
+      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl}`);
+    }
+  }
+
+  async listProviders(tenantId: string): Promise<ModelProviderEntry[]> {
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM lt_model_providers WHERE tenant_id = ? ORDER BY created_at DESC`
+      )
+      .all(tenantId) as unknown as ProviderRow[];
+    return rows.map((row) => mapRowToEntry(row));
+  }
+
+  async getProviderById(
+    tenantId: string,
+    id: string
+  ): Promise<ModelProviderEntry | null> {
+    const row = this.db
+      .prepare(
+        `SELECT * FROM lt_model_providers WHERE tenant_id = ? AND id = ?`
+      )
+      .get(tenantId, id) as unknown as ProviderRow | undefined;
+    return row ? mapRowToEntry(row) : null;
+  }
+
+  async getProviderByName(
+    tenantId: string,
+    name: string
+  ): Promise<ModelProviderEntry | null> {
+    const row = this.db
+      .prepare(
+        `SELECT * FROM lt_model_providers WHERE tenant_id = ? AND name = ?`
+      )
+      .get(tenantId, name) as unknown as ProviderRow | undefined;
+    return row ? mapRowToEntry(row) : null;
+  }
+
+  async createProvider(
+    tenantId: string,
+    id: string,
+    data: CreateModelProviderRequest
+  ): Promise<ModelProviderEntry> {
+    const now = nowISO();
+
+    this.db
+      .prepare(
+        `INSERT INTO lt_model_providers (
+           id, tenant_id, name, display_name, protocol, api_style, llm_provider, base_url,
+           api_key_enc, api_key_hint, enabled, status, created_at, updated_at
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'unknown', ?, ?)
+         ON CONFLICT (tenant_id, id) DO UPDATE SET
+           name = excluded.name,
+           display_name = excluded.display_name,
+           protocol = excluded.protocol,
+           api_style = excluded.api_style,
+           llm_provider = excluded.llm_provider,
+           base_url = excluded.base_url,
+           api_key_enc = excluded.api_key_enc,
+           api_key_hint = excluded.api_key_hint,
+           enabled = excluded.enabled,
+           updated_at = excluded.updated_at`
+      )
+      .run(
+        id,
+        tenantId,
+        data.name,
+        data.displayName || null,
+        data.protocol,
+        data.apiStyle ?? "chat-completions",
+        // Phase 1 pins the LLM provider (ADR-138 decision 7b)
+        "openai",
+        data.baseURL,
+        data.apiKey ? encrypt(data.apiKey) : null,
+        data.apiKey ? data.apiKey.slice(-4) : null,
+        data.enabled === false ? 0 : 1,
+        now,
+        now
+      );
+
+    const created = await this.getProviderById(tenantId, id);
+    if (!created) {
+      throw new Error("Failed to create model provider");
+    }
+
+    return created;
+  }
+
+  async updateProvider(
+    tenantId: string,
+    id: string,
+    updates: Partial<UpdateModelProviderRequest>
+  ): Promise<ModelProviderEntry | null> {
+    const existing = await this.getProviderById(tenantId, id);
+    if (!existing) {
+      return null;
+    }
+
+    const fields: string[] = [];
+    const values: unknown[] = [];
+
+    const set = (column: string, value: unknown): void => {
+      fields.push(`${column} = ?`);
+      values.push(value);
+    };
+
+    if (updates.name !== undefined) set("name", updates.name);
+    if (updates.displayName !== undefined) {
+      set("display_name", updates.displayName || null);
+    }
+    if (updates.protocol !== undefined) set("protocol", updates.protocol);
+    if (updates.apiStyle !== undefined) set("api_style", updates.apiStyle);
+    if (updates.baseURL !== undefined) set("base_url", updates.baseURL);
+    if (updates.enabled !== undefined) set("enabled", updates.enabled ? 1 : 0);
+
+    // An empty or omitted apiKey means "keep the existing key"; `clearApiKey`
+    // is the only way to remove one outright.
+    if (updates.clearApiKey === true) {
+      set("api_key_enc", null);
+      set("api_key_hint", null);
+    } else if (updates.apiKey) {
+      set("api_key_enc", encrypt(updates.apiKey));
+      set("api_key_hint", updates.apiKey.slice(-4));
+    }
+
+    if (fields.length === 0) {
+      return existing;
+    }
+
+    fields.push("updated_at = ?");
+    values.push(nowISO(), tenantId, id);
+
+    this.db
+      .prepare(
+        `UPDATE lt_model_providers SET ${fields.join(", ")}
+         WHERE tenant_id = ? AND id = ?`
+      )
+      .run(...values);
+
+    return this.getProviderById(tenantId, id);
+  }
+
+  async deleteProvider(tenantId: string, id: string): Promise<boolean> {
+    await this.deleteModelsByProvider(tenantId, id);
+
+    const result = this.db
+      .prepare(`DELETE FROM lt_model_providers WHERE tenant_id = ? AND id = ?`)
+      .run(tenantId, id);
+
+    return result.changes > 0;
+  }
+
+  async markProviderStatus(
+    tenantId: string,
+    id: string,
+    status: ModelProviderStatus,
+    lastError?: string,
+    discoveredAt?: Date
+  ): Promise<void> {
+    this.db
+      .prepare(
+        `UPDATE lt_model_providers
+         SET status = ?,
+             last_error = ?,
+             last_discovered_at = COALESCE(?, last_discovered_at),
+             updated_at = ?
+         WHERE tenant_id = ? AND id = ?`
+      )
+      .run(
+        status,
+        status === "ok" ? null : lastError || null,
+        discoveredAt ? discoveredAt.toISOString() : null,
+        nowISO(),
+        tenantId,
+        id
+      );
+  }
+
+  async listModels(
+    tenantId: string,
+    providerId?: string
+  ): Promise<ModelProviderModelEntry[]> {
+    const rows = providerId
+      ? (this.db
+          .prepare(
+            `SELECT * FROM lt_model_provider_models
+             WHERE tenant_id = ? AND provider_id = ? ORDER BY model_id ASC`
+          )
+          .all(tenantId, providerId) as unknown as ModelRow[])
+      : (this.db
+          .prepare(
+            `SELECT * FROM lt_model_provider_models
+             WHERE tenant_id = ? ORDER BY model_id ASC`
+          )
+          .all(tenantId) as unknown as ModelRow[]);
+
+    return rows.map((row) => mapRowToModel(row));
+  }
+
+  async getModel(
+    tenantId: string,
+    providerId: string,
+    modelId: string
+  ): Promise<ModelProviderModelEntry | null> {
+    const row = this.db
+      .prepare(
+        `SELECT * FROM lt_model_provider_models
+         WHERE tenant_id = ? AND provider_id = ? AND model_id = ?`
+      )
+      .get(tenantId, providerId, modelId) as unknown as ModelRow | undefined;
+
+    return row ? mapRowToModel(row) : null;
+  }
+
+  /**
+   * Replace a provider's model snapshot.
+   *
+   * Models the upstream no longer offers are deleted; survivors are upserted
+   * without touching `enabled`, so the tenant's enable/disable choice survives.
+   */
+  async replaceProviderModels(
+    tenantId: string,
+    providerId: string,
+    models: ProviderModelInput[]
+  ): Promise<string[]> {
+    const now = nowISO();
+
+    // De-duplicate by model id: the upsert below targets
+    // (tenant_id, provider_id, model_id), and upstreams do repeat ids.
+    const deduped = new Map<string, ProviderModelInput>();
+    for (const model of models) {
+      deduped.set(model.id, model);
+    }
+    const rows = [...deduped.values()];
+
+    if (rows.length === 0) {
+      await this.deleteModelsByProvider(tenantId, providerId);
+      return [];
+    }
+
+    // Read the current enabled state first so the write can state it
+    // explicitly: discovery leaves `enabled` out (keeping the tenant's choice)
+    // while an explicit selection supplies it.
+    const current = new Map(
+      (await this.listModels(tenantId, providerId)).map((model) => [
+        model.modelId,
+        model.enabled,
+      ])
+    );
+
+    const placeholders = rows.map(() => "?").join(", ");
+    this.db
+      .prepare(
+        `DELETE FROM lt_model_provider_models
+         WHERE tenant_id = ? AND provider_id = ? AND model_id NOT IN (${placeholders})`
+      )
+      .run(tenantId, providerId, ...rows.map((model) => model.id));
+
+    for (const model of rows) {
+      this.db
+        .prepare(
+          `INSERT INTO lt_model_provider_models (
+             id, tenant_id, provider_id, model_id, display_name, owned_by,
+             upstream_created, raw, enabled, stale, discovered_at
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT (tenant_id, provider_id, model_id) DO UPDATE SET
+             display_name = excluded.display_name,
+             owned_by = excluded.owned_by,
+             upstream_created = excluded.upstream_created,
+             raw = excluded.raw,
+             enabled = excluded.enabled,
+             stale = excluded.stale,
+             discovered_at = excluded.discovered_at`
+        )
+        .run(
+          `${providerId}:${model.id}`,
+          tenantId,
+          providerId,
+          model.id,
+          model.displayName || null,
+          model.ownedBy || null,
+          model.createdAt || null,
+          model.raw === undefined ? null : JSON.stringify(model.raw),
+          model.enabled ?? current.get(model.id) ?? true ? 1 : 0,
+          model.stale ? 1 : 0,
+          now
+        );
+    }
+
+    return rows.map((model) => model.id);
+  }
+
+  async setModelEnabled(
+    tenantId: string,
+    providerId: string,
+    modelId: string,
+    enabled: boolean
+  ): Promise<ModelProviderModelEntry | null> {
+    const result = this.db
+      .prepare(
+        `UPDATE lt_model_provider_models SET enabled = ?
+         WHERE tenant_id = ? AND provider_id = ? AND model_id = ?`
+      )
+      .run(enabled ? 1 : 0, tenantId, providerId, modelId);
+
+    if (result.changes === 0) {
+      return null;
+    }
+
+    return this.getModel(tenantId, providerId, modelId);
+  }
+
+  async deleteModelsByProvider(
+    tenantId: string,
+    providerId: string
+  ): Promise<number> {
+    const result = this.db
+      .prepare(
+        `DELETE FROM lt_model_provider_models
+         WHERE tenant_id = ? AND provider_id = ?`
+      )
+      .run(tenantId, providerId);
+
+    return result.changes;
+  }
+}
+
+function mapRowToEntry(row: ProviderRow): ModelProviderEntry {
+  let apiKey: string | undefined;
+
+  if (row.api_key_enc) {
+    try {
+      apiKey = decrypt(row.api_key_enc);
+    } catch (error) {
+      console.error("Failed to decrypt model provider API key:", error);
+      throw new Error("Failed to decrypt model provider API key");
+    }
+  }
+
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    name: row.name,
+    displayName: row.display_name || undefined,
+    protocol: row.protocol as ModelProviderWireProtocol,
+    apiStyle: row.api_style as ModelProviderApiStyle,
+    llmProvider: row.llm_provider as ModelProviderLlmProvider,
+    baseURL: row.base_url,
+    apiKey,
+    apiKeyHint: row.api_key_hint || undefined,
+    enabled: row.enabled === 1,
+    status: row.status as ModelProviderStatus,
+    lastError: row.last_error || undefined,
+    lastDiscoveredAt: row.last_discovered_at
+      ? parseISO(row.last_discovered_at)
+      : undefined,
+    createdBy: row.created_by || undefined,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}
+
+function mapRowToModel(row: ModelRow): ModelProviderModelEntry {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    providerId: row.provider_id,
+    modelId: row.model_id,
+    displayName: row.display_name || undefined,
+    ownedBy: row.owned_by || undefined,
+    upstreamCreatedAt: row.upstream_created
+      ? parseISO(row.upstream_created)
+      : undefined,
+    enabled: row.enabled === 1,
+    stale: row.stale === 1,
+    discoveredAt: parseISO(row.discovered_at),
+  };
+}