@dexto/agent-management 1.4.0 → 1.5.1

package/dist/models/path-resolver.cjs

@@ -0,0 +1,154 @@
+"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);
+var path_resolver_exports = {};
+__export(path_resolver_exports, {
+  deleteModelDirectory: () => deleteModelDirectory,
+  ensureModelDirectory: () => ensureModelDirectory,
+  ensureModelsDirectory: () => ensureModelsDirectory,
+  formatSize: () => formatSize,
+  getModelDirectory: () => getModelDirectory,
+  getModelFilePath: () => getModelFilePath,
+  getModelFileSize: () => getModelFileSize,
+  getModelStatePath: () => getModelStatePath,
+  getModelTempDirectory: () => getModelTempDirectory,
+  getModelsDirectory: () => getModelsDirectory,
+  getModelsDiskUsage: () => getModelsDiskUsage,
+  listModelDirectories: () => listModelDirectories,
+  modelFileExists: () => modelFileExists
+});
+module.exports = __toCommonJS(path_resolver_exports);
+var path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var import_os = require("os");
+function getModelsDirectory() {
+  return path.join((0, import_os.homedir)(), ".dexto", "models");
+}
+function getModelFilePath(modelId, filename) {
+  return path.join(getModelsDirectory(), modelId, filename);
+}
+function getModelDirectory(modelId) {
+  return path.join(getModelsDirectory(), modelId);
+}
+function getModelStatePath() {
+  return path.join(getModelsDirectory(), "state.json");
+}
+function getModelTempDirectory() {
+  return path.join(getModelsDirectory(), ".tmp");
+}
+async function ensureModelsDirectory() {
+  const modelsDir = getModelsDirectory();
+  const tempDir = getModelTempDirectory();
+  await import_fs.promises.mkdir(modelsDir, { recursive: true });
+  await import_fs.promises.mkdir(tempDir, { recursive: true });
+}
+async function ensureModelDirectory(modelId) {
+  const modelDir = getModelDirectory(modelId);
+  await import_fs.promises.mkdir(modelDir, { recursive: true });
+  return modelDir;
+}
+async function modelFileExists(modelId, filename) {
+  const filePath = getModelFilePath(modelId, filename);
+  try {
+    await import_fs.promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getModelFileSize(modelId, filename) {
+  const filePath = getModelFilePath(modelId, filename);
+  try {
+    const stats = await import_fs.promises.stat(filePath);
+    return stats.size;
+  } catch {
+    return null;
+  }
+}
+async function deleteModelDirectory(modelId) {
+  const modelDir = getModelDirectory(modelId);
+  try {
+    await import_fs.promises.rm(modelDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listModelDirectories() {
+  const modelsDir = getModelsDirectory();
+  try {
+    const entries = await import_fs.promises.readdir(modelsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function getModelsDiskUsage() {
+  const modelsDir = getModelsDirectory();
+  async function getDirSize(dir) {
+    let size = 0;
+    try {
+      const entries = await import_fs.promises.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          size += await getDirSize(entryPath);
+        } else if (entry.isFile()) {
+          const stats = await import_fs.promises.stat(entryPath);
+          size += stats.size;
+        }
+      }
+    } catch {
+    }
+    return size;
+  }
+  return getDirSize(modelsDir);
+}
+function formatSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(1)} ${units[i]}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteModelDirectory,
+  ensureModelDirectory,
+  ensureModelsDirectory,
+  formatSize,
+  getModelDirectory,
+  getModelFilePath,
+  getModelFileSize,
+  getModelStatePath,
+  getModelTempDirectory,
+  getModelsDirectory,
+  getModelsDiskUsage,
+  listModelDirectories,
+  modelFileExists
+});

package/dist/models/path-resolver.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Path resolver for local model storage.
+ *
+ * Models are stored globally at ~/.dexto/models/ to be shared across projects.
+ * This avoids duplicating large model files for each project.
+ */
+/**
+ * Get the base models directory path.
+ * Always returns global path: ~/.dexto/models/
+ */
+export declare function getModelsDirectory(): string;
+/**
+ * Get the path to a specific model file.
+ * @param modelId Model ID from registry
+ * @param filename GGUF filename
+ */
+export declare function getModelFilePath(modelId: string, filename: string): string;
+/**
+ * Get the path to a model's directory.
+ * @param modelId Model ID from registry
+ */
+export declare function getModelDirectory(modelId: string): string;
+/**
+ * Get the path to the model state file.
+ * Stores download status, hashes, and usage metadata.
+ */
+export declare function getModelStatePath(): string;
+/**
+ * Get the path to the model download temp directory.
+ * Used for in-progress downloads.
+ */
+export declare function getModelTempDirectory(): string;
+/**
+ * Ensure the models directory and subdirectories exist.
+ */
+export declare function ensureModelsDirectory(): Promise<void>;
+/**
+ * Ensure a specific model's directory exists.
+ * @param modelId Model ID from registry
+ */
+export declare function ensureModelDirectory(modelId: string): Promise<string>;
+/**
+ * Check if a model file exists at the expected path.
+ * @param modelId Model ID from registry
+ * @param filename GGUF filename
+ */
+export declare function modelFileExists(modelId: string, filename: string): Promise<boolean>;
+/**
+ * Get file size of an installed model.
+ * @param modelId Model ID from registry
+ * @param filename GGUF filename
+ * @returns File size in bytes, or null if file doesn't exist
+ */
+export declare function getModelFileSize(modelId: string, filename: string): Promise<number | null>;
+/**
+ * Delete a model's directory and all its files.
+ * @param modelId Model ID to delete
+ * @returns True if deleted, false if not found
+ */
+export declare function deleteModelDirectory(modelId: string): Promise<boolean>;
+/**
+ * List all model directories in the models folder.
+ * @returns Array of model IDs (directory names)
+ */
+export declare function listModelDirectories(): Promise<string[]>;
+/**
+ * Get disk usage statistics for the models directory.
+ * @returns Total bytes used by models, or 0 if directory doesn't exist
+ */
+export declare function getModelsDiskUsage(): Promise<number>;
+/**
+ * Format bytes to human-readable string.
+ * @param bytes Number of bytes
+ * @returns Formatted string (e.g., "4.5 GB")
+ */
+export declare function formatSize(bytes: number): string;
+//# sourceMappingURL=path-resolver.d.ts.map

package/dist/models/path-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-resolver.d.ts","sourceRoot":"","sources":["../../src/models/path-resolver.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED;;GAEG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAM3D;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAI3E;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQzF;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAQhG;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ5E;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAQ9D;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC,CAuB1D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQhD"}

package/dist/models/path-resolver.js

@@ -0,0 +1,108 @@
+import * as path from "path";
+import { promises as fs } from "fs";
+import { homedir } from "os";
+function getModelsDirectory() {
+  return path.join(homedir(), ".dexto", "models");
+}
+function getModelFilePath(modelId, filename) {
+  return path.join(getModelsDirectory(), modelId, filename);
+}
+function getModelDirectory(modelId) {
+  return path.join(getModelsDirectory(), modelId);
+}
+function getModelStatePath() {
+  return path.join(getModelsDirectory(), "state.json");
+}
+function getModelTempDirectory() {
+  return path.join(getModelsDirectory(), ".tmp");
+}
+async function ensureModelsDirectory() {
+  const modelsDir = getModelsDirectory();
+  const tempDir = getModelTempDirectory();
+  await fs.mkdir(modelsDir, { recursive: true });
+  await fs.mkdir(tempDir, { recursive: true });
+}
+async function ensureModelDirectory(modelId) {
+  const modelDir = getModelDirectory(modelId);
+  await fs.mkdir(modelDir, { recursive: true });
+  return modelDir;
+}
+async function modelFileExists(modelId, filename) {
+  const filePath = getModelFilePath(modelId, filename);
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getModelFileSize(modelId, filename) {
+  const filePath = getModelFilePath(modelId, filename);
+  try {
+    const stats = await fs.stat(filePath);
+    return stats.size;
+  } catch {
+    return null;
+  }
+}
+async function deleteModelDirectory(modelId) {
+  const modelDir = getModelDirectory(modelId);
+  try {
+    await fs.rm(modelDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listModelDirectories() {
+  const modelsDir = getModelsDirectory();
+  try {
+    const entries = await fs.readdir(modelsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function getModelsDiskUsage() {
+  const modelsDir = getModelsDirectory();
+  async function getDirSize(dir) {
+    let size = 0;
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          size += await getDirSize(entryPath);
+        } else if (entry.isFile()) {
+          const stats = await fs.stat(entryPath);
+          size += stats.size;
+        }
+      }
+    } catch {
+    }
+    return size;
+  }
+  return getDirSize(modelsDir);
+}
+function formatSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(1)} ${units[i]}`;
+}
+export {
+  deleteModelDirectory,
+  ensureModelDirectory,
+  ensureModelsDirectory,
+  formatSize,
+  getModelDirectory,
+  getModelFilePath,
+  getModelFileSize,
+  getModelStatePath,
+  getModelTempDirectory,
+  getModelsDirectory,
+  getModelsDiskUsage,
+  listModelDirectories,
+  modelFileExists
+};

package/dist/models/state-manager.cjs

@@ -0,0 +1,220 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var state_manager_exports = {};
+__export(state_manager_exports, {
+  addInstalledModel: () => addInstalledModel,
+  addToDownloadQueue: () => addToDownloadQueue,
+  getActiveModel: () => getActiveModel,
+  getActiveModelId: () => getActiveModelId,
+  getAllInstalledModels: () => getAllInstalledModels,
+  getDownloadQueue: () => getDownloadQueue,
+  getInstalledModel: () => getInstalledModel,
+  getInstalledModelCount: () => getInstalledModelCount,
+  getTotalInstalledSize: () => getTotalInstalledSize,
+  isModelInstalled: () => isModelInstalled,
+  loadModelState: () => loadModelState,
+  registerManualModel: () => registerManualModel,
+  removeFromDownloadQueue: () => removeFromDownloadQueue,
+  removeInstalledModel: () => removeInstalledModel,
+  saveModelState: () => saveModelState,
+  setActiveModel: () => setActiveModel,
+  syncStateWithFilesystem: () => syncStateWithFilesystem,
+  updateModelLastUsed: () => updateModelLastUsed
+});
+module.exports = __toCommonJS(state_manager_exports);
+var import_fs = require("fs");
+var import_path_resolver = require("./path-resolver.js");
+const CURRENT_VERSION = "1.0";
+function createDefaultState() {
+  return {
+    version: CURRENT_VERSION,
+    installed: {},
+    downloadQueue: []
+  };
+}
+async function loadModelState() {
+  const statePath = (0, import_path_resolver.getModelStatePath)();
+  try {
+    const content = await import_fs.promises.readFile(statePath, "utf-8");
+    const state = JSON.parse(content);
+    if (state.version !== CURRENT_VERSION) {
+      return migrateState(state);
+    }
+    return state;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return createDefaultState();
+    }
+    console.warn("Invalid model state file, resetting to default");
+    return createDefaultState();
+  }
+}
+async function saveModelState(state) {
+  await (0, import_path_resolver.ensureModelsDirectory)();
+  const statePath = (0, import_path_resolver.getModelStatePath)();
+  await import_fs.promises.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+}
+function migrateState(state) {
+  return {
+    ...state,
+    version: CURRENT_VERSION
+  };
+}
+async function addInstalledModel(model) {
+  const state = await loadModelState();
+  state.installed[model.id] = model;
+  await saveModelState(state);
+}
+async function removeInstalledModel(modelId) {
+  const state = await loadModelState();
+  if (!state.installed[modelId]) {
+    return false;
+  }
+  delete state.installed[modelId];
+  if (state.activeModelId === modelId) {
+    delete state.activeModelId;
+  }
+  state.downloadQueue = state.downloadQueue.filter((id) => id !== modelId);
+  await saveModelState(state);
+  return true;
+}
+async function getInstalledModel(modelId) {
+  const state = await loadModelState();
+  return state.installed[modelId] ?? null;
+}
+async function getAllInstalledModels() {
+  const state = await loadModelState();
+  return Object.values(state.installed);
+}
+async function isModelInstalled(modelId) {
+  const model = await getInstalledModel(modelId);
+  if (!model) {
+    return false;
+  }
+  return (0, import_path_resolver.modelFileExists)(modelId, model.filename);
+}
+async function updateModelLastUsed(modelId) {
+  const state = await loadModelState();
+  const model = state.installed[modelId];
+  if (model) {
+    model.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await saveModelState(state);
+  }
+}
+async function setActiveModel(modelId) {
+  const state = await loadModelState();
+  if (modelId === void 0) {
+    delete state.activeModelId;
+  } else {
+    state.activeModelId = modelId;
+  }
+  await saveModelState(state);
+}
+async function getActiveModelId() {
+  const state = await loadModelState();
+  return state.activeModelId;
+}
+async function getActiveModel() {
+  const activeId = await getActiveModelId();
+  if (!activeId) {
+    return null;
+  }
+  return getInstalledModel(activeId);
+}
+async function addToDownloadQueue(modelId) {
+  const state = await loadModelState();
+  if (!state.downloadQueue.includes(modelId)) {
+    state.downloadQueue.push(modelId);
+    await saveModelState(state);
+  }
+}
+async function removeFromDownloadQueue(modelId) {
+  const state = await loadModelState();
+  state.downloadQueue = state.downloadQueue.filter((id) => id !== modelId);
+  await saveModelState(state);
+}
+async function getDownloadQueue() {
+  const state = await loadModelState();
+  return [...state.downloadQueue];
+}
+async function syncStateWithFilesystem() {
+  const state = await loadModelState();
+  const removed = [];
+  const kept = [];
+  for (const [modelId, model] of Object.entries(state.installed)) {
+    const exists = await (0, import_path_resolver.modelFileExists)(modelId, model.filename);
+    if (exists) {
+      kept.push(modelId);
+    } else {
+      removed.push(modelId);
+      delete state.installed[modelId];
+    }
+  }
+  if (state.activeModelId && removed.includes(state.activeModelId)) {
+    delete state.activeModelId;
+  }
+  if (removed.length > 0) {
+    await saveModelState(state);
+  }
+  return { removed, kept };
+}
+async function getTotalInstalledSize() {
+  const state = await loadModelState();
+  return Object.values(state.installed).reduce((total, model) => total + model.sizeBytes, 0);
+}
+async function getInstalledModelCount() {
+  const state = await loadModelState();
+  return Object.keys(state.installed).length;
+}
+async function registerManualModel(modelId, filename, sizeBytes, sha256) {
+  const filePath = (0, import_path_resolver.getModelFilePath)(modelId, filename);
+  const model = {
+    id: modelId,
+    filePath,
+    sizeBytes,
+    downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "manual",
+    filename
+  };
+  if (sha256 !== void 0) {
+    model.sha256 = sha256;
+  }
+  await addInstalledModel(model);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addInstalledModel,
+  addToDownloadQueue,
+  getActiveModel,
+  getActiveModelId,
+  getAllInstalledModels,
+  getDownloadQueue,
+  getInstalledModel,
+  getInstalledModelCount,
+  getTotalInstalledSize,
+  isModelInstalled,
+  loadModelState,
+  registerManualModel,
+  removeFromDownloadQueue,
+  removeInstalledModel,
+  saveModelState,
+  setActiveModel,
+  syncStateWithFilesystem,
+  updateModelLastUsed
+});

package/dist/models/state-manager.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Model state manager for tracking downloaded local models.
+ *
+ * Persists model metadata to ~/.dexto/models/state.json including:
+ * - Which models are installed
+ * - File paths and sizes
+ * - Download timestamps
+ * - Usage tracking
+ *
+ * Note: ModelSource and InstalledModel types here intentionally differ from
+ * packages/core/src/llm/providers/local/types.ts. This package extends the core
+ * types with agent-management specific needs:
+ * - ModelSource adds 'manual' for user-placed model files
+ * - InstalledModel adds 'filename' for file system operations (isModelInstalled, syncStateWithFilesystem)
+ */
+/**
+ * Source of the model download.
+ */
+export type ModelSource = 'huggingface' | 'manual';
+/**
+ * Installed model metadata.
+ */
+export interface InstalledModel {
+    /** Model ID from registry */
+    id: string;
+    /** Absolute path to the .gguf file */
+    filePath: string;
+    /** File size in bytes */
+    sizeBytes: number;
+    /** When the model was downloaded (ISO timestamp) */
+    downloadedAt: string;
+    /** When the model was last used (ISO timestamp) */
+    lastUsedAt?: string;
+    /** SHA-256 hash of the file for integrity verification */
+    sha256?: string;
+    /** Source of the download */
+    source: ModelSource;
+    /** GGUF filename */
+    filename: string;
+}
+/**
+ * Persisted model state.
+ */
+export interface ModelState {
+    /** Schema version for migrations */
+    version: string;
+    /** Map of model ID to installed model info */
+    installed: Record<string, InstalledModel>;
+    /** Currently active/selected model ID */
+    activeModelId?: string;
+    /** Queue of model IDs pending download */
+    downloadQueue: string[];
+}
+/**
+ * Load model state from disk.
+ * Returns default state if file doesn't exist.
+ */
+export declare function loadModelState(): Promise<ModelState>;
+/**
+ * Save model state to disk.
+ */
+export declare function saveModelState(state: ModelState): Promise<void>;
+/**
+ * Add an installed model to state.
+ *
+ * Note: These operations are not atomic. Ensure single-threaded access
+ * or implement file locking for concurrent usage scenarios.
+ */
+export declare function addInstalledModel(model: InstalledModel): Promise<void>;
+/**
+ * Remove an installed model from state.
+ *
+ * Note: These operations are not atomic. Ensure single-threaded access
+ * or implement file locking for concurrent usage scenarios.
+ */
+export declare function removeInstalledModel(modelId: string): Promise<boolean>;
+/**
+ * Get installed model info.
+ */
+export declare function getInstalledModel(modelId: string): Promise<InstalledModel | null>;
+/**
+ * Get all installed models.
+ */
+export declare function getAllInstalledModels(): Promise<InstalledModel[]>;
+/**
+ * Check if a model is installed.
+ */
+export declare function isModelInstalled(modelId: string): Promise<boolean>;
+/**
+ * Update last used timestamp for a model.
+ */
+export declare function updateModelLastUsed(modelId: string): Promise<void>;
+/**
+ * Set the active model.
+ */
+export declare function setActiveModel(modelId: string | undefined): Promise<void>;
+/**
+ * Get the active model ID.
+ */
+export declare function getActiveModelId(): Promise<string | undefined>;
+/**
+ * Get the active model info.
+ */
+export declare function getActiveModel(): Promise<InstalledModel | null>;
+/**
+ * Add a model to the download queue.
+ */
+export declare function addToDownloadQueue(modelId: string): Promise<void>;
+/**
+ * Remove a model from the download queue.
+ */
+export declare function removeFromDownloadQueue(modelId: string): Promise<void>;
+/**
+ * Get the download queue.
+ */
+export declare function getDownloadQueue(): Promise<string[]>;
+/**
+ * Sync state with actual filesystem.
+ * Removes entries for models that no longer exist on disk.
+ */
+export declare function syncStateWithFilesystem(): Promise<{
+    removed: string[];
+    kept: string[];
+}>;
+/**
+ * Get total size of all installed models.
+ */
+export declare function getTotalInstalledSize(): Promise<number>;
+/**
+ * Get count of installed models.
+ */
+export declare function getInstalledModelCount(): Promise<number>;
+/**
+ * Register a manually added model file.
+ * Used when user places a GGUF file directly in the models directory.
+ */
+export declare function registerManualModel(modelId: string, filename: string, sizeBytes: number, sha256?: string): Promise<void>;
+//# sourceMappingURL=state-manager.d.ts.map