@codelia/model-metadata 0.1.0

package/dist/index.cjs

@@ -0,0 +1,290 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ModelMetadataServiceImpl: () => ModelMetadataServiceImpl
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/sources/modeldev.ts
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var import_storage = require("@codelia/storage");
+var import_zod = require("zod");
+var modelResourceUrl = "https://models.dev/api.json";
+var CACHE_FILENAME = "models.dev.json";
+var CACHE_VERSION = 1;
+var DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var wireModelDevModelSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  name: import_zod.z.string(),
+  family: import_zod.z.string().optional(),
+  attachment: import_zod.z.boolean().optional(),
+  reasoning: import_zod.z.boolean().optional(),
+  tool_call: import_zod.z.boolean().optional(),
+  structured_output: import_zod.z.boolean().optional(),
+  temperature: import_zod.z.boolean().optional(),
+  knowledge: import_zod.z.string().optional(),
+  release_date: import_zod.z.string().optional(),
+  last_updated: import_zod.z.string().optional(),
+  open_weights: import_zod.z.boolean().optional(),
+  cost: import_zod.z.object({
+    input: import_zod.z.number().optional(),
+    output: import_zod.z.number().optional(),
+    reasoning: import_zod.z.number().optional(),
+    cache_read: import_zod.z.number().optional(),
+    cache_write: import_zod.z.number().optional(),
+    input_audio: import_zod.z.number().optional(),
+    output_audio: import_zod.z.number().optional()
+  }).loose().optional(),
+  limit: import_zod.z.object({
+    context: import_zod.z.number().optional(),
+    input: import_zod.z.number().optional(),
+    output: import_zod.z.number().optional()
+  }).loose().optional(),
+  modalities: import_zod.z.object({
+    input: import_zod.z.array(import_zod.z.string()).optional(),
+    output: import_zod.z.array(import_zod.z.string()).optional()
+  }).loose().optional(),
+  interleaved: import_zod.z.union([
+    import_zod.z.boolean(),
+    import_zod.z.object({
+      field: import_zod.z.string().optional()
+    }).loose()
+  ]).optional()
+}).loose();
+var wireModelDevModelsSchema = import_zod.z.union([
+  import_zod.z.array(wireModelDevModelSchema),
+  import_zod.z.record(import_zod.z.string(), wireModelDevModelSchema)
+]);
+var wireModelDevProviderSchema = import_zod.z.object({
+  id: import_zod.z.string().optional(),
+  name: import_zod.z.string().optional(),
+  api: import_zod.z.string().optional(),
+  doc: import_zod.z.string().optional(),
+  env: import_zod.z.array(import_zod.z.string()).optional(),
+  npm: import_zod.z.string().optional(),
+  models: import_zod.z.record(import_zod.z.string(), wireModelDevModelSchema).optional()
+}).loose();
+var wireModelDevProvidersSchema = import_zod.z.record(
+  import_zod.z.string(),
+  wireModelDevProviderSchema
+);
+var ModelDevSource = class {
+  loaded = false;
+  models = {};
+  cacheTtlMs;
+  cachePath;
+  constructor(options = {}) {
+    this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+    const storagePaths = options.storagePathService ? options.storagePathService.resolvePaths({
+      rootOverride: options.storageRoot
+    }) : (0, import_storage.resolveStoragePaths)({ rootOverride: options.storageRoot });
+    this.cachePath = options.cachePath ?? import_node_path.default.join(storagePaths.cacheDir, CACHE_FILENAME);
+  }
+  async loadModelMetadata(options = {}) {
+    this.loaded = false;
+    this.models = {};
+    if (!options.forceRefresh) {
+      const cached = await readCacheFile(this.cachePath);
+      if (cached && !isCacheExpired(cached.expiresAt)) {
+        this.models = cached.entries;
+        this.loaded = true;
+        return;
+      }
+    }
+    const response = await fetch(modelResourceUrl);
+    const data = await response.json();
+    const providersResult = wireModelDevProvidersSchema.safeParse(data);
+    if (providersResult.success) {
+      this.models = buildEntriesFromProviders(providersResult.data);
+    }
+    let hasEntries = Object.keys(this.models).length > 0;
+    if (!hasEntries) {
+      this.models = buildEntriesFromLegacyPayload(data);
+    }
+    hasEntries = Object.keys(this.models).length > 0;
+    if (!hasEntries) {
+      throw new Error("ModelDevSource: empty metadata payload");
+    }
+    await writeCacheFile(this.cachePath, {
+      version: CACHE_VERSION,
+      cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      expiresAt: new Date(Date.now() + this.cacheTtlMs).toISOString(),
+      entries: this.models
+    }).catch(() => void 0);
+    this.loaded = true;
+  }
+  async getModelEntry(provider, model) {
+    if (!this.loaded) {
+      await this.loadModelMetadata();
+    }
+    return this.models[provider]?.[model] || null;
+  }
+  async getModelEntries(provider) {
+    if (!this.loaded) {
+      await this.loadModelMetadata();
+    }
+    return this.models[provider] ? Object.values(this.models[provider]) : null;
+  }
+  async getAllModelEntries() {
+    if (!this.loaded) {
+      await this.loadModelMetadata();
+    }
+    return this.models;
+  }
+};
+function buildEntriesFromProviders(providers) {
+  const entries = {};
+  for (const [providerId, provider] of Object.entries(providers)) {
+    const models = provider.models ? Object.values(provider.models) : [];
+    if (models.length === 0) continue;
+    entries[providerId] = buildEntriesForProvider(providerId, models);
+  }
+  return entries;
+}
+function buildEntriesFromLegacyPayload(data) {
+  let provider = "unknown";
+  if (data.provider && typeof data.provider === "object") {
+    const name = data.provider.name;
+    if (name) provider = name;
+  }
+  const modelsResult = wireModelDevModelsSchema.safeParse(
+    data.models
+  );
+  if (!modelsResult.success) return {};
+  const models = Array.isArray(modelsResult.data) ? modelsResult.data : Object.values(modelsResult.data);
+  if (models.length === 0) return {};
+  return { [provider]: buildEntriesForProvider(provider, models) };
+}
+function buildEntriesForProvider(provider, models) {
+  const entries = {};
+  for (const model of models) {
+    entries[model.id] = {
+      provider,
+      modelId: model.id,
+      cost: {
+        input: model.cost?.input,
+        output: model.cost?.output,
+        reasoning: model.cost?.reasoning,
+        cacheRead: model.cost?.cache_read,
+        cacheWrite: model.cost?.cache_write,
+        inputAudio: model.cost?.input_audio,
+        outputAudio: model.cost?.output_audio
+      },
+      limits: {
+        contextWindow: model.limit?.context,
+        inputTokens: model.limit?.input,
+        outputTokens: model.limit?.output
+      }
+    };
+  }
+  return entries;
+}
+async function readCacheFile(cachePath) {
+  const contents = await (0, import_promises.readFile)(cachePath, "utf8").catch(() => null);
+  if (!contents) return null;
+  const parsed = safeJsonParse(contents);
+  if (!parsed || !isCacheFile(parsed)) return null;
+  return parsed;
+}
+async function writeCacheFile(cachePath, cache) {
+  await ensureDir(import_node_path.default.dirname(cachePath));
+  await (0, import_promises.writeFile)(cachePath, JSON.stringify(cache), "utf8");
+}
+function isCacheExpired(expiresAt) {
+  const timestamp = Date.parse(expiresAt);
+  if (Number.isNaN(timestamp)) return true;
+  return timestamp <= Date.now();
+}
+function isCacheFile(value) {
+  if (!value || typeof value !== "object") return false;
+  const file = value;
+  if (file.version !== CACHE_VERSION) return false;
+  if (typeof file.cachedAt !== "string") return false;
+  if (typeof file.expiresAt !== "string") return false;
+  if (!file.entries || typeof file.entries !== "object") return false;
+  return true;
+}
+function safeJsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+async function ensureDir(dir) {
+  await (0, import_promises.mkdir)(dir, { recursive: true });
+}
+
+// src/service.ts
+var ModelMetadataServiceImpl = class {
+  modelDevSource;
+  sources;
+  constructor(options = {}) {
+    this.modelDevSource = new ModelDevSource(options);
+    this.sources = [this.modelDevSource];
+  }
+  async refreshAllModelEntries() {
+    await this.modelDevSource.loadModelMetadata({ forceRefresh: true });
+    return this.getAllModelEntries();
+  }
+  async getModelEntry(provider, model) {
+    for (const source of this.sources) {
+      const entry = await source.getModelEntry(provider, model);
+      if (entry) {
+        return entry;
+      }
+    }
+    return null;
+  }
+  async getModelEntries(provider) {
+    for (const source of this.sources) {
+      const entries = await source.getModelEntries(provider);
+      if (entries) {
+        return entries;
+      }
+    }
+    return null;
+  }
+  async getAllModelEntries() {
+    const entries = {};
+    for (const source of this.sources) {
+      const sourceEntries = await source.getAllModelEntries();
+      Object.assign(entries, sourceEntries);
+    }
+    return entries;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModelMetadataServiceImpl
+});

