@symerian/symi 3.0.18 → 3.0.19

package/extensions/model-equalizer/index.ts

@@ -1,80 +0,0 @@
-import type { SymiPluginApi } from "symi/plugin-sdk";
-import { buildProviderMap, isLocalProvider, resolveDefaultProvider } from "./src/detection.js";
-import { buildEnhancement } from "./src/enhancer.js";
-import { resolveConfig } from "./src/types.js";
-
-const plugin = {
-  id: "model-equalizer",
-  name: "Model Equalizer",
-  description:
-    "Automatically enhances prompts for local models (Ollama, vLLM, LM Studio, llama.cpp) with chain-of-thought scaffolding and self-verification to close the quality gap with paid API models.",
-
-  register(api: SymiPluginApi) {
-    const config = resolveConfig(api.pluginConfig);
-    const logger = api.logger;
-
-    if (!config.enabled) {
-      logger.debug?.("[model-equalizer] disabled via config");
-      return;
-    }
-
-    // Build provider→isLocal map from config at registration time
-    const providerMap = buildProviderMap(api.config);
-
-    // Cached provider per session (populated by llm_input)
-    const sessionProviders = new Map<string, string>();
-
-    // -----------------------------------------------------------------------
-    // llm_input (priority 100) — detect and cache provider per session
-    // -----------------------------------------------------------------------
-    api.on(
-      "llm_input",
-      (event, ctx) => {
-        if (ctx.sessionKey) {
-          sessionProviders.set(ctx.sessionKey, event.provider);
-        }
-      },
-      { priority: 100 },
-    );
-
-    // -----------------------------------------------------------------------
-    // before_prompt_build (priority 180) — inject enhancement for local models
-    // Runs before learning-loop's 200 so learnings are prepended first.
-    // -----------------------------------------------------------------------
-    api.on(
-      "before_prompt_build",
-      async (event, ctx) => {
-        try {
-          const provider =
-            sessionProviders.get(ctx.sessionKey ?? "") ?? resolveDefaultProvider(api.config);
-
-          if (!provider) return undefined;
-
-          const isLocal =
-            providerMap.get(provider.trim().toLowerCase()) ?? isLocalProvider(provider);
-          if (!isLocal) return undefined;
-
-          const enhancement = buildEnhancement(event.prompt, {
-            intensity: config.intensity,
-            minPromptLength: config.minPromptLength,
-          });
-          if (!enhancement) return undefined;
-
-          logger.debug?.(`[model-equalizer] enhancing prompt for local provider "${provider}"`);
-          return { prependContext: enhancement };
-        } catch (err) {
-          logger.warn(`[model-equalizer] before_prompt_build failed: ${String(err)}`);
-          return undefined;
-        }
-      },
-      { priority: 180 },
-    );
-
-    logger.debug?.(
-      `[model-equalizer] registered (intensity=${config.intensity}, ` +
-        `${providerMap.size} providers mapped)`,
-    );
-  },
-};
-
-export default plugin;

package/extensions/model-equalizer/skills/model-equalizer/SKILL.md

@@ -1,58 +0,0 @@
----
-name: model-equalizer
-description: Shows model-equalizer status and whether prompt enhancement is active for the current model.
-metadata: { "symi": {} }
----
-
-# Model Equalizer Status
-
-The model-equalizer extension automatically detects local LLM providers (Ollama, vLLM, LM Studio, llama.cpp) and injects prompt enhancement techniques to improve response quality.
-
-## When to Activate
-
-Activate this skill when the user:
-
-- Asks about model-equalizer status
-- Wants to know if prompt enhancement is active
-- Asks what enhancement techniques are being applied
-- Mentions "equalizer" in the context of model quality
-
-## What to Report
-
-When invoked, check and report:
-
-1. **Extension status**: Whether model-equalizer is enabled in the plugin config
-2. **Current provider detection**: Whether the active provider is detected as local
-3. **Enhancement intensity**: The configured intensity level (light / standard / aggressive)
-4. **Techniques applied**: List the specific enhancement techniques being injected
-
-## Enhancement Techniques
-
-Depending on the configured intensity and prompt complexity, these techniques may be applied:
-
-### Standard (default for simple prompts)
-
-- Step-by-step reasoning
-- Self-verification after drafting
-- Thoroughness anchoring
-- Instruction following reinforcement
-
-### Complex (auto-detected or aggressive intensity)
-
-- Problem decomposition into sub-problems
-- Step-by-step reasoning per sub-problem
-- Accuracy and completeness verification
-- Detailed responses with examples
-- Instruction following reinforcement
-- Structured output formatting
-
-### Light
-
-- Condensed step-by-step + verify + be thorough reminder
-
-## Known Local Providers
-
-The following provider names are recognized as local:
-`ollama`, `vllm`, `lmstudio`, `lm-studio`, `lm_studio`, `llama.cpp`, `llama-cpp`, `llamacpp`, `local`
-
-Any provider with a `baseUrl` containing `localhost`, `127.0.0.1`, or `[::1]` is also treated as local.

