@jevvy/permissions 0.0.0 → 0.2.0

package/README.md

@@ -49,30 +49,38 @@ Jevvy reads one optional global file at `~/.config/jevvy/jevvy.jsonc`. Project r
 ```jsonc
 {
   "$schema": "https://raw.githubusercontent.com/PanAchy/jevvy/main/config.schema.json",
-  "provider": "auto",
+  "provider": "typesafe",
+  "providers": {
+    "typesafe": {
+      "apiKey": "your-typesafe-api-key",
+    },
+  },
 }
 ```
 
 ### Provider
 
-| Setting                     | Default                 | Options                   | Purpose                              |
-| --------------------------- | ----------------------- | ------------------------- | ------------------------------------ |
-| `provider`                  | `auto`                  | `auto`, `zen`, `typesafe` | Select a provider                    |
-| `providers.zen.apiKey`      | none                    | OpenCode API key          | Use Zen without an OpenCode login    |
-| `providers.typesafe.apiKey` | none                    | TypeSafe API key          | Use TypeSafe AI                      |
+| Setting                       | Default | Options                                           | Purpose                           |
+| ----------------------------- | ------- | ------------------------------------------------- | --------------------------------- |
+| `provider`                    | `auto`  | `auto`, `zen`, `typesafe`, `openrouter`, `vercel` | Select a provider                 |
+| `providers.zen.apiKey`        | none    | OpenCode API key                                  | Use Zen without an OpenCode login |
+| `providers.typesafe.apiKey`   | none    | TypeSafe API key                                  | Use TypeSafe AI                   |
+| `providers.openrouter.apiKey` | none    | OpenRouter API key                                | Use OpenRouter                    |
+| `providers.vercel.apiKey`     | none    | Vercel AI Gateway key                             | Use Vercel AI Gateway             |
 
 With `provider` set to `auto`, Jevvy uses the first available credential:
 