package/dist/index.d.cts

@@ -0,0 +1,27 @@
+import { ModelEntry, StoragePathService, ModelMetadataService } from '@codelia/core';
+export { ModelCost, ModelEntry, ModelLimits, ModelMetadataIndex } from '@codelia/core';
+
+type ModelMetadataSource = {
+    getModelEntry(provider: string, modelId: string): Promise<ModelEntry | null>;
+    getModelEntries(provider: string): Promise<ModelEntry[] | null>;
+    getAllModelEntries(): Promise<Record<string, Record<string, ModelEntry>>>;
+};
+
+type ModelDevSourceOptions = {
+    cacheTtlMs?: number;
+    cachePath?: string;
+    storageRoot?: string;
+    storagePathService?: StoragePathService;
+};
+
+declare class ModelMetadataServiceImpl implements ModelMetadataService {
+    private readonly modelDevSource;
+    private readonly sources;
+    constructor(options?: ModelDevSourceOptions);
+    refreshAllModelEntries(): Promise<Record<string, Record<string, ModelEntry>>>;
+    getModelEntry(provider: string, model: string): Promise<ModelEntry | null>;
+    getModelEntries(provider: string): Promise<ModelEntry[] | null>;
+    getAllModelEntries(): Promise<Record<string, Record<string, ModelEntry>>>;
+}
+
+export { type ModelDevSourceOptions, ModelMetadataServiceImpl, type ModelMetadataSource };

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import { ModelEntry, StoragePathService, ModelMetadataService } from '@codelia/core';
+export { ModelCost, ModelEntry, ModelLimits, ModelMetadataIndex } from '@codelia/core';
+
+type ModelMetadataSource = {
+    getModelEntry(provider: string, modelId: string): Promise<ModelEntry | null>;
+    getModelEntries(provider: string): Promise<ModelEntry[] | null>;
+    getAllModelEntries(): Promise<Record<string, Record<string, ModelEntry>>>;
+};
+
+type ModelDevSourceOptions = {
+    cacheTtlMs?: number;
+    cachePath?: string;
+    storageRoot?: string;
+    storagePathService?: StoragePathService;
+};
+
+declare class ModelMetadataServiceImpl implements ModelMetadataService {
+    private readonly modelDevSource;
+    private readonly sources;
+    constructor(options?: ModelDevSourceOptions);
+    refreshAllModelEntries(): Promise<Record<string, Record<string, ModelEntry>>>;
+    getModelEntry(provider: string, model: string): Promise<ModelEntry | null>;
+    getModelEntries(provider: string): Promise<ModelEntry[] | null>;
+    getAllModelEntries(): Promise<Record<string, Record<string, ModelEntry>>>;
+}
+
+export { type ModelDevSourceOptions, ModelMetadataServiceImpl, type ModelMetadataSource };

