saeeol 1.0.9 → 1.1.1

package/src/server/routes/instance/httpapi/server.ts

@@ -58,6 +58,7 @@ import { experimentalHandlers } from "./handlers/experimental"
 import { fileHandlers } from "./handlers/file"
 import { globalHandlers } from "./handlers/global"
 import { instanceHandlers } from "./handlers/instance"
+import { localHandlers } from "./handlers/local"
 import { mcpHandlers } from "./handlers/mcp"
 import { permissionHandlers } from "./handlers/permission"
 import { projectHandlers } from "./handlers/project"
@@ -110,6 +111,7 @@ const instanceApiRoutes = HttpApiBuilder.layer(InstanceHttpApi).pipe(
     experimentalHandlers,
     fileHandlers,
     instanceHandlers,
+    localHandlers,
     mcpHandlers,
     projectHandlers,
     ptyHandlers,

package/src/server/routes/instance/provider.ts

@@ -58,11 +58,11 @@ export const ProviderRoutes = lazy(() =>
           const failedSet = new Set(failed)
           const validProviders = pickBy(
             providers,
-            (item, id) => Object.keys(item.models).length > 0 || id in connected || failedSet.has(id),
+            (item, id) => Object.keys(item.models ?? {}).length > 0 || id in connected || failedSet.has(id),
           )
           return {
             all: Object.values(validProviders),
-            default: Provider.defaultModelIDs(pickBy(validProviders, (item) => Object.keys(item.models).length > 0)),
+            default: Provider.defaultModelIDs(pickBy(validProviders, (item) => Object.keys(item.models ?? {}).length > 0)),
             connected: Object.keys(connected),
             failed,
           }

package/src/session/prompt-reminders.ts

@@ -7,6 +7,7 @@ import * as Session from "./session"
 import { InstanceState } from "@/effect/instance-state"
 import CODE_SWITCH from "./prompt/code-switch.txt"
 import type { PromptDeps } from "./prompt-types"
+import * as LTM from "@/ltm"
 
 const PLAN_REMINDER = `<system-reminder>
 Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits (with the exception of the plan file mentioned below), run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received.
@@ -57,6 +58,34 @@ export const insertReminders = (deps: PromptDeps, SaeeolSessionPrompt: any) =>
           sessionID: userMessage.info.sessionID, type: "text", text: CODE_SWITCH, synthetic: true,
         })
       }
+
+      // LTM retrieval — inject relevant long-term memories into the prompt
+      const cfg = yield* deps.config.get()
+      if (cfg?.ltm?.enabled) {
+        const userText = userMessage.parts
+          .filter((p) => p.type === "text")
+          .map((p) => (p as any).text ?? "")
+          .join(" ")
+          .slice(0, 500)
+        if (userText.length > 10) {
+          const ltmCfg = {
+            ...LTM.Config.DEFAULT_LTM_CONFIG,
+            ...cfg.ltm,
+            episodic: { ...LTM.Config.DEFAULT_LTM_CONFIG.episodic, ...cfg.ltm.episodic },
+            semantic: { ...LTM.Config.DEFAULT_LTM_CONFIG.semantic, ...cfg.ltm.semantic },
+            procedural: { ...LTM.Config.DEFAULT_LTM_CONFIG.procedural, ...cfg.ltm.procedural },
+            retrieval: { ...LTM.Config.DEFAULT_LTM_CONFIG.retrieval, ...cfg.ltm.retrieval },
+          }
+          const context = yield* Effect.promise(() => LTM.Retrieval.inject(userText, ltmCfg))
+          if (context) {
+            userMessage.parts.push({
+              id: PartID.ascending(), messageID: userMessage.info.id,
+              sessionID: userMessage.info.sessionID, type: "text", text: `\n${context}`, synthetic: true,
+            })
+          }
+        }
+      }
+
       return input.messages
     }
 

package/test/fake/provider.ts

@@ -35,6 +35,7 @@ export namespace ProviderTest {
     return {
       id,
       name: "Test Provider",
+      category: "cloud" as const,
       source: "config",
       env: [],
       options: {},

package/test/provider/local.test.ts

@@ -0,0 +1,208 @@
+import { test, expect, describe } from "bun:test"
+import { Schema } from "effect"
+import {
+  GPUInfo, GPUProfile, Quantization, ModelFormat,
+  ModelArtifact, ModelStatus, ModelInstance,
+  BackendType, BackendStatus,
+  RAGAssetType, RAGAsset,
+  DownloadState, HFModelSearch,
+} from "@/provider/local/types"
+import * as GPU from "@/provider/local/gpu"
+import * as Hub from "@/provider/local/hub"
+import * as RAG from "@/provider/local/rag"
+
+// ── Types ──
+
+describe("local types", () => {
+  test("Quantization accepts known values", () => {
+    const vals = ["q4_k_m", "q5_k_m", "q8_0", "fp16", "bf16", "fp32"] as const
+    for (const v of vals) {
+      expect(Schema.decodeSync(Quantization)(v)).toBe(v)
+    }
+  })
+
+  test("Quantization rejects invalid", () => {
+    expect(() => Schema.decodeSync(Quantization)("invalid" as any)).toThrow()
+  })
+
+  test("ModelFormat accepts known values", () => {
+    for (const v of ["gguf", "safetensors", "pytorch", "onnx", "awq", "gptq"] as const) {
+      expect(Schema.decodeSync(ModelFormat)(v)).toBe(v)
+    }
+  })
+
+  test("ModelStatus accepts all states", () => {
+    for (const v of ["stopped", "starting", "running", "error", "downloading"] as const) {
+      expect(Schema.decodeSync(ModelStatus)(v)).toBe(v)
+    }
+  })
+
+  test("BackendType accepts known backends", () => {
+    for (const v of ["ollama", "lmstudio", "vllm", "llama.cpp", "text-generation-webui"] as const) {
+      expect(Schema.decodeSync(BackendType)(v)).toBe(v)
+    }
+  })
+
+  test("RAGAssetType accepts known types", () => {
+    for (const v of ["embedding", "reranker", "vectordb"] as const) {
+      expect(Schema.decodeSync(RAGAssetType)(v)).toBe(v)
+    }
+  })
+})
+
+// ── GPU ──
+
+describe("GPU utilities", () => {
+  const mockProfile: GPUProfile = {
+    gpus: [
+      { index: 0, name: "RTX 4090", vramTotalMB: 24564, vramUsedMB: 2000, vramFreeMB: 22564, computeCapability: "8.9" },
+      { index: 1, name: "RTX 3090", vramTotalMB: 24564, vramUsedMB: 8000, vramFreeMB: 16564, computeCapability: "8.6" },
+    ],
+    totalVRAMMB: 49128,
+    availableVRAMMB: 39128,
+    cudaAvailable: true,
+  }
+
+  test("estimateVRAM returns MB with 20% overhead", () => {
+    // 1GB model = ~1220MB VRAM needed
+    const vram = GPU.estimateVRAM(1024 * 1024 * 1024, "q4_k_m")
+    expect(vram).toBeGreaterThan(1000)
+    expect(vram).toBeLessThan(1500)
+  })
+
+  test("findBestGPU picks GPU with most free VRAM", () => {
+    const gpu = GPU.findBestGPU(mockProfile, 10000)
+    expect(gpu).toBeDefined()
+    expect(gpu!.index).toBe(0) // 22564MB free > 16564MB free
+  })
+
+  test("findBestGPU returns undefined if nothing fits", () => {
+    const gpu = GPU.findBestGPU(mockProfile, 50000)
+    expect(gpu).toBeUndefined()
+  })
+
+  test("canFit returns true when enough VRAM", () => {
+    expect(GPU.canFit(mockProfile, 30000)).toBe(true)
+  })
+
+  test("canFit returns false when not enough VRAM", () => {
+    expect(GPU.canFit(mockProfile, 50000)).toBe(false)
+  })
+
+  test("suggestQuantization picks highest quality that fits", () => {
+    const sizes: Record<string, number> = {
+      fp16: 14_000_000_000,
+      q8_0: 8_000_000_000,
+      q5_k_m: 5_000_000_000,
+      q4_k_m: 4_000_000_000,
+      q2_k: 2_500_000_000,
+    }
+    const result = GPU.suggestQuantization(10000, sizes)
+    expect(result).toBeDefined()
+    if (result) expect(["q4_k_m", "q5_k_m", "q8_0", "fp16"]).toContain(result)
+  })
+
+  test("suggestQuantization returns undefined if nothing fits", () => {
+    const sizes: Record<string, number> = {
+      fp16: 100_000_000_000,
+      q2_k: 50_000_000_000,
+    }
+    const result = GPU.suggestQuantization(100, sizes)
+    expect(result).toBeUndefined()
+  })
+})
+
+// ── Hub ──
+
+describe("HuggingFace Hub utilities", () => {
+  test("parseQuant extracts quantization from GGUF filename", () => {
+    expect(Hub.parseQuant("model-q4_k_m.gguf")).toBe("q4_k_m")
+    expect(Hub.parseQuant("Llama-3.1-8B-Q5_K_M.gguf")).toBe("q5_k_m")
+    expect(Hub.parseQuant("model-q8_0.gguf")).toBe("q8_0")
+    expect(Hub.parseQuant("model-fp16.gguf")).toBe("fp16")
+  })
+
+  test("parseQuant returns undefined for unknown", () => {
+    expect(Hub.parseQuant("model.bin")).toBeUndefined()
+    expect(Hub.parseQuant("config.json")).toBeUndefined()
+  })
+
+  test("listGGUF filters GGUF files from siblings", () => {
+    const siblings = [
+      { rfilename: "model-q4_k_m.gguf" },
+      { rfilename: "config.json" },
+      { rfilename: "tokenizer.json" },
+      { rfilename: "model-q8_0.gguf" },
+    ]
+    const ggufs = Hub.listGGUF(siblings)
+    expect(ggufs).toHaveLength(2)
+    expect(ggufs).toContain("model-q4_k_m.gguf")
+    expect(ggufs).toContain("model-q8_0.gguf")
+  })
+
+  test("downloadURL builds correct URL", () => {
+    const url = Hub.downloadURL("meta-llama/Llama-3.1-8B", "model.gguf")
+    expect(url).toBe("https://huggingface.co/meta-llama/Llama-3.1-8B/resolve/main/model.gguf")
+  })
+
+  test("buildArtifact creates valid artifact", () => {
+    const artifact = Hub.buildArtifact("meta-llama/Llama-3.1-8B", "model-q4_k_m.gguf", 5_000_000_000, "abc123")
+    expect(artifact.repo).toBe("meta-llama/Llama-3.1-8B")
+    expect(artifact.filename).toBe("model-q4_k_m.gguf")
+    expect(artifact.format).toBe("gguf")
+    expect(artifact.quantization).toBe("q4_k_m")
+    expect(artifact.sizeBytes).toBe(5_000_000_000)
+    expect(artifact.sha256).toBe("abc123")
+  })
+
+  test("buildArtifact detects safetensors format", () => {
+    const artifact = Hub.buildArtifact("BAAI/bge-small", "model.safetensors", 130_000_000)
+    expect(artifact.format).toBe("safetensors")
+  })
+})
+
+// ── RAG ──
+
+describe("RAG assets", () => {
+  test("EMBEDDING_MODELS has well-known entries", () => {
+    expect(RAG.EMBEDDING_MODELS.length).toBeGreaterThan(0)
+    const ids = RAG.EMBEDDING_MODELS.map(m => m.id)
+    expect(ids).toContain("bge-small-en")
+    expect(ids).toContain("nomic-embed")
+    expect(ids).toContain("all-minilm-l6")
+  })
+
+  test("RERANKER_MODELS has well-known entries", () => {
+    expect(RAG.RERANKER_MODELS.length).toBeGreaterThan(0)
+    const ids = RAG.RERANKER_MODELS.map(m => m.id)
+    expect(ids).toContain("bge-reranker-base")
+  })
+
+  test("embeddingAsset builds correct RAGAsset", () => {
+    const model = RAG.EMBEDDING_MODELS[0]
+    const asset = RAG.embeddingAsset(model)
+    expect(asset.type).toBe("embedding")
+    expect(asset.repo).toBe(model.repo)
+    expect(asset.dimensions).toBe(model.dimensions)
+  })
+
+  test("rerankerAsset builds correct RAGAsset", () => {
+    const model = RAG.RERANKER_MODELS[0]
+    const asset = RAG.rerankerAsset(model)
+    expect(asset.type).toBe("reranker")
+    expect(asset.repo).toBe(model.repo)
+  })
+
+  test("recommendForVRAM filters by available memory", async () => {
+    const { embeddings, rerankers } = await RAG.recommendForVRAM(500) // 500MB
+    // Should only include small models
+    for (const e of embeddings) {
+      expect(e.sizeBytes).toBeLessThan(500 * 1024 * 1024 * 1.2)
+    }
+  })
+
+  test("recommendForVRAM returns all when plenty of VRAM", async () => {
+    const { embeddings } = await RAG.recommendForVRAM(100000) // 100GB
+    expect(embeddings.length).toBe(RAG.EMBEDDING_MODELS.length)
+  })
+})

package/test/provider/provider-category.test.ts

@@ -0,0 +1,190 @@
+import { test, expect, describe } from "bun:test"
+import { Schema } from "effect"
+import { Provider } from "@/provider/provider"
+import { ProviderID, ModelID } from "../../src/provider/schema"
+import { LOCAL_PROVIDERS, CUSTOM_PROVIDERS, CLOUD_PROVIDERS } from "@/provider/custom-loaders"
+import { ProviderCategory, Info } from "@/provider/provider-schemas"
+
+const local = LOCAL_PROVIDERS as readonly string[]
+const custom = CUSTOM_PROVIDERS as readonly string[]
+const cloud = CLOUD_PROVIDERS as readonly string[]
+
+describe("provider category constants", () => {
+  test("LOCAL_PROVIDERS contains expected local providers", () => {
+    expect(local).toContain("ollama")
+    expect(local).toContain("lmstudio")
+    expect(local).toContain("vllm")
+    expect(local).toContain("text-generation-webui")
+    expect(local).toContain("llama.cpp")
+  })
+
+  test("CUSTOM_PROVIDERS contains expected custom providers", () => {
+    expect(custom).toContain("openrouter")
+    expect(custom).toContain("llmgateway")
+    expect(custom).toContain("nvidia")
+    expect(custom).toContain("vercel")
+    expect(custom).toContain("zenmux")
+    expect(custom).toContain("cerebras")
+  })
+
+  test("CLOUD_PROVIDERS contains expected cloud providers", () => {
+    expect(cloud).toContain("anthropic")
+    expect(cloud).toContain("openai")
+    expect(cloud).toContain("xai")
+    expect(cloud).toContain("saeeol")
+    expect(cloud).toContain("azure")
+    expect(cloud).toContain("amazon-bedrock")
+    expect(cloud).toContain("google-vertex")
+    expect(cloud).toContain("google-vertex-anthropic")
+    expect(cloud).toContain("github-copilot")
+  })
+
+  test("no overlap between categories", () => {
+    const localSet = new Set(local)
+    const customSet = new Set(custom)
+    const cloudSet = new Set(cloud)
+
+    for (const id of localSet) {
+      expect(customSet.has(id as string)).toBe(false)
+      expect(cloudSet.has(id as string)).toBe(false)
+    }
+    for (const id of customSet) {
+      expect(localSet.has(id as string)).toBe(false)
+      expect(cloudSet.has(id as string)).toBe(false)
+    }
+  })
+
+  test("all arrays are non-empty", () => {
+    expect(local.length).toBeGreaterThan(0)
+    expect(custom.length).toBeGreaterThan(0)
+    expect(cloud.length).toBeGreaterThan(0)
+  })
+})
+
+describe("ProviderCategory schema", () => {
+  test("ProviderCategory accepts valid values", () => {
+    for (const val of ["local", "custom", "cloud"] as const) {
+      const result = Schema.decodeSync(ProviderCategory)(val)
+      expect(result).toBe(val)
+    }
+  })
+
+  test("ProviderCategory rejects invalid values", () => {
+    expect(() => Schema.decodeSync(ProviderCategory)("invalid" as any)).toThrow()
+  })
+})
+
+describe("Info schema with category", () => {
+  function makeInfo(cat: "local" | "custom" | "cloud") {
+    return {
+      id: "test" as any,
+      name: "Test",
+      category: cat,
+      source: "config" as const,
+      env: [] as string[],
+      options: {} as Record<string, any>,
+      models: {} as Record<string, any>,
+    }
+  }
+
+  test("Info decodes with category field", () => {
+    const parsed = Schema.decodeSync(Info)(makeInfo("cloud"))
+    expect(parsed.category).toBe("cloud")
+  })
+
+  test("Info rejects missing category", () => {
+    const missing = {
+      id: "test" as any,
+      name: "Test",
+      source: "config" as const,
+      env: [] as string[],
+      options: {} as Record<string, any>,
+      models: {} as Record<string, any>,
+    }
+    expect(() => Schema.decodeSync(Info)(missing as any)).toThrow()
+  })
+
+  test("Info accepts all valid categories", () => {
+    for (const cat of ["local", "custom", "cloud"] as const) {
+      expect(Schema.decodeSync(Info)(makeInfo(cat)).category).toBe(cat)
+    }
+  })
+})
+
+describe("getCategory classification", () => {
+  function getCategory(id: string): "local" | "custom" | "cloud" {
+    if (local.includes(id)) return "local"
+    if (custom.includes(id)) return "custom"
+    return "cloud"
+  }
+
+  test("local providers classified correctly", () => {
+    expect(getCategory("ollama")).toBe("local")
+    expect(getCategory("lmstudio")).toBe("local")
+    expect(getCategory("vllm")).toBe("local")
+    expect(getCategory("text-generation-webui")).toBe("local")
+    expect(getCategory("llama.cpp")).toBe("local")
+  })
+
+  test("custom providers classified correctly", () => {
+    expect(getCategory("openrouter")).toBe("custom")
+    expect(getCategory("llmgateway")).toBe("custom")
+    expect(getCategory("nvidia")).toBe("custom")
+    expect(getCategory("vercel")).toBe("custom")
+    expect(getCategory("cerebras")).toBe("custom")
+  })
+
+  test("cloud providers classified correctly", () => {
+    expect(getCategory("anthropic")).toBe("cloud")
+    expect(getCategory("openai")).toBe("cloud")
+    expect(getCategory("saeeol")).toBe("cloud")
+    expect(getCategory("github-copilot")).toBe("cloud")
+  })
+
+  test("unknown providers default to cloud", () => {
+    expect(getCategory("some-new-provider")).toBe("cloud")
+    expect(getCategory("future-ai")).toBe("cloud")
+  })
+})
+
+describe("fromModelsDevProvider assigns category", () => {
+  test("fromModelsDevProvider returns custom category", () => {
+    const { fromModelsDevProvider } = require("@/provider/provider-schemas")
+    const mockProvider = {
+      id: "test-provider",
+      name: "Test Provider",
+      env: [],
+      models: {
+        "test-model": {
+          id: "test-model",
+          name: "Test Model",
+          limit: { context: 4096, output: 2048 },
+          cost: {},
+        },
+      },
+    }
+    const result = fromModelsDevProvider(mockProvider)
+    expect(result.category).toBe("custom")
+  })
+})
+
+describe("provider re-exports", () => {
+  test("Provider exports ProviderCategory", () => {
+    expect(Provider.ProviderCategory).toBeDefined()
+  })
+
+  test("Provider exports LOCAL_PROVIDERS", () => {
+    expect(Provider.LOCAL_PROVIDERS).toBeDefined()
+    expect(Provider.LOCAL_PROVIDERS).toContain("ollama")
+  })
+
+  test("Provider exports CUSTOM_PROVIDERS", () => {
+    expect(Provider.CUSTOM_PROVIDERS).toBeDefined()
+    expect(Provider.CUSTOM_PROVIDERS).toContain("openrouter")
+  })
+
+  test("Provider exports CLOUD_PROVIDERS", () => {
+    expect(Provider.CLOUD_PROVIDERS).toBeDefined()
+    expect(Provider.CLOUD_PROVIDERS).toContain("anthropic")
+  })
+})