@jevable/core 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,6 @@
 # @jevable/core
 
-The rule engine behind [`jev`](../cli/README.md): CEL expressions over a
+The rule engine behind [`jevable`](../cli/README.md): CEL expressions over a
 record (`line`, `json`) or a window (`window`) that can ask
 [Jev](https://docs.typesafe.ai) semantic questions through `judge.boolean`,
 `judge.choice` and `judge.score`. Plain conditions decide first; Jev is asked

package/dist/cel/check.d.ts

@@ -2,7 +2,7 @@ import { type Planned } from "./env.ts";
 /** A rule that cannot work as written. */
 export declare class RuleError extends Error {
 }
-export declare const HINT = "Variables: line, json (the parsed line) and, with --window, window. Run `jev guide` for functions and examples.";
+export declare const HINT = "Variables: line, json (the parsed line) and, with --window, window. Run `jevable guide` for functions and examples.";
 /** Throws a RuleError when the parsed expression cannot work as a rule (or key). */
 export declare function checkParsed(expr: unknown, kind: "rule" | "key"): void;
 /** Dry-runs a planned expression with neutral answers; throws a RuleError on what only evaluation shows. */

package/dist/cel/check.js

@@ -8,7 +8,7 @@ export class RuleError extends Error {
 const VARIABLES = new Set(["line", "json", "window"]);
 // Identifiers CEL itself provides: type names usable in `type(x) == int`.
 const BUILTIN_IDENTS = new Set(["int", "uint", "double", "bool", "string", "bytes", "list", "map", "null_type", "type"]);
-export const HINT = "Variables: line, json (the parsed line) and, with --window, window. Run `jev guide` for functions and examples.";
+export const HINT = "Variables: line, json (the parsed line) and, with --window, window. Run `jevable guide` for functions and examples.";
 const COMPARE = `compare it, e.g. judge.boolean(line, "...") >= 0.7`;
 // Values for the dry run, shaped like real ones.
 const PROBE = {

package/dist/engine.d.ts

@@ -1,7 +1,7 @@
 import { type Answers } from "./cel/env.ts";
 import { Program } from "./program.ts";
 import { type Answer, type Client, type Question } from "./typesafe/client.ts";
-export declare const NO_KEY = "no Jev API key: set TYPESAFE_API_KEY (or JEV_API_KEY)";
+export declare const NO_KEY = "no Jev API key: run `jevable key`";
 /**
  * What every program shares: the Jev client, an answer cache (the same
  * question on the same material is asked once), and counters.

package/dist/engine.js

@@ -3,7 +3,7 @@ import { checkParsed, checkPlanned, HINT, RuleError } from "./cel/check.js";
 import { env } from "./cel/env.js";
 import { Program } from "./program.js";
 import { HttpError } from "./typesafe/client.js";
-export const NO_KEY = "no Jev API key: set TYPESAFE_API_KEY (or JEV_API_KEY)";
+export const NO_KEY = "no Jev API key: run `jevable key`";
 /**
  * What every program shares: the Jev client, an answer cache (the same
  * question on the same material is asked once), and counters.

package/dist/index.d.ts

@@ -4,5 +4,6 @@ export { RuleError, isRuleBug } from "./cel/check.ts";
 export { toCel, fromCel } from "./cel/values.ts";
 export { clip, cutLongStrings, fingerprint, parseRecord } from "./text.ts";
 export { Client, HttpError, DEFAULT_BASE_URL, DEFAULT_MODEL, type Answer, type Question, type QuestionType, type Result } from "./typesafe/client.ts";
+export { PROVIDERS, lookup, choose, whose, type Provider, type Found } from "./typesafe/providers.ts";
 export type { Bindings, Call, Outcome } from "./types.ts";
 export type { CelInput } from "@bufbuild/cel";

package/dist/index.js

@@ -1,6 +1,7 @@
 // @jevable/core: compile a rule once, match records against it.
 //
 //   const engine = new Engine(new Client({ apiKey: process.env.TYPESAFE_API_KEY }));
+//   // or another provider of Jev: new Client({ apiKey, baseUrl: p.baseUrl, model: p.model, provider: p.label })
 //   const rule = engine.compile(`judge.boolean(line, "Is this an outage?") >= 0.7`);
 //   const { pass, calls } = await rule.match({ line: "checkout returns 500 for everyone" });
 export { Engine, NO_KEY } from "./engine.js";
@@ -9,3 +10,4 @@ export { RuleError, isRuleBug } from "./cel/check.js";
 export { toCel, fromCel } from "./cel/values.js";
 export { clip, cutLongStrings, fingerprint, parseRecord } from "./text.js";
 export { Client, HttpError, DEFAULT_BASE_URL, DEFAULT_MODEL } from "./typesafe/client.js";
+export { PROVIDERS, lookup, choose, whose } from "./typesafe/providers.js";

package/dist/typesafe/client.d.ts

@@ -29,7 +29,7 @@ export interface Result {
 /** A non-2xx answer from the API. */
 export declare class HttpError extends Error {
     readonly status: number;
-    constructor(status: number, body: string);
+    constructor(provider: string, status: number, body: string);
     /** Retrying cannot help: a bad key or a malformed request. */
     get fatal(): boolean;
 }
@@ -37,10 +37,13 @@ export declare class Client {
     readonly baseUrl: string;
     readonly apiKey: string;
     readonly model: string;
+    /** Who serves Jev here, for messages. */
+    readonly provider: string;
     constructor(opts?: {
         apiKey?: string;
         baseUrl?: string;
         model?: string;
+        provider?: string;
     });
     /** Evaluates every question against state in one call, retrying once on anything but a fatal error. */
     ask(state: unknown, questions: Record<string, Question>, signal?: AbortSignal): Promise<Result>;

package/dist/typesafe/client.js

@@ -1,6 +1,6 @@
 // A minimal client for TypeSafe's System One endpoint
 // (https://docs.typesafe.ai/api): one state, a map of typed questions, one
-// typed answer per question.
+// typed answer per question. Other providers serve the same API (providers.ts).
 export const DEFAULT_BASE_URL = "https://api.typesafe.ai";
 // Pinned rather than `jev-latest`: thresholds are tuned against one model,
 // and an alias moves without a change on our side.
@@ -8,8 +8,8 @@ export const DEFAULT_MODEL = "jev-1.13.0";
 /** A non-2xx answer from the API. */
 export class HttpError extends Error {
     status;
-    constructor(status, body) {
-        super(`typesafe API returned ${status}: ${body.slice(0, 512)}`);
+    constructor(provider, status, body) {
+        super(`${provider} returned ${status}: ${reason(body)}`);
         this.status = status;
     }
     /** Retrying cannot help: a bad key or a malformed request. */
@@ -17,14 +17,28 @@ export class HttpError extends Error {
         return this.status === 401 || this.status === 403 || this.status === 422;
     }
 }
+/** The message in an error body — TypeSafe's {message}, a gateway's {error: {message}} — else the body itself. */
+function reason(body) {
+    try {
+        const j = JSON.parse(body);
+        const m = j?.error?.message ?? j?.message ?? j?.error;
+        if (typeof m === "string")
+            return m;
+    }
+    catch { }
+    return body.slice(0, 512);
+}
 export class Client {
     baseUrl;
     apiKey;
     model;
+    /** Who serves Jev here, for messages. */
+    provider;
     constructor(opts = {}) {
         this.apiKey = opts.apiKey ?? "";
         this.baseUrl = (opts.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
         this.model = opts.model || DEFAULT_MODEL;
+        this.provider = opts.provider || "TypeSafe";
     }
     /** Evaluates every question against state in one call, retrying once on anything but a fatal error. */
     async ask(state, questions, signal) {
@@ -48,11 +62,11 @@ export class Client {
         });
         const text = await res.text();
         if (!res.ok)
-            throw new HttpError(res.status, text);
+            throw new HttpError(this.provider, res.status, text);
         const out = JSON.parse(text);
         for (const key of Object.keys(questions)) {
             if (!out.answers?.[key])
-                throw new Error(`typesafe: answer ${JSON.stringify(key)} missing`);
+                throw new Error(`${this.provider}: answer ${JSON.stringify(key)} missing`);
         }
         return out;
     }

package/dist/typesafe/providers.d.ts

@@ -0,0 +1,28 @@
+export interface Provider {
+    name: string;
+    label: string;
+    baseUrl: string;
+    /** Jev as this provider names it, pinned where the provider allows. */
+    model: string;
+    /** Variables holding its credential, the first set one wins. */
+    env: readonly string[];
+    /** How its keys start, to tell whose a pasted key is. */
+    prefix: string;
+}
+/** In the order jevable prefers them. */
+export declare const PROVIDERS: readonly Provider[];
+/** The provider a key belongs to, told by how it starts. */
+export declare function whose(key: string): Provider | undefined;
+export interface Found {
+    provider: Provider;
+    /** The variable the credential came from, when one is set. */
+    variable?: string;
+    key?: string;
+}
+/**
+ * Every provider with the credential found for it in `vars`. JEV_BASE_URL
+ * adds a custom endpoint (a proxy) ahead of the rest, keyed by JEV_API_KEY.
+ */
+export declare function lookup(vars: Readonly<Record<string, string | undefined>>): Found[];
+/** The provider to use: the one named (JEV_PROVIDER), else the first with a credential. */
+export declare function choose(found: Found[], name?: string): Found | undefined;

package/dist/typesafe/providers.js

@@ -0,0 +1,32 @@
+// Where Jev can be reached. Every provider here speaks TypeSafe's System One
+// API (POST <baseUrl>/v1/systemone) with the same request and answer shapes;
+// they differ in base URL, credential and model id.
+import { DEFAULT_BASE_URL, DEFAULT_MODEL } from "./client.js";
+/** In the order jevable prefers them. */
+export const PROVIDERS = [
+    { name: "typesafe", label: "TypeSafe", baseUrl: DEFAULT_BASE_URL, model: DEFAULT_MODEL, env: ["TYPESAFE_API_KEY", "JEV_API_KEY"], prefix: "apikey_" },
+    // AI Gateway lists Jev under one id only; it does not take a version.
+    { name: "vercel", label: "Vercel AI Gateway", baseUrl: "https://ai-gateway.vercel.sh/typesafe", model: "typesafe-ai/jev", env: ["AI_GATEWAY_API_KEY", "VERCEL_OIDC_TOKEN"], prefix: "vck_" },
+    { name: "openrouter", label: "OpenRouter", baseUrl: "https://openrouter.ai/api", model: "typesafe/jev-1.13", env: ["OPENROUTER_API_KEY"], prefix: "sk-or-" },
+];
+/** The provider a key belongs to, told by how it starts. */
+export function whose(key) {
+    return PROVIDERS.find((p) => key.startsWith(p.prefix));
+}
+/**
+ * Every provider with the credential found for it in `vars`. JEV_BASE_URL
+ * adds a custom endpoint (a proxy) ahead of the rest, keyed by JEV_API_KEY.
+ */
+export function lookup(vars) {
+    const custom = vars.JEV_BASE_URL
+        ? [{ name: "custom", label: vars.JEV_BASE_URL, baseUrl: vars.JEV_BASE_URL, model: DEFAULT_MODEL, env: ["JEV_API_KEY", "TYPESAFE_API_KEY"], prefix: "" }]
+        : [];
+    return [...custom, ...PROVIDERS].map((provider) => {
+        const variable = provider.env.find((v) => vars[v]);
+        return { provider, variable, key: variable && vars[variable] };
+    });
+}
+/** The provider to use: the one named (JEV_PROVIDER), else the first with a credential. */
+export function choose(found, name) {
+    return name ? found.find((f) => f.provider.name === name) : found.find((f) => f.key);
+}

package/package.json

@@ -1,32 +1,34 @@
 {
   "name": "@jevable/core",
-  "version": "0.1.0",
-  "description": "The jev rule engine: CEL rules that ask Jev, TypeSafe's classification model, semantic questions",
+  "version": "0.1.2",
+  "description": "The jevable rule engine: CEL rules that ask Jev, TypeSafe's classification model, semantic questions",
   "type": "module",
   "exports": {
     ".": {
-      "development": "./src/index.ts",
+      "jevable-source": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
     "./testing": {
-      "development": "./src/testing.ts",
+      "jevable-source": "./src/testing.ts",
       "types": "./dist/testing.d.ts",
       "default": "./dist/testing.js"
     }
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "engines": {
-    "node": ">=20"
+    "node": ">=20.3"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
-    "test": "node --conditions=development --test test/*.test.ts",
+    "test": "node --conditions=jevable-source --test test/*.test.ts",
     "prepack": "npm run build"
   },
   "dependencies": {
     "@bufbuild/cel": "0.6.1"
   },
-  "license": "MIT"
+  "license": "UNLICENSED"
 }