package/dist/index.js

@@ -0,0 +1,253 @@
+// src/sources/modeldev.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { resolveStoragePaths } from "@codelia/storage";
+import { z } from "zod";
+var modelResourceUrl = "https://models.dev/api.json";
+var CACHE_FILENAME = "models.dev.json";
+var CACHE_VERSION = 1;
+var DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var wireModelDevModelSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  family: z.string().optional(),
+  attachment: z.boolean().optional(),
+  reasoning: z.boolean().optional(),
+  tool_call: z.boolean().optional(),
+  structured_output: z.boolean().optional(),
+  temperature: z.boolean().optional(),
+  knowledge: z.string().optional(),
+  release_date: z.string().optional(),
+  last_updated: z.string().optional(),
+  open_weights: z.boolean().optional(),
+  cost: z.object({
+    input: z.number().optional(),
+    output: z.number().optional(),
+    reasoning: z.number().optional(),
+    cache_read: z.number().optional(),
+    cache_write: z.number().optional(),
+    input_audio: z.number().optional(),
+    output_audio: z.number().optional()
+  }).loose().optional(),
+  limit: z.object({
+    context: z.number().optional(),
+    input: z.number().optional(),
+    output: z.number().optional()
+  }).loose().optional(),
+  modalities: z.object({
+    input: z.array(z.string()).optional(),
+    output: z.array(z.string()).optional()
+  }).loose().optional(),
+  interleaved: z.union([
+    z.boolean(),
+    z.object({
+      field: z.string().optional()
+    }).loose()
+  ]).optional()
+}).loose();
+var wireModelDevModelsSchema = z.union([
+  z.array(wireModelDevModelSchema),
+  z.record(z.string(), wireModelDevModelSchema)
+]);
+var wireModelDevProviderSchema = z.object({
+  id: z.string().optional(),
+  name: z.string().optional(),
+  api: z.string().optional(),
+  doc: z.string().optional(),
+  env: z.array(z.string()).optional(),
+  npm: z.string().optional(),
+  models: z.record(z.string(), wireModelDevModelSchema).optional()
+}).loose();
+var wireModelDevProvidersSchema = z.record(
+  z.string(),
+  wireModelDevProviderSchema
+);
+var ModelDevSource = class {
+  loaded = false;
+  models = {};
+  cacheTtlMs;
+  cachePath;
+  constructor(options = {}) {
+    this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+    const storagePaths = options.storagePathService ? options.storagePathService.resolvePaths({
+      rootOverride: options.storageRoot
+    }) : resolveStoragePaths({ rootOverride: options.storageRoot });
+    this.cachePath = options.cachePath ?? path.join(storagePaths.cacheDir, CACHE_FILENAME);
+  }
+  async loadModelMetadata(options = {}) {
+    this.loaded = false;
+    this.models = {};
+    if (!options.forceRefresh) {
+      const cached = await readCacheFile(this.cachePath);
+      if (cached && !isCacheExpired(cached.expiresAt)) {
+        this.models = cached.entries;
+        this.loaded = true;
+        return;
+      }
+    }
+    const response = await fetch(modelResourceUrl);
+    const data = await response.json();
+    const providersResult = wireModelDevProvidersSchema.safeParse(data);
+    if (providersResult.success) {
+      this.models = buildEntriesFromProviders(providersResult.data);
+    }
+    let hasEntries = Object.keys(this.models).length > 0;
+    if (!hasEntries) {
+      this.models = buildEntriesFromLegacyPayload(data);
+    }
+    hasEntries = Object.keys(this.models).length > 0;
+    if (!hasEntries) {
+      throw new Error("ModelDevSource: empty metadata payload");
+    }
+    await writeCacheFile(this.cachePath, {
+      version: CACHE_VERSION,
+      cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      expiresAt: new Date(Date.now() + this.cacheTtlMs).toISOString(),
+      entries: this.models
+    }).catch(() => void 0);
+    this.loaded = true;
+  }
+  async getModelEntry(provider, model) {
+    if (!this.loaded) {
+      await this.loadModelMetadata();
+    }
+    return this.models[provider]?.[model] || null;
+  }
+  async getModelEntries(provider) {
+    if (!this.loaded) {
+      await this.loadModelMetadata();
+    }
+    return this.models[provider] ? Object.values(this.models[provider]) : null;
+  }
+  async getAllModelEntries() {
+    if (!this.loaded) {
+      await this.loadModelMetadata();
+    }
+    return this.models;
+  }
+};
+function buildEntriesFromProviders(providers) {
+  const entries = {};
+  for (const [providerId, provider] of Object.entries(providers)) {
+    const models = provider.models ? Object.values(provider.models) : [];
+    if (models.length === 0) continue;
+    entries[providerId] = buildEntriesForProvider(providerId, models);
+  }
+  return entries;
+}
+function buildEntriesFromLegacyPayload(data) {
+  let provider = "unknown";
+  if (data.provider && typeof data.provider === "object") {
+    const name = data.provider.name;
+    if (name) provider = name;
+  }
+  const modelsResult = wireModelDevModelsSchema.safeParse(
+    data.models
+  );
+  if (!modelsResult.success) return {};
+  const models = Array.isArray(modelsResult.data) ? modelsResult.data : Object.values(modelsResult.data);
+  if (models.length === 0) return {};
+  return { [provider]: buildEntriesForProvider(provider, models) };
+}
+function buildEntriesForProvider(provider, models) {
+  const entries = {};
+  for (const model of models) {
+    entries[model.id] = {
+      provider,
+      modelId: model.id,
+      cost: {
+        input: model.cost?.input,
+        output: model.cost?.output,
+        reasoning: model.cost?.reasoning,
+        cacheRead: model.cost?.cache_read,
+        cacheWrite: model.cost?.cache_write,
+        inputAudio: model.cost?.input_audio,
+        outputAudio: model.cost?.output_audio
+      },
+      limits: {
+        contextWindow: model.limit?.context,
+        inputTokens: model.limit?.input,
+        outputTokens: model.limit?.output
+      }
+    };
+  }
+  return entries;
+}
+async function readCacheFile(cachePath) {
+  const contents = await readFile(cachePath, "utf8").catch(() => null);
+  if (!contents) return null;
+  const parsed = safeJsonParse(contents);
+  if (!parsed || !isCacheFile(parsed)) return null;
+  return parsed;
+}
+async function writeCacheFile(cachePath, cache) {
+  await ensureDir(path.dirname(cachePath));
+  await writeFile(cachePath, JSON.stringify(cache), "utf8");
+}
+function isCacheExpired(expiresAt) {
+  const timestamp = Date.parse(expiresAt);
+  if (Number.isNaN(timestamp)) return true;
+  return timestamp <= Date.now();
+}
+function isCacheFile(value) {
+  if (!value || typeof value !== "object") return false;
+  const file = value;
+  if (file.version !== CACHE_VERSION) return false;
+  if (typeof file.cachedAt !== "string") return false;
+  if (typeof file.expiresAt !== "string") return false;
+  if (!file.entries || typeof file.entries !== "object") return false;
+  return true;
+}
+function safeJsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+
+// src/service.ts
+var ModelMetadataServiceImpl = class {
+  modelDevSource;
+  sources;
+  constructor(options = {}) {
+    this.modelDevSource = new ModelDevSource(options);
+    this.sources = [this.modelDevSource];
+  }
+  async refreshAllModelEntries() {
+    await this.modelDevSource.loadModelMetadata({ forceRefresh: true });
+    return this.getAllModelEntries();
+  }
+  async getModelEntry(provider, model) {
+    for (const source of this.sources) {
+      const entry = await source.getModelEntry(provider, model);
+      if (entry) {
+        return entry;
+      }
+    }
+    return null;
+  }
+  async getModelEntries(provider) {
+    for (const source of this.sources) {
+      const entries = await source.getModelEntries(provider);
+      if (entries) {
+        return entries;
+      }
+    }
+    return null;
+  }
+  async getAllModelEntries() {
+    const entries = {};
+    for (const source of this.sources) {
+      const sourceEntries = await source.getAllModelEntries();
+      Object.assign(entries, sourceEntries);
+    }
+    return entries;
+  }
+};
+export {
+  ModelMetadataServiceImpl
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+	"name": "@codelia/model-metadata",
+	"version": "0.1.0",
+	"type": "module",
+	"files": [
+		"dist"
+	],
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"require": "./dist/index.cjs"
+		}
+	},
+	"scripts": {
+		"build": "tsup src/index.ts --format esm,cjs --dts --clean",
+		"typecheck": "tsc --noEmit"
+	},
+	"dependencies": {
+		"@codelia/core": "0.1.0",
+		"@codelia/storage": "0.1.0",
+		"zod": "^4.3.5"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}