package/extensions/model-equalizer/src/detection.ts

@@ -1,62 +0,0 @@
-import type { SymiConfig } from "symi/plugin-sdk";
-
-const LOCAL_PROVIDERS = new Set([
-  "ollama",
-  "vllm",
-  "lmstudio",
-  "lm-studio",
-  "lm_studio",
-  "llama.cpp",
-  "llama-cpp",
-  "llamacpp",
-  "local",
-]);
-
-/**
- * Check whether a provider name is a known local provider.
- */
-export function isLocalProvider(provider: string): boolean {
-  return LOCAL_PROVIDERS.has(provider.trim().toLowerCase());
-}
-
-/**
- * Check whether a base URL points to a local server.
- */
-export function isLocalBaseUrl(baseUrl: string | undefined): boolean {
-  if (!baseUrl) return false;
-  const url = baseUrl.trim().toLowerCase();
-  return url.includes("localhost") || url.includes("127.0.0.1") || url.includes("[::1]");
-}
-
-/**
- * Build a map of provider-name → isLocal from the full config.
- */
-export function buildProviderMap(config: SymiConfig): Map<string, boolean> {
-  const map = new Map<string, boolean>();
-  const providers = config.models?.providers ?? {};
-  for (const [name, cfg] of Object.entries(providers)) {
-    const normalized = name.trim().toLowerCase();
-    map.set(normalized, isLocalProvider(normalized) || isLocalBaseUrl(cfg.baseUrl));
-  }
-  return map;
-}
-
-/**
- * Extract the provider name from the default agent's model string.
- * Model strings are formatted as "provider/model-id".
- * Returns null if no default agent or no model configured.
- */
-export function resolveDefaultProvider(config: SymiConfig): string | null {
-  const agents = config.agents?.list ?? [];
-  const defaultAgent = agents.find((a) => a.default === true) ?? agents[0];
-  if (!defaultAgent?.model) return null;
-
-  const modelStr =
-    typeof defaultAgent.model === "string" ? defaultAgent.model : defaultAgent.model.primary;
-  if (!modelStr) return null;
-
-  const slashIdx = modelStr.indexOf("/");
-  if (slashIdx <= 0) return null;
-
-  return modelStr.slice(0, slashIdx).trim().toLowerCase();
-}

package/extensions/model-equalizer/src/enhancer.ts

@@ -1,63 +0,0 @@
-import type { ModelEqualizerConfig } from "./types.js";
-
-export type EnhancerOptions = {
-  intensity?: ModelEqualizerConfig["intensity"];
-  minPromptLength?: number;
-};
-
-const STANDARD_BLOCK = `<model-equalizer>
-You are operating in enhanced reasoning mode. Apply these techniques:
-1. Think step-by-step: break the problem down before answering
-2. Self-verify: after drafting your response, check for errors and correct them
-3. Be thorough: provide complete, detailed, professional-quality responses
-4. Follow instructions precisely: address every part of the user's request
-</model-equalizer>`;
-
-const COMPLEX_BLOCK = `<model-equalizer>
-You are operating in enhanced reasoning mode. Apply these techniques:
-1. Decompose: identify all sub-problems before solving
-2. Think step-by-step: reason through each sub-problem carefully
-3. Self-verify: review your complete response for accuracy and completeness
-4. Be thorough: provide detailed, professional-quality responses with examples
-5. Follow instructions precisely: address every part of the user's request
-6. Structure your output: use headers, lists, and code blocks for clarity
-</model-equalizer>`;
-
-const LIGHT_BLOCK = `<model-equalizer>
-Think step-by-step. Verify your answer before responding. Be thorough and precise.
-</model-equalizer>`;
-
-/**
- * Detect whether a prompt is "complex" based on heuristics:
- * - length > 200 chars
- * - contains code blocks (```)
- * - contains multiple question marks (multi-part question)
- */
-function isComplexPrompt(prompt: string): boolean {
-  if (prompt.length > 200) return true;
-  if (prompt.includes("```")) return true;
-  const questionMarks = (prompt.match(/\?/g) ?? []).length;
-  if (questionMarks >= 2) return true;
-  return false;
-}
-
-/**
- * Build a prompt enhancement block for local models.
- * Returns null if enhancement should be skipped.
- */
-export function buildEnhancement(prompt: string, options?: EnhancerOptions): string | null {
-  const minLen = options?.minPromptLength ?? 10;
-  if (prompt.trim().length < minLen) return null;
-
-  const intensity = options?.intensity ?? "standard";
-
-  if (intensity === "light") {
-    return LIGHT_BLOCK;
-  }
-
-  if (intensity === "aggressive" || isComplexPrompt(prompt)) {
-    return COMPLEX_BLOCK;
-  }
-
-  return STANDARD_BLOCK;
-}