-| Priority | Credential source                             | Provider |
-| -------: | --------------------------------------------- | -------- |
-|        1 | OpenCode login                                | Zen      |
-|        2 | Global JSON field `providers.zen.apiKey`      | Zen      |
-|        3 | `OPENCODE_API_KEY`                            | Zen      |
-|        4 | Global JSON field `providers.typesafe.apiKey` | TypeSafe |
-|        5 | `TYPESAFE_API_KEY`                            | TypeSafe |
-
-> [!TIP]
-> Join the [TypeSafe AI waitlist](https://typesafe.ai/) for $5 in credit.
+| Priority | Credential source                               | Provider   |
+| -------: | ----------------------------------------------- | ---------- |
+|        1 | OpenCode login                                  | Zen        |
+|        2 | Global JSON field `providers.zen.apiKey`        | Zen        |
+|        3 | `OPENCODE_API_KEY`                              | Zen        |
+|        4 | Global JSON field `providers.typesafe.apiKey`   | TypeSafe   |
+|        5 | `TYPESAFE_API_KEY`                              | TypeSafe   |
+|        6 | Global JSON field `providers.openrouter.apiKey` | OpenRouter |
+|        7 | `OPENROUTER_API_KEY`                            | OpenRouter |
+|        8 | Global JSON field `providers.vercel.apiKey`     | Vercel     |
+|        9 | `AI_GATEWAY_API_KEY`                            | Vercel     |
 
 ### Approval policy
 
@@ -89,7 +97,7 @@ Without `permissions.questions`, Jevvy requires all four shipped questions to pa
 | Untrusted | Does the command execute newly obtained, installed, generated, or concealed code?         | score ≤ `0.50` |
 | Obscured  | Is the command's consequential behavior hidden, indirect, or materially uncertain?        | score ≤ `0.50` |
 
-The four questions, thresholds, and pinned models were calibrated together against [`eval/commands.json`](https://github.com/PanAchy/jevvy/blob/main/eval/commands.json). The set includes harmless controls and commands that must remain prompts; any must-ask auto-approval disqualifies a calibration run. Replacing `permissions.questions` creates a custom policy that is not covered by this evidence.
+The four questions, thresholds, and model identities were calibrated together against [`eval/commands.json`](https://github.com/PanAchy/jevvy/blob/main/eval/commands.json). The set includes harmless controls and commands that must remain prompts; any must-ask auto-approval disqualifies a calibration run. Replacing `permissions.questions` creates a custom policy that is not covered by this evidence.
 
 ### Calibrate custom questions
 

package/dist/calibration-cli.d.ts

@@ -1,5 +1,6 @@
-import { Option } from "effect";
+import { Effect, Option } from "effect";
 import { Command } from "effect/unstable/cli";
+import type { ProviderPreference } from "./providers.ts";
 export interface CalibrationCliOptions {
     readonly corpora: readonly string[];
     readonly config?: string;
@@ -7,7 +8,8 @@ export interface CalibrationCliOptions {
     readonly spacing: number;
     readonly dryRun: boolean;
 }
-export declare const runCalibration: (options: CalibrationCliOptions, writeStdout?: (text: string) => void, writeStderr?: (text: string) => void) => Promise<number>;
+export declare const missingProviderMessage: (preference: ProviderPreference) => string;
+export declare const runCalibration: (options: CalibrationCliOptions, writeStdout?: (text: string) => void, writeStderr?: (text: string) => void) => Effect.Effect<number, never, never>;
 export declare const calibrationCommand: Command.Command<"jevvy-calibrate", {
     readonly corpora: readonly string[];
     readonly config: Option.Option<string>;

package/dist/calibration-cli.js

@@ -2,121 +2,121 @@ import { createHash } from "node:crypto";
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Effect, Option, Redacted, Schema } from "effect";
+import { Clock, Effect, Option, Schema } from "effect";
 import { Command, Flag } from "effect/unstable/cli";
-import { createTypeSafeClient, createZenClient, DEFAULT_TYPESAFE_MODEL, DEFAULT_ZEN_MODEL, } from "./core.js";
 import { calibrationMetaRecord, buildCalibrationPlan, numericAnswers, parseCalibrationCorpus, summarizeCalibration, } from "./calibration.js";
 import { loadJevvyConfig } from "./config.js";
 import { permissionEffectOf } from "./engine.js";
+import { selectConfiguredProvider } from "./providers.js";
 import { toNoulQuestions } from "./questions.js";
 const hash = (text) => createHash("sha256").update(text).digest("hex");
-const loadCorpus = async (path, name = path) => {
-    const raw = await readFile(path, "utf8");
-    return { name, corpus: parseCalibrationCorpus(JSON.parse(raw), name), hash: hash(raw) };
-};
-const timestamp = () => new Date().toISOString().replaceAll(":", "-").replace(".", "-");
-const sleep = (milliseconds) => new Promise((resolveSleep) => setTimeout(resolveSleep, milliseconds));
-const selectProvider = (preference, keys) => {
-    if ((preference === "auto" || preference === "zen") && keys.zen !== undefined) {
-        const key = Redacted.value(keys.zen);
-        return { provider: "zen", model: DEFAULT_ZEN_MODEL, key, client: createZenClient(key) };
-    }
-    if ((preference === "auto" || preference === "typesafe") && keys.typesafe !== undefined) {
-        const key = Redacted.value(keys.typesafe);
-        return { provider: "typesafe", model: DEFAULT_TYPESAFE_MODEL, key, client: createTypeSafeClient(key) };
-    }
+const loadCorpus = Effect.fn("JevvyCalibration.loadCorpus")(function* (path, name = path) {
+    const raw = yield* Effect.tryPromise(() => readFile(path, "utf8"));
+    return yield* Effect.try(() => ({
+        name,
+        corpus: parseCalibrationCorpus(JSON.parse(raw), name),
+        hash: hash(raw),
+    }));
+});
+const timestamp = (milliseconds) => new Date(milliseconds).toISOString().replaceAll(":", "-").replace(".", "-");
+export const missingProviderMessage = (preference) => {
     if (preference === "zen") {
-        throw new Error("Zen calibration needs providers.zen.apiKey or OPENCODE_API_KEY; OpenCode login is unavailable to the standalone calibration command");
+        return "Zen calibration needs providers.zen.apiKey or OPENCODE_API_KEY; OpenCode login is unavailable to the standalone calibration command";
     }
     if (preference === "typesafe") {
-        throw new Error("TypeSafe calibration needs providers.typesafe.apiKey or TYPESAFE_API_KEY");
+        return "TypeSafe calibration needs providers.typesafe.apiKey or TYPESAFE_API_KEY";
     }
-    throw new Error("calibration needs a global or environment provider credential");
-};
-export const runCalibration = async (options, writeStdout = (text) => console.log(text), writeStderr = (text) => console.error(text)) => {
-    try {
-        const baselinePath = fileURLToPath(new URL("./calibration/commands.json", import.meta.url));
-        const corpora = [
-            await loadCorpus(baselinePath, "jevvy:eval/commands.json"),
-            ...await Promise.all(options.corpora.map(async (path) => loadCorpus(resolve(path)))),
-        ];
-        const plan = buildCalibrationPlan(corpora);
-        const config = await Effect.runPromise(loadJevvyConfig(options.config === undefined ? undefined : resolve(options.config)));
-        if (config.kind === "invalid")
-            throw new Error(config.message);
-        if (config.kind !== "custom")
-            throw new Error("calibration requires permissions.questions in jevvy.jsonc");
-        const selected = selectProvider(config.provider, config.apiKeys);
-        const questionHash = hash(JSON.stringify(toNoulQuestions(config.questions)));
-        const meta = {
-            provider: selected.provider,
-            requestedModel: selected.model,
-            questions: config.questions,
-            questionHash,
-            createdAt: new Date().toISOString(),
-            calls: plan.length,
-            corpora: corpora.map((corpus) => ({ name: corpus.name, hash: corpus.hash })),
-        };
-        if (options.dryRun) {
-            await selected.client.dispose?.();
-            writeStdout(JSON.stringify({ ...calibrationMetaRecord(meta), plan }, null, 2));
-            return 0;
-        }
-        const output = resolve(options.output ?? `jevvy-calibration-${selected.provider}-${timestamp()}.jsonl`);
-        await mkdir(dirname(output), { recursive: true });
-        await writeFile(output, `${JSON.stringify(calibrationMetaRecord(meta))}\n`, { mode: 0o600, flag: "wx" });
-        const records = [];
-        try {
-            for (let index = 0; index < plan.length; index++) {
-                const entry = plan[index];
-                if (entry === undefined)
-                    continue;
-                const started = performance.now();
-                let record;
-                try {
-                    const judged = await selected.client.evaluate({
-                        state: { action: "shell", resource: entry.command },
-                        questions: toNoulQuestions(config.questions),
-                    }, AbortSignal.timeout(30_000));
-                    record = {
-                        ...entry,
-                        status: "result",
-                        effect: permissionEffectOf(judged.answers, config.questions),
-                        answers: numericAnswers(judged.answers),
-                        model: judged.model,
-                        ms: Math.round(performance.now() - started),
-                        timestamp: new Date().toISOString(),
-                    };
-                }
-                catch (error) {
-                    record = {
-                        ...entry,
-                        status: "error",
-                        error: String(error).replaceAll(selected.key, "[redacted]").slice(0, 500),
-                        ms: Math.round(performance.now() - started),
-                        timestamp: new Date().toISOString(),
-                    };
-                }
-                records.push(record);
-                await appendFile(output, `${JSON.stringify(record)}\n`);
-                writeStdout(`${index + 1}/${plan.length} ${record.status.padEnd(6)} ${entry.command.slice(0, 64)}`);
-                if (index + 1 < plan.length && options.spacing > 0)
-                    await sleep(options.spacing);
-            }
-        }
-        finally {
-            await selected.client.dispose?.();
-        }
-        const summary = summarizeCalibration(meta, records);
-        await appendFile(output, `${JSON.stringify(summary)}\n`);
-        writeStdout(JSON.stringify({ output, result: summary.result, counts: summary.counts }, null, 2));
-        return summary.failed ? 1 : 0;
+    if (preference === "openrouter") {
+        return "OpenRouter calibration needs providers.openrouter.apiKey or OPENROUTER_API_KEY";
     }
-    catch (error) {
-        writeStderr(String(error));
-        return 2;
+    if (preference === "vercel") {
+        return "Vercel calibration needs providers.vercel.apiKey or AI_GATEWAY_API_KEY";
     }
+    return "calibration needs a global or environment provider credential";
 };
+const run = Effect.fn("JevvyCalibration.runPlan")(function* (options, writeStdout) {
+    const baselinePath = fileURLToPath(new URL("./calibration/commands.json", import.meta.url));
+    const corpora = [
+        yield* loadCorpus(baselinePath, "jevvy:eval/commands.json"),
+        ...yield* Effect.forEach(options.corpora, (path) => loadCorpus(resolve(path)), { concurrency: "unbounded" }),
+    ];
+    const plan = buildCalibrationPlan(corpora);
+    const config = yield* loadJevvyConfig(options.config === undefined ? undefined : resolve(options.config));
+    if (config.kind === "invalid")
+        return yield* Effect.fail(new Error(config.message));
+    if (config.kind !== "custom") {
+        return yield* Effect.fail(new Error("calibration requires permissions.questions in jevvy.jsonc"));
+    }
+    const selected = selectConfiguredProvider(config.provider, config.apiKeys);
+    if (selected === undefined)
+        return yield* Effect.fail(new Error(missingProviderMessage(config.provider)));
+    const questionHash = hash(JSON.stringify(toNoulQuestions(config.questions)));
+    const createdAt = yield* Clock.currentTimeMillis;
+    const meta = {
+        provider: selected.provider,
+        requestedModel: selected.model,
+        questions: config.questions,
+        questionHash,
+        createdAt: new Date(createdAt).toISOString(),
+        calls: plan.length,
+        corpora: corpora.map((corpus) => ({ name: corpus.name, hash: corpus.hash })),
+    };
+    if (options.dryRun) {
+        yield* Effect.sync(() => writeStdout(JSON.stringify({ ...calibrationMetaRecord(meta), plan }, null, 2)));
+        return 0;
+    }
+    const output = resolve(options.output ?? `jevvy-calibration-${selected.provider}-${timestamp(createdAt)}.jsonl`);
+    yield* Effect.tryPromise(() => mkdir(dirname(output), { recursive: true }));
+    yield* Effect.tryPromise(() => writeFile(output, `${JSON.stringify(calibrationMetaRecord(meta))}\n`, { mode: 0o600, flag: "wx" }));
+    const records = [];
+    for (let index = 0; index < plan.length; index++) {
+        const entry = plan[index];
+        if (entry === undefined)
+            continue;
+        const started = yield* Clock.currentTimeMillis;
+        const outcome = yield* selected.client.evaluate({
+            state: { action: "shell", resource: entry.command },
+            questions: toNoulQuestions(config.questions),
+        }).pipe(Effect.timeout(30_000), Effect.match({
+            onFailure: (error) => ({ kind: "failure", error }),
+            onSuccess: (judged) => ({ kind: "success", judged }),
+        }));
+        const finished = yield* Clock.currentTimeMillis;
+        const timing = { ms: finished - started, timestamp: new Date(finished).toISOString() };
+        const record = outcome.kind === "success"
+            ? {
+                ...entry,
+                status: "result",
+                effect: permissionEffectOf(outcome.judged.answers, config.questions),
+                answers: numericAnswers(outcome.judged.answers),
+                model: outcome.judged.model,
+                ...timing,
+            }
+            : {
+                ...entry,
+                status: "error",
+                error: selected.redact(String(outcome.error)).slice(0, 500),
+                ...timing,
+            };
+        records.push(record);
+        yield* Effect.tryPromise(() => appendFile(output, `${JSON.stringify(record)}\n`));
+        yield* Effect.sync(() => {
+            writeStdout(`${index + 1}/${plan.length} ${record.status.padEnd(6)} ${entry.command.slice(0, 64)}`);
+        });
+        if (index + 1 < plan.length && options.spacing > 0)
+            yield* Effect.sleep(options.spacing);
+    }
+    const summary = summarizeCalibration(meta, records);
+    yield* Effect.tryPromise(() => appendFile(output, `${JSON.stringify(summary)}\n`));
+    yield* Effect.sync(() => {
+        writeStdout(JSON.stringify({ output, result: summary.result, counts: summary.counts }, null, 2));
+    });
+    return summary.failed ? 1 : 0;
+});
+export const runCalibration = (options, writeStdout = (text) => console.log(text), writeStderr = (text) => console.error(text)) => run(options, writeStdout).pipe(Effect.catch((error) => Effect.sync(() => {
+    writeStderr(String(error));
+    return 2;
+})));
 const NonNegative = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
 export const calibrationCommand = Command.make("jevvy-calibrate", {
     corpora: Flag.file("corpus", { mustExist: true }).pipe(Flag.atMost(100), Flag.withDescription("Add a user corpus to Jevvy's bundled baseline. Repeatable.")),
@@ -134,7 +134,7 @@ export const calibrationCommand = Command.make("jevvy-calibrate", {
         options = { ...options, config: config.value };
     if (Option.isSome(output))
         options = { ...options, output: output.value };
-    const code = yield* Effect.promise(() => runCalibration(options));
+    const code = yield* runCalibration(options);
     if (code !== 0)
         process.exitCode = code;
 })).pipe(Command.withDescription("Calibrate a custom Jevvy permission policy against the bundled baseline and user corpora"), Command.withExamples([

package/dist/calibration.d.ts

@@ -1,4 +1,4 @@
-import type { Json, NoulAnswer } from "./core.ts";
+import type { JevProvider, Json, NoulAnswer } from "./core.ts";
 import type { ApprovalQuestions } from "./questions.ts";
 export type CalibrationWant = "allow" | "ask" | "must-ask";
 export interface CalibrationCommand {
@@ -24,7 +24,7 @@ export interface CalibrationPlanEntry extends CalibrationCommand {
     readonly probe?: number;
 }
 export interface CalibrationMeta {
-    readonly provider: "typesafe" | "zen";
+    readonly provider: JevProvider;
     readonly requestedModel: string;
     readonly questions: ApprovalQuestions;
     readonly questionHash: string;
@@ -107,7 +107,7 @@ export declare const parseCalibrationCorpus: (value: Json, name: string) => Cali
 export declare const buildCalibrationPlan: (corpora: readonly NamedCalibrationCorpus[]) => readonly CalibrationPlanEntry[];
 export declare const summarizeCalibration: (meta: CalibrationMeta, records: readonly CalibrationRecord[], completedAt?: string) => CalibrationSummary;
 export declare const calibrationMetaRecord: (meta: CalibrationMeta) => {
-    provider: "typesafe" | "zen";
+    provider: JevProvider;
     requestedModel: string;
     questions: ApprovalQuestions;
     questionHash: string;

package/dist/config.d.ts

@@ -1,12 +1,9 @@
-import { ConfigProvider, Effect, Schema } from "effect";
-import type { Redacted } from "effect";
-import type { ApprovalQuestions } from "./questions.ts";
-declare const ProviderPreferenceSchema: Schema.Literals<readonly ["auto", "zen", "typesafe"]>;
-export interface ProviderApiKeys {
-    readonly zen?: Redacted.Redacted<string>;
-    readonly typesafe?: Redacted.Redacted<string>;
-}
-export type ProviderPreference = Schema.Schema.Type<typeof ProviderPreferenceSchema>;
+import { ConfigProvider, Effect } from "effect";
+import { ApprovalQuestions } from "./questions.ts";
+import { ProviderPreference } from "./providers.ts";
+import type { ProviderApiKeys } from "./providers.ts";
+export { ProviderPreference };
+export type { ProviderApiKeys };
 export type JevvyConfig = {
     readonly kind: "default";
     readonly provider: ProviderPreference;
@@ -23,20 +20,12 @@ export type JevvyConfig = {
 export declare const globalJevvyConfigPath: () => string;
 export declare const loadJevvyConfig: (path?: string, environment?: ConfigProvider.ConfigProvider) => Effect.Effect<{
     kind: "default";
-    provider: "auto" | "typesafe" | "zen";
+    provider: "auto" | "openrouter" | "typesafe" | "vercel" | "zen";
     apiKeys: ProviderApiKeys;
-    message?: undefined;
     questions?: undefined;
 } | {
-    kind: "invalid";
-    message: string;
-    provider?: undefined;
-    apiKeys?: undefined;
-    questions?: undefined;
-} | {
-    message?: undefined;
     kind: "custom";
-    provider: "auto" | "typesafe" | "zen";
+    provider: "auto" | "openrouter" | "typesafe" | "vercel" | "zen";
     apiKeys: ProviderApiKeys;
     questions: {
         readonly [x: string]: {
@@ -56,4 +45,3 @@ export declare const loadJevvyConfig: (path?: string, environment?: ConfigProvid
     kind: "invalid";
     message: string;
 }, never, never>;
-export {};

package/dist/config.js

@@ -3,36 +3,25 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { Config, ConfigProvider, Effect, Option, Schema } from "effect";
 import { parse } from "jsonc-parser";
-const Probability = Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 1 }));
-const CriteriaSchema = Schema.Struct({
-    false: Schema.NonEmptyString,
-    true: Schema.NonEmptyString,
-});
-const ApprovalQuestionSchema = Schema.Struct({
-    type: Schema.Literal("noul"),
-    instructions: Schema.NonEmptyString,
-    criteria: Schema.optional(CriteriaSchema),
-    threshold: Schema.Struct({
-        direction: Schema.Literals(["atLeast", "atMost"]),
-        value: Probability,
-    }),
-});
-const ApprovalQuestionsSchema = Schema.Record(Schema.NonEmptyString, ApprovalQuestionSchema);
-const ProviderPreferenceSchema = Schema.Literals(["auto", "zen", "typesafe"]);
+import { ApprovalQuestions } from "./questions.js";
+import { ProviderPreference } from "./providers.js";
 const ProviderCredentialSchema = Schema.Struct({
     apiKey: Schema.NonEmptyString,
 });
 const JevvyConfigSchema = Schema.Struct({
-    $schema: Schema.optional(Schema.String),
-    provider: Schema.optional(ProviderPreferenceSchema),
-    providers: Schema.optional(Schema.Struct({
-        zen: Schema.optional(ProviderCredentialSchema),
-        typesafe: Schema.optional(ProviderCredentialSchema),
+    $schema: Schema.optionalKey(Schema.String),
+    provider: Schema.optionalKey(ProviderPreference),
+    providers: Schema.optionalKey(Schema.Struct({
+        zen: Schema.optionalKey(ProviderCredentialSchema),
+        typesafe: Schema.optionalKey(ProviderCredentialSchema),
+        openrouter: Schema.optionalKey(ProviderCredentialSchema),
+        vercel: Schema.optionalKey(ProviderCredentialSchema),
     })),
-    permissions: Schema.optional(Schema.Struct({
-        questions: Schema.optional(ApprovalQuestionsSchema),
+    permissions: Schema.optionalKey(Schema.Struct({
+        questions: Schema.optionalKey(ApprovalQuestions),
     })),
 });
+export { ProviderPreference };
 class ConfigMissing extends Schema.TaggedError()("ConfigMissing", {}) {
 }
 class ConfigFileError extends Schema.TaggedError()("ConfigFileError", {
@@ -41,12 +30,17 @@ class ConfigFileError extends Schema.TaggedError()("ConfigFileError", {
 }
 const fileApiKey = (provider) => Config.redacted("apiKey").pipe(Config.nested(provider), Config.nested("providers"));
 const RuntimeConfig = Config.all({
-    provider: Config.schema(ProviderPreferenceSchema, "provider"),
+    provider: Config.schema(ProviderPreference, "provider"),
     zen: Config.option(fileApiKey("zen").pipe(Config.orElse(() => Config.redacted("OPENCODE_API_KEY")))),
     typesafe: Config.option(fileApiKey("typesafe").pipe(Config.orElse(() => Config.redacted("TYPESAFE_API_KEY")))),
-    questions: Config.option(Config.schema(ApprovalQuestionsSchema, ["permissions", "questions"])),
+    openrouter: Config.option(fileApiKey("openrouter").pipe(Config.orElse(() => Config.redacted("OPENROUTER_API_KEY")))),
+    vercel: Config.option(fileApiKey("vercel").pipe(Config.orElse(() => Config.redacted("AI_GATEWAY_API_KEY")))),
+    questions: Config.option(Config.schema(ApprovalQuestions, ["permissions", "questions"])),
 });
-const hasCredentials = (document) => document.providers?.zen !== undefined || document.providers?.typesafe !== undefined;
+const hasCredentials = (document) => document.providers?.zen !== undefined ||
+    document.providers?.typesafe !== undefined ||
+    document.providers?.openrouter !== undefined ||
+    document.providers?.vercel !== undefined;
 const readDocument = Effect.fn("JevvyConfig.readDocument")(function* (path) {
     const raw = yield* Effect.tryPromise({
         try: () => readFile(path, "utf8"),
@@ -101,11 +95,12 @@ const load = Effect.fn("JevvyConfig.load")(function* (path, environment) {
         apiKeys = { zen: config.zen.value };
     if (Option.isSome(config.typesafe))
         apiKeys = { ...apiKeys, typesafe: config.typesafe.value };
+    if (Option.isSome(config.openrouter))
+        apiKeys = { ...apiKeys, openrouter: config.openrouter.value };
+    if (Option.isSome(config.vercel))
+        apiKeys = { ...apiKeys, vercel: config.vercel.value };
     if (Option.isNone(config.questions))
         return { kind: "default", provider: config.provider, apiKeys };
-    if (Object.keys(config.questions.value).length === 0) {
-        return { kind: "invalid", message: "permissions.questions must contain at least one question" };
-    }
     return { kind: "custom", provider: config.provider, apiKeys, questions: config.questions.value };
 }, Effect.catchTag("ConfigFileError", (error) => Effect.succeed({ kind: "invalid", message: invalidMessage(error.reason) })));
 export const loadJevvyConfig = (path = globalJevvyConfigPath(), environment = ConfigProvider.fromEnv()) => load(path, environment);

package/dist/core.d.ts

@@ -1,2 +1,2 @@
-export { createTypeSafeClient, createZenClient, DEFAULT_TYPESAFE_MODEL, DEFAULT_ZEN_MODEL, } from "@jevvy/core";
-export type { Json, JevClient, JevRequest, JevResult, NoulAnswer, NoulQuestion, } from "@jevvy/core";
+export { createOpenRouterClient, createTypeSafeClient, createVercelClient, createZenClient, DEFAULT_OPENROUTER_MODEL, DEFAULT_TYPESAFE_MODEL, DEFAULT_VERCEL_MODEL, DEFAULT_ZEN_MODEL, isJevProviderError, JevRequest, JevResult, JevProvider, JevProviderError, JevProviderFailure, Json, NoulAnswer, NoulQuestion, providerFailureOf, } from "@jevvy/core";
+export type { JevClient, JevProviderErrorKind, } from "@jevvy/core";