nemoris 0.1.0 → 0.1.2

package/src/providers/circuit-breaker.js

@@ -1,136 +1,136 @@
-const DEFAULT_TRANSIENT_CODES = new Set([408, 429, 500, 502, 503, 504]);
-
-export function ensureBreakerSchema(db) {
-  db.exec(`
-    create table if not exists provider_breakers (
-      provider_key text primary key,
-      state text not null default 'closed',
-      failure_count integer not null default 0,
-      last_failure_at text,
-      last_success_at text,
-      opened_at text,
-      half_open_at text
-    );
-  `);
-}
-
-export class CircuitBreaker {
-  constructor(providerKey, db, config = {}) {
-    this._key = providerKey;
-    this._db = db;
-    this._failureThreshold = config.failureThreshold ?? 5;
-    this._resetTimeoutSeconds = config.resetTimeoutSeconds ?? 30;
-    this._transientCodes = new Set(config.transientCodes ?? DEFAULT_TRANSIENT_CODES);
-
-    ensureBreakerSchema(db);
-    this._load();
-  }
-
-  static forProvider(providerKey, db, config = {}) {
-    return new CircuitBreaker(providerKey, db, config);
-  }
-
-  _load() {
-    const row = this._db.prepare("select * from provider_breakers where provider_key = ?").get(this._key);
-    if (row) {
-      this._state = row.state;
-      this._failureCount = row.failure_count;
-      this._lastFailureAt = row.last_failure_at;
-      this._lastSuccessAt = row.last_success_at;
-      this._openedAt = row.opened_at;
-      this._halfOpenAt = row.half_open_at;
-    } else {
-      this._state = "closed";
-      this._failureCount = 0;
-      this._lastFailureAt = null;
-      this._lastSuccessAt = null;
-      this._openedAt = null;
-      this._halfOpenAt = null;
-    }
-  }
-
-  _persist() {
-    this._db.prepare(`
-      insert into provider_breakers (provider_key, state, failure_count, last_failure_at, last_success_at, opened_at, half_open_at)
-      values (?, ?, ?, ?, ?, ?, ?)
-      on conflict(provider_key) do update set
-        state = excluded.state,
-        failure_count = excluded.failure_count,
-        last_failure_at = excluded.last_failure_at,
-        last_success_at = excluded.last_success_at,
-        opened_at = excluded.opened_at,
-        half_open_at = excluded.half_open_at
-    `).run(
-      this._key,
-      this._state,
-      this._failureCount,
-      this._lastFailureAt,
-      this._lastSuccessAt,
-      this._openedAt,
-      this._halfOpenAt
-    );
-  }
-
-  _checkHalfOpen() {
-    if (this._state !== "open") return;
-    if (!this._openedAt) return;
-    const elapsed = (Date.now() - new Date(this._openedAt).getTime()) / 1000;
-    if (elapsed >= this._resetTimeoutSeconds) {
-      this._state = "half_open";
-      this._halfOpenAt = new Date().toISOString();
-      this._persist();
-    }
-  }
-
-  isClosed() {
-    this._checkHalfOpen();
-    return this._state === "closed";
-  }
-
-  isOpen() {
-    this._checkHalfOpen();
-    return this._state === "open";
-  }
-
-  isHalfOpen() {
-    this._checkHalfOpen();
-    return this._state === "half_open";
-  }
-
-  failureCount() {
-    return this._failureCount;
-  }
-
-  retryAfter() {
-    if (this._state !== "open" || !this._openedAt) return 0;
-    const elapsed = (Date.now() - new Date(this._openedAt).getTime()) / 1000;
-    return Math.max(0, this._resetTimeoutSeconds - elapsed);
-  }
-
-  recordSuccess() {
-    this._state = "closed";
-    this._failureCount = 0;
-    this._lastSuccessAt = new Date().toISOString();
-    this._openedAt = null;
-    this._halfOpenAt = null;
-    this._persist();
-  }
-
-  recordFailure(errorCode) {
-    if (!this._transientCodes.has(errorCode)) return;
-
-    this._failureCount += 1;
-    this._lastFailureAt = new Date().toISOString();
-
-    if (this._state === "half_open") {
-      this._state = "open";
-      this._openedAt = new Date().toISOString();
-      this._halfOpenAt = null;
-    } else if (this._failureCount >= this._failureThreshold) {
-      this._state = "open";
-      this._openedAt = new Date().toISOString();
-    }
-
-    this._persist();
-  }
-}
+const DEFAULT_TRANSIENT_CODES = new Set([408, 429, 500, 502, 503, 504]);
+
+export function ensureBreakerSchema(db) {
+  db.exec(`
+    create table if not exists provider_breakers (
+      provider_key text primary key,
+      state text not null default 'closed',
+      failure_count integer not null default 0,
+      last_failure_at text,
+      last_success_at text,
+      opened_at text,
+      half_open_at text
+    );
+  `);
+}
+
+export class CircuitBreaker {
+  constructor(providerKey, db, config = {}) {
+    this._key = providerKey;
+    this._db = db;
+    this._failureThreshold = config.failureThreshold ?? 5;
+    this._resetTimeoutSeconds = config.resetTimeoutSeconds ?? 30;
+    this._transientCodes = new Set(config.transientCodes ?? DEFAULT_TRANSIENT_CODES);
+
+    ensureBreakerSchema(db);
+    this._load();
+  }
+
+  static forProvider(providerKey, db, config = {}) {
+    return new CircuitBreaker(providerKey, db, config);
+  }
+
+  _load() {
+    const row = this._db.prepare("select * from provider_breakers where provider_key = ?").get(this._key);
+    if (row) {
+      this._state = row.state;
+      this._failureCount = row.failure_count;
+      this._lastFailureAt = row.last_failure_at;
+      this._lastSuccessAt = row.last_success_at;
+      this._openedAt = row.opened_at;
+      this._halfOpenAt = row.half_open_at;
+    } else {
+      this._state = "closed";
+      this._failureCount = 0;
+      this._lastFailureAt = null;
+      this._lastSuccessAt = null;
+      this._openedAt = null;
+      this._halfOpenAt = null;
+    }
+  }
+
+  _persist() {
+    this._db.prepare(`
+      insert into provider_breakers (provider_key, state, failure_count, last_failure_at, last_success_at, opened_at, half_open_at)
+      values (?, ?, ?, ?, ?, ?, ?)
+      on conflict(provider_key) do update set
+        state = excluded.state,
+        failure_count = excluded.failure_count,
+        last_failure_at = excluded.last_failure_at,
+        last_success_at = excluded.last_success_at,
+        opened_at = excluded.opened_at,
+        half_open_at = excluded.half_open_at
+    `).run(
+      this._key,
+      this._state,
+      this._failureCount,
+      this._lastFailureAt,
+      this._lastSuccessAt,
+      this._openedAt,
+      this._halfOpenAt
+    );
+  }
+
+  _checkHalfOpen() {
+    if (this._state !== "open") return;
+    if (!this._openedAt) return;
+    const elapsed = (Date.now() - new Date(this._openedAt).getTime()) / 1000;
+    if (elapsed >= this._resetTimeoutSeconds) {
+      this._state = "half_open";
+      this._halfOpenAt = new Date().toISOString();
+      this._persist();
+    }
+  }
+
+  isClosed() {
+    this._checkHalfOpen();
+    return this._state === "closed";
+  }
+
+  isOpen() {
+    this._checkHalfOpen();
+    return this._state === "open";
+  }
+
+  isHalfOpen() {
+    this._checkHalfOpen();
+    return this._state === "half_open";
+  }
+
+  failureCount() {
+    return this._failureCount;
+  }
+
+  retryAfter() {
+    if (this._state !== "open" || !this._openedAt) return 0;
+    const elapsed = (Date.now() - new Date(this._openedAt).getTime()) / 1000;
+    return Math.max(0, this._resetTimeoutSeconds - elapsed);
+  }
+
+  recordSuccess() {
+    this._state = "closed";
+    this._failureCount = 0;
+    this._lastSuccessAt = new Date().toISOString();
+    this._openedAt = null;
+    this._halfOpenAt = null;
+    this._persist();
+  }
+
+  recordFailure(errorCode) {
+    if (!this._transientCodes.has(errorCode)) return;
+
+    this._failureCount += 1;
+    this._lastFailureAt = new Date().toISOString();
+
+    if (this._state === "half_open") {
+      this._state = "open";
+      this._openedAt = new Date().toISOString();
+      this._halfOpenAt = null;
+    } else if (this._failureCount >= this._failureThreshold) {
+      this._state = "open";
+      this._openedAt = new Date().toISOString();
+    }
+
+    this._persist();
+  }
+}