package/extensions/model-equalizer/src/test/detection.test.ts

@@ -1,218 +0,0 @@
-import type { SymiConfig } from "symi/plugin-sdk";
-import { describe, it, expect } from "vitest";
-import {
-  isLocalProvider,
-  isLocalBaseUrl,
-  buildProviderMap,
-  resolveDefaultProvider,
-} from "../detection.js";
-
-// ---------------------------------------------------------------------------
-// isLocalProvider
-// ---------------------------------------------------------------------------
-describe("isLocalProvider", () => {
-  it.each([
-    "ollama",
-    "vllm",
-    "lmstudio",
-    "lm-studio",
-    "lm_studio",
-    "llama.cpp",
-    "llama-cpp",
-    "llamacpp",
-    "local",
-  ])("should detect '%s' as local", (provider) => {
-    expect(isLocalProvider(provider)).toBe(true);
-  });
-
-  it("should be case-insensitive", () => {
-    expect(isLocalProvider("Ollama")).toBe(true);
-    expect(isLocalProvider("VLLM")).toBe(true);
-    expect(isLocalProvider("LMStudio")).toBe(true);
-  });
-
-  it("should trim whitespace", () => {
-    expect(isLocalProvider("  ollama  ")).toBe(true);
-  });
-
-  it.each(["openai", "anthropic", "google", "azure", "bedrock", "mistral"])(
-    "should not detect '%s' as local",
-    (provider) => {
-      expect(isLocalProvider(provider)).toBe(false);
-    },
-  );
-
-  it("should return false for empty string", () => {
-    expect(isLocalProvider("")).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// isLocalBaseUrl
-// ---------------------------------------------------------------------------
-describe("isLocalBaseUrl", () => {
-  it("should detect localhost URLs", () => {
-    expect(isLocalBaseUrl("http://localhost:11434")).toBe(true);
-    expect(isLocalBaseUrl("http://localhost:8080/v1")).toBe(true);
-    expect(isLocalBaseUrl("https://localhost")).toBe(true);
-  });
-
-  it("should detect 127.0.0.1 URLs", () => {
-    expect(isLocalBaseUrl("http://127.0.0.1:11434")).toBe(true);
-    expect(isLocalBaseUrl("http://127.0.0.1:5000/v1")).toBe(true);
-  });
-
-  it("should detect IPv6 loopback URLs", () => {
-    expect(isLocalBaseUrl("http://[::1]:11434")).toBe(true);
-  });
-
-  it("should be case-insensitive", () => {
-    expect(isLocalBaseUrl("HTTP://LOCALHOST:8080")).toBe(true);
-  });
-
-  it("should trim whitespace", () => {
-    expect(isLocalBaseUrl("  http://localhost:11434  ")).toBe(true);
-  });
-
-  it("should not detect remote URLs", () => {
-    expect(isLocalBaseUrl("https://api.openai.com/v1")).toBe(false);
-    expect(isLocalBaseUrl("https://api.anthropic.com")).toBe(false);
-  });
-
-  it("should return false for undefined", () => {
-    expect(isLocalBaseUrl(undefined)).toBe(false);
-  });
-
-  it("should return false for empty string", () => {
-    expect(isLocalBaseUrl("")).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// buildProviderMap
-// ---------------------------------------------------------------------------
-describe("buildProviderMap", () => {
-  it("should map known local providers as local", () => {
-    const config: SymiConfig = {
-      models: {
-        providers: {
-          ollama: { baseUrl: "http://localhost:11434", models: [] },
-          openai: { baseUrl: "https://api.openai.com/v1", models: [] },
-        },
-      },
-    };
-    const map = buildProviderMap(config);
-    expect(map.get("ollama")).toBe(true);
-    expect(map.get("openai")).toBe(false);
-  });
-
-  it("should detect local by baseUrl even with unknown name", () => {
-    const config: SymiConfig = {
-      models: {
-        providers: {
-          "my-custom-model": { baseUrl: "http://localhost:8080/v1", models: [] },
-        },
-      },
-    };
-    const map = buildProviderMap(config);
-    expect(map.get("my-custom-model")).toBe(true);
-  });
-
-  it("should normalize provider names to lowercase", () => {
-    const config: SymiConfig = {
-      models: {
-        providers: {
-          Ollama: { baseUrl: "http://remote.example.com", models: [] },
-        },
-      },
-    };
-    const map = buildProviderMap(config);
-    expect(map.get("ollama")).toBe(true); // Known local name wins
-  });
-
-  it("should return empty map when no providers configured", () => {
-    const config: SymiConfig = {};
-    const map = buildProviderMap(config);
-    expect(map.size).toBe(0);
-  });
-
-  it("should handle providers with no baseUrl using name-only detection", () => {
-    const config: SymiConfig = {
-      models: {
-        providers: {
-          vllm: { baseUrl: "", models: [] },
-        },
-      },
-    };
-    const map = buildProviderMap(config);
-    expect(map.get("vllm")).toBe(true); // Known local name
-  });
-});
-
-// ---------------------------------------------------------------------------
-// resolveDefaultProvider
-// ---------------------------------------------------------------------------
-describe("resolveDefaultProvider", () => {
-  it("should extract provider from default agent's model string", () => {
-    const config: SymiConfig = {
-      agents: {
-        list: [{ id: "main", default: true, model: "ollama/llama3.1" }],
-      },
-    };
-    expect(resolveDefaultProvider(config)).toBe("ollama");
-  });
-
-  it("should extract provider from object-form model config", () => {
-    const config: SymiConfig = {
-      agents: {
-        list: [{ id: "main", default: true, model: { primary: "vllm/mistral-7b" } }],
-      },
-    };
-    expect(resolveDefaultProvider(config)).toBe("vllm");
-  });
-
-  it("should fall back to the first agent when no default is set", () => {
-    const config: SymiConfig = {
-      agents: {
-        list: [
-          { id: "first", model: "lmstudio/phi-3" },
-          { id: "second", model: "openai/gpt-4" },
-        ],
-      },
-    };
-    expect(resolveDefaultProvider(config)).toBe("lmstudio");
-  });
-
-  it("should return null when no agents are configured", () => {
-    const config: SymiConfig = {};
-    expect(resolveDefaultProvider(config)).toBeNull();
-  });
-
-  it("should return null when agent has no model", () => {
-    const config: SymiConfig = {
-      agents: { list: [{ id: "main", default: true }] },
-    };
-    expect(resolveDefaultProvider(config)).toBeNull();
-  });
-
-  it("should return null for model strings without a slash", () => {
-    const config: SymiConfig = {
-      agents: { list: [{ id: "main", default: true, model: "gpt-4" }] },
-    };
-    expect(resolveDefaultProvider(config)).toBeNull();
-  });
-
-  it("should return null for model strings starting with a slash", () => {
-    const config: SymiConfig = {
-      agents: { list: [{ id: "main", default: true, model: "/model-only" }] },
-    };
-    expect(resolveDefaultProvider(config)).toBeNull();
-  });
-
-  it("should normalize the provider name to lowercase", () => {
-    const config: SymiConfig = {
-      agents: { list: [{ id: "main", default: true, model: "Ollama/Llama3" }] },
-    };
-    expect(resolveDefaultProvider(config)).toBe("ollama");
-  });
-});

package/extensions/model-equalizer/src/test/enhancer.test.ts

@@ -1,137 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { buildEnhancement } from "../enhancer.js";
-
-describe("buildEnhancement", () => {
-  // ---------------------------------------------------------------------------
-  // Skip conditions
-  // ---------------------------------------------------------------------------
-  describe("skip conditions", () => {
-    it("should return null for very short prompts", () => {
-      expect(buildEnhancement("hi")).toBeNull();
-      expect(buildEnhancement("ok")).toBeNull();
-    });
-
-    it("should return null for empty prompt", () => {
-      expect(buildEnhancement("")).toBeNull();
-    });
-
-    it("should return null for whitespace-only prompt", () => {
-      expect(buildEnhancement("      ")).toBeNull();
-    });
-
-    it("should respect custom minPromptLength", () => {
-      expect(buildEnhancement("hello world", { minPromptLength: 20 })).toBeNull();
-      expect(buildEnhancement("hello world and more!", { minPromptLength: 20 })).not.toBeNull();
-    });
-  });
-
-  // ---------------------------------------------------------------------------
-  // Standard enhancement
-  // ---------------------------------------------------------------------------
-  describe("standard enhancement", () => {
-    it("should return standard block for normal prompts", () => {
-      const result = buildEnhancement("What is the capital of France?");
-      expect(result).not.toBeNull();
-      expect(result).toContain("<model-equalizer>");
-      expect(result).toContain("</model-equalizer>");
-      expect(result).toContain("Think step-by-step");
-      expect(result).toContain("Self-verify");
-    });
-
-    it("should not include decompose step for simple prompts", () => {
-      const result = buildEnhancement("What is 2+2?");
-      expect(result).not.toBeNull();
-      expect(result).not.toContain("Decompose");
-    });
-  });
-
-  // ---------------------------------------------------------------------------
-  // Complex prompt detection
-  // ---------------------------------------------------------------------------
-  describe("complex prompt detection", () => {
-    it("should use complex block for long prompts (>200 chars)", () => {
-      const longPrompt = "a".repeat(201);
-      const result = buildEnhancement(longPrompt);
-      expect(result).not.toBeNull();
-      expect(result).toContain("Decompose");
-      expect(result).toContain("Structure your output");
-    });
-
-    it("should use complex block for prompts with code blocks", () => {
-      const prompt = "Fix this code:\n```\nconst x = 1;\n```";
-      const result = buildEnhancement(prompt);
-      expect(result).not.toBeNull();
-      expect(result).toContain("Decompose");
-    });
-
-    it("should use complex block for multi-question prompts", () => {
-      const prompt = "What is X? How does Y work?";
-      const result = buildEnhancement(prompt);
-      expect(result).not.toBeNull();
-      expect(result).toContain("Decompose");
-    });
-
-    it("should use standard block for single-question prompts", () => {
-      const prompt = "How does this work?";
-      const result = buildEnhancement(prompt);
-      expect(result).not.toBeNull();
-      expect(result).not.toContain("Decompose");
-    });
-  });
-
-  // ---------------------------------------------------------------------------
-  // Intensity levels
-  // ---------------------------------------------------------------------------
-  describe("intensity levels", () => {
-    it("should use light block for light intensity", () => {
-      const result = buildEnhancement("Explain this concept please", {
-        intensity: "light",
-      });
-      expect(result).not.toBeNull();
-      expect(result).toContain("<model-equalizer>");
-      expect(result).toContain("Think step-by-step");
-      // Light block is compact, no numbered list
-      expect(result).not.toContain("1.");
-    });
-
-    it("should use complex block for aggressive intensity regardless of prompt", () => {
-      const result = buildEnhancement("Simple question?", {
-        intensity: "aggressive",
-      });
-      expect(result).not.toBeNull();
-      expect(result).toContain("Decompose");
-      expect(result).toContain("Structure your output");
-    });
-
-    it("should use standard block for standard intensity with simple prompt", () => {
-      const result = buildEnhancement("Explain this concept", {
-        intensity: "standard",
-      });
-      expect(result).not.toBeNull();
-      expect(result).toContain("Think step-by-step");
-      expect(result).not.toContain("Decompose");
-    });
-  });
-
-  // ---------------------------------------------------------------------------
-  // Block format
-  // ---------------------------------------------------------------------------
-  describe("block format", () => {
-    it("should wrap content in <model-equalizer> tags", () => {
-      const result = buildEnhancement("Tell me about something");
-      expect(result).not.toBeNull();
-      expect(result!.startsWith("<model-equalizer>")).toBe(true);
-      expect(result!.endsWith("</model-equalizer>")).toBe(true);
-    });
-
-    it("should be reasonably sized (under 600 chars)", () => {
-      const standard = buildEnhancement("Tell me about something");
-      expect(standard).not.toBeNull();
-      expect(standard!.length).toBeLessThan(600);
-
-      const complex = buildEnhancement("a".repeat(201));
-      expect(complex).not.toBeNull();
-      expect(complex!.length).toBeLessThan(600);
-    });
-  });
-});