package/src/providers/ollama.js

@@ -1,163 +1,163 @@
-import { ProviderAdapter } from "./base.js";
-
-export class OllamaAdapter extends ProviderAdapter {
-  static providerId = "ollama";
-
-  getCapabilities() {
-    return {
-      supportsToolDefinitions: true,
-      supportsToolCalls: true,
-      structuredOutputMode: "prompt_contract",
-      supportsReasoningSchema: false,
-      tokenCountingMode: "heuristic",
-      toolReliabilityTier: "medium",
-      supportsVision: false
-    };
-  }
-
-  normalizeModel(model) {
-    if (typeof model !== "string") return model;
-    return model.startsWith("ollama/") ? model.slice("ollama/".length) : model;
-  }
-
-  buildInvokePayload({ model, system, messages, tools, options }) {
-    const payload = {
-      model: this.normalizeModel(model),
-      stream: false,
-      system,
-      messages,
-      options
-    };
-    // Ollama /api/chat supports OpenAI-compatible tools array
-    if (tools?.length) payload.tools = tools;
-    return payload;
-  }
-
-  async invoke(input) {
-    return this.postJson("api/chat", this.buildInvokePayload(input), {}, {
-      timeoutMs: input.timeoutMs
-    });
-  }
-
-  normalizeResponse(raw) {
-    // Handle Ollama tool_calls (OpenAI-compatible format)
-    const toolCalls = raw?.message?.tool_calls;
-    if (Array.isArray(toolCalls) && toolCalls.length > 0) {
-      // Convert to Anthropic-style tool_use blocks for executor compatibility
-      const content = toolCalls.map((tc) => ({
-        type: "tool_use",
-        id: tc.id || `ollama_tool_${Date.now()}`,
-        name: tc.function?.name || tc.name,
-        input: tc.function?.arguments
-          ? (typeof tc.function.arguments === "string"
-              ? JSON.parse(tc.function.arguments)
-              : tc.function.arguments)
-          : {}
-      }));
-      return {
-        summary: `Tool call: ${content.map(c => c.name).join(", ")}`,
-        output: null,
-        nextActions: [],
-        reasoning: null,
-        raw,
-        content
-      };
-    }
-
-    const text = raw?.message?.content ? String(raw.message.content) : null;
-    const parsedJson = text ? this.parseStructuredJson(text) : null;
-    if (parsedJson) {
-      return {
-        summary: parsedJson.summary || "Provider returned structured JSON output.",
-        output: parsedJson.output || text,
-        nextActions: Array.isArray(parsedJson.nextActions) ? parsedJson.nextActions : [],
-        reasoning: parsedJson.analysis || null,
-        raw
-      };
-    }
-    if (text) {
-      return {
-        summary: text.slice(0, 200) || "Provider responded.",
-        output: text,
-        nextActions: [],
-        reasoning: null,
-        raw
-      };
-    }
-
-    return super.normalizeResponse(raw);
-  }
-
-  async embed({ model, input }) {
-    const payload = {
-      model: this.normalizeModel(model),
-      input
-    };
-
-    try {
-      const result = await this.postJson("api/embed", payload, {}, {
-        timeoutMs: input.timeoutMs
-      });
-      if (Array.isArray(result.embeddings) && result.embeddings.length > 0) {
-        return {
-          embeddings: result.embeddings
-        };
-      }
-      if (Array.isArray(result.embedding)) {
-        return {
-          embeddings: [result.embedding]
-        };
-      }
-      return result;
-    } catch (error) {
-      if (!String(error.message || "").includes("404")) throw error;
-      const fallback = await this.postJson("api/embeddings", payload, {}, {
-        timeoutMs: input.timeoutMs
-      });
-      if (Array.isArray(fallback.embedding)) {
-        return {
-          embeddings: [fallback.embedding]
-        };
-      }
-      return fallback;
-    }
-  }
-
-  async healthCheck() {
-    // Ollama is intentionally local-only. fetchResponse enforces loopback-only
-    // on the configured baseUrl before any health probe leaves the process.
-    const response = await this.fetchResponse("api/tags", {
-      method: "GET"
-    });
-    return {
-      ok: response.ok,
-      status: response.status
-    };
-  }
-
-  async listModels() {
-    const response = await this.fetchResponse("api/tags", {
-      method: "GET"
-    });
-    const text = await response.text();
-    let data = null;
-    if (text) {
-      try {
-        data = JSON.parse(text);
-      } catch {
-        data = null;
-      }
-    }
-    if (!response.ok) {
-      throw new Error(`Provider error ${response.status}: ${typeof data === "string" ? data : JSON.stringify(data)}`);
-    }
-
-    const models = Array.isArray(data?.models)
-      ? data.models
-          .map((item) => item?.name || item?.model || null)
-          .filter(Boolean)
-      : [];
-
-    return models;
-  }
-}
+import { ProviderAdapter } from "./base.js";
+
+export class OllamaAdapter extends ProviderAdapter {
+  static providerId = "ollama";
+
+  getCapabilities() {
+    return {
+      supportsToolDefinitions: true,
+      supportsToolCalls: true,
+      structuredOutputMode: "prompt_contract",
+      supportsReasoningSchema: false,
+      tokenCountingMode: "heuristic",
+      toolReliabilityTier: "medium",
+      supportsVision: false
+    };
+  }
+
+  normalizeModel(model) {
+    if (typeof model !== "string") return model;
+    return model.startsWith("ollama/") ? model.slice("ollama/".length) : model;
+  }
+
+  buildInvokePayload({ model, system, messages, tools, options }) {
+    const payload = {
+      model: this.normalizeModel(model),
+      stream: false,
+      system,
+      messages,
+      options
+    };
+    // Ollama /api/chat supports OpenAI-compatible tools array
+    if (tools?.length) payload.tools = tools;
+    return payload;
+  }
+
+  async invoke(input) {
+    return this.postJson("api/chat", this.buildInvokePayload(input), {}, {
+      timeoutMs: input.timeoutMs
+    });
+  }
+
+  normalizeResponse(raw) {
+    // Handle Ollama tool_calls (OpenAI-compatible format)
+    const toolCalls = raw?.message?.tool_calls;
+    if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+      // Convert to Anthropic-style tool_use blocks for executor compatibility
+      const content = toolCalls.map((tc) => ({
+        type: "tool_use",
+        id: tc.id || `ollama_tool_${Date.now()}`,
+        name: tc.function?.name || tc.name,
+        input: tc.function?.arguments
+          ? (typeof tc.function.arguments === "string"
+              ? JSON.parse(tc.function.arguments)
+              : tc.function.arguments)
+          : {}
+      }));
+      return {
+        summary: `Tool call: ${content.map(c => c.name).join(", ")}`,
+        output: null,
+        nextActions: [],
+        reasoning: null,
+        raw,
+        content
+      };
+    }
+
+    const text = raw?.message?.content ? String(raw.message.content) : null;
+    const parsedJson = text ? this.parseStructuredJson(text) : null;
+    if (parsedJson) {
+      return {
+        summary: parsedJson.summary || "Provider returned structured JSON output.",
+        output: parsedJson.output || text,
+        nextActions: Array.isArray(parsedJson.nextActions) ? parsedJson.nextActions : [],
+        reasoning: parsedJson.analysis || null,
+        raw
+      };
+    }
+    if (text) {
+      return {
+        summary: text.slice(0, 200) || "Provider responded.",
+        output: text,
+        nextActions: [],
+        reasoning: null,
+        raw
+      };
+    }
+
+    return super.normalizeResponse(raw);
+  }
+
+  async embed({ model, input }) {
+    const payload = {
+      model: this.normalizeModel(model),
+      input
+    };
+
+    try {
+      const result = await this.postJson("api/embed", payload, {}, {
+        timeoutMs: input.timeoutMs
+      });
+      if (Array.isArray(result.embeddings) && result.embeddings.length > 0) {
+        return {
+          embeddings: result.embeddings
+        };
+      }
+      if (Array.isArray(result.embedding)) {
+        return {
+          embeddings: [result.embedding]
+        };
+      }
+      return result;
+    } catch (error) {
+      if (!String(error.message || "").includes("404")) throw error;
+      const fallback = await this.postJson("api/embeddings", payload, {}, {
+        timeoutMs: input.timeoutMs
+      });
+      if (Array.isArray(fallback.embedding)) {
+        return {
+          embeddings: [fallback.embedding]
+        };
+      }
+      return fallback;
+    }
+  }
+
+  async healthCheck() {
+    // Ollama is intentionally local-only. fetchResponse enforces loopback-only
+    // on the configured baseUrl before any health probe leaves the process.
+    const response = await this.fetchResponse("api/tags", {
+      method: "GET"
+    });
+    return {
+      ok: response.ok,
+      status: response.status
+    };
+  }
+
+  async listModels() {
+    const response = await this.fetchResponse("api/tags", {
+      method: "GET"
+    });
+    const text = await response.text();
+    let data = null;
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+        data = null;
+      }
+    }
+    if (!response.ok) {
+      throw new Error(`Provider error ${response.status}: ${typeof data === "string" ? data : JSON.stringify(data)}`);
+    }
+
+    const models = Array.isArray(data?.models)
+      ? data.models
+          .map((item) => item?.name || item?.model || null)
+          .filter(Boolean)
+      : [];
+
+    return models;
+  }
+}