@jevvy/permissions 0.1.0 → 0.2.0

package/dist/engine.d.ts

@@ -1,5 +1,7 @@
-import type { JevClient, NoulAnswer } from "./core.ts";
-import type { ApprovalQuestions } from "./questions.ts";
+import { Effect, Schema } from "effect";
+import { NoulAnswer } from "./core.ts";
+import type { JevClient, JevProviderFailure } from "./core.ts";
+import { ApprovalQuestions } from "./questions.ts";
 export type PermissionEffect = "allow" | "ask";
 export interface ResourceJudgment {
     readonly resource: string;
@@ -14,19 +16,25 @@ export type PermissionReview = {
     readonly effect: "ask";
     readonly reason: "judged" | "unavailable" | "empty";
     readonly judgments: readonly ResourceJudgment[];
+    readonly failure?: JevProviderFailure;
 };
 export interface PermissionRequest {
     readonly action: string;
     readonly resources: readonly string[];
 }
 export interface PermissionReviewer {
-    readonly review: (request: PermissionRequest, signal?: AbortSignal) => Promise<PermissionReview>;
-    readonly dispose: () => Promise<void>;
+    readonly review: (request: PermissionRequest) => Effect.Effect<PermissionReview>;
 }
 export interface PermissionReviewerOptions {
     readonly questions?: ApprovalQuestions;
     readonly timeoutMs?: number;
     readonly cacheCapacity?: number;
 }
+declare const ReviewerConfigurationError_base: Schema.Class<ReviewerConfigurationError, Schema.TaggedStruct<"ReviewerConfigurationError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ReviewerConfigurationError extends ReviewerConfigurationError_base {
+}
 export declare const permissionEffectOf: (answers: Readonly<Record<string, NoulAnswer>>, questions: ApprovalQuestions) => PermissionEffect;
-export declare const createPermissionReviewer: (client: JevClient, options?: PermissionReviewerOptions) => Promise<PermissionReviewer>;
+export declare const createPermissionReviewer: (client: JevClient, options?: PermissionReviewerOptions | undefined) => Effect.Effect<PermissionReviewer, ReviewerConfigurationError, never>;
+export {};

package/dist/engine.js

@@ -1,18 +1,35 @@
-import { Cache, Duration, Effect, Exit } from "effect";
-import { defaultApprovalQuestions, toNoulQuestions } from "./questions.js";
-class JudgmentUnavailable extends Error {
-    name = "JudgmentUnavailable";
+import { Cache, Clock, Duration, Effect, Exit, Ref, Schema } from "effect";
+import { isJevProviderError, JevProviderFailure as JevProviderFailureSchema, NoulAnswer, providerFailureOf, } from "./core.js";
+import { ApprovalQuestions, defaultApprovalQuestions, toNoulQuestions } from "./questions.js";
+const RATE_LIMIT_COOLDOWN_MS = 60_000;
+const EXHAUSTED_COOLDOWN_MS = 5 * 60_000;
+const cooldownMs = (failure) => {
+    if (failure.retryAfterMs !== undefined)
+        return failure.retryAfterMs;
+    if (failure.kind === "rate-limited")
+        return RATE_LIMIT_COOLDOWN_MS;
+    if (failure.kind === "credits-exhausted" || failure.kind === "quota-exhausted") {
+        return EXHAUSTED_COOLDOWN_MS;
+    }
+    return undefined;
+};
+class JudgmentUnavailable extends Schema.TaggedError()("JudgmentUnavailable", {
+    message: Schema.String,
+    failure: Schema.optional(JevProviderFailureSchema),
+}) {
+}
+export class ReviewerConfigurationError extends Schema.TaggedError()("ReviewerConfigurationError", { message: Schema.String }) {
 }
 const answerPasses = (answer, question) => question.threshold.direction === "atMost"
     ? answer <= question.threshold.value
     : answer >= question.threshold.value;
-const validAnswer = (answer) => answer?.type === "noul" && Number.isFinite(answer.noul) && answer.noul >= 0 && answer.noul <= 1;
+const validAnswer = Schema.is(NoulAnswer);
 export const permissionEffectOf = (answers, questions) => {
     let effect = "allow";
     for (const [key, question] of Object.entries(questions)) {
         const answer = answers[key];
         if (!validAnswer(answer))
-            throw new JudgmentUnavailable(`missing valid answer for ${key}`);
+            throw new JudgmentUnavailable({ message: `missing valid answer for ${key}` });
         if (!answerPasses(answer.noul, question))
             effect = "ask";
     }
@@ -20,7 +37,7 @@ export const permissionEffectOf = (answers, questions) => {
 };
 const judgeResult = (resource, result, questions) => {
     if (result.model.trim().length === 0)
-        throw new JudgmentUnavailable("missing model identifier");
+        throw new JudgmentUnavailable({ message: "missing model identifier" });
     return {
         resource,
         effect: permissionEffectOf(result.answers, questions),
@@ -28,70 +45,100 @@ const judgeResult = (resource, result, questions) => {
         answers: result.answers,
     };
 };
-const validateQuestions = (questions) => {
-    const entries = Object.entries(questions);
-    if (entries.length === 0)
-        throw new Error("at least one approval question is required");
-    for (const [key, question] of entries) {
-        if (key.length === 0)
-            throw new Error("approval question keys cannot be empty");
-        if (question.instructions.trim().length === 0)
-            throw new Error(`approval question ${key} has no instructions`);
-        if (!Number.isFinite(question.threshold.value) || question.threshold.value < 0 || question.threshold.value > 1) {
-            throw new Error(`approval question ${key} has an invalid threshold`);
-        }
+const validateQuestions = (questions) => Schema.decodeUnknownEffect(ApprovalQuestions, { onExcessProperty: "error" })(questions).pipe(Effect.asVoid, Effect.mapError(() => new ReviewerConfigurationError({ message: "invalid approval questions" })));
+const cacheKey = (action, resource) => `${action.length}:${action}${resource}`;
+const unavailable = (error) => {
+    if (error instanceof JudgmentUnavailable)
+        return error;
+    if (isJevProviderError(error)) {
+        return new JudgmentUnavailable({ message: error.message, failure: providerFailureOf(error) });
     }
+    return new JudgmentUnavailable({ message: String(error) });
 };
-const cacheKey = (action, resource) => `${action.length}:${action}${resource}`;
-const abortReason = (signal) => signal.reason instanceof Error
-    ? signal.reason
-    : new DOMException("The operation was aborted", "AbortError");
-const isAborted = (signal) => signal?.aborted === true;
-export const createPermissionReviewer = async (client, options = {}) => {
+export const createPermissionReviewer = Effect.fn("PermissionReviewer.create")(function* (client, options = {}) {
     const questions = options.questions ?? defaultApprovalQuestions;
     const timeoutMs = options.timeoutMs ?? 5_000;
     const capacity = options.cacheCapacity ?? 512;
-    validateQuestions(questions);
-    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
-        throw new Error("timeoutMs must be positive");
-    if (!Number.isInteger(capacity) || capacity <= 0)
-        throw new Error("cacheCapacity must be a positive integer");
+    yield* validateQuestions(questions);
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return yield* new ReviewerConfigurationError({ message: "timeoutMs must be positive" });
+    }
+    if (!Number.isInteger(capacity) || capacity <= 0) {
+        return yield* new ReviewerConfigurationError({ message: "cacheCapacity must be a positive integer" });
+    }
     const noulQuestions = toNoulQuestions(questions);
-    const cache = await Effect.runPromise(Cache.makeWith((key) => {
+    const providerCooldown = yield* Ref.make(undefined);
+    const activeProviderFailure = Effect.fn("PermissionReviewer.activeProviderFailure")(function* () {
+        const now = yield* Clock.currentTimeMillis;
+        return yield* Ref.modify(providerCooldown, (current) => {
+            if (current === undefined || current.untilMs <= now)
+                return [undefined, undefined];
+            return [current.failure, current];
+        });
+    });
+    const recordProviderCooldown = Effect.fn("PermissionReviewer.recordProviderCooldown")(function* (failure) {
+        const duration = cooldownMs(failure);
+        if (duration === undefined)
+            return;
+        const now = yield* Clock.currentTimeMillis;
+        const next = { failure, untilMs: now + duration };
+        yield* Ref.update(providerCooldown, (current) => current === undefined || current.untilMs < next.untilMs ? next : current);
+    });
+    const judgeResource = Effect.fn("PermissionReviewer.judgeResource")(function* (key) {
         const separator = key.indexOf(":");
         const actionLength = Number(key.slice(0, separator));
         const payload = key.slice(separator + 1);
         const action = payload.slice(0, actionLength);
         const resource = payload.slice(actionLength);
-        return Effect.tryPromise((signal) => client.evaluate({ state: { action, resource }, questions: noulQuestions }, signal)).pipe(Effect.timeout(timeoutMs), Effect.map((result) => judgeResult(resource, result, questions)), Effect.mapError((error) => new JudgmentUnavailable(String(error))));
-    }, {
+        const disabled = yield* activeProviderFailure();
+        if (disabled !== undefined) {
+            return yield* new JudgmentUnavailable({ message: disabled.message, failure: disabled });
+        }
+        return yield* client.evaluate({ state: { action, resource }, questions: noulQuestions }).pipe(Effect.timeout(timeoutMs), Effect.flatMap((result) => Effect.try({
+            try: () => judgeResult(resource, result, questions),
+            catch: (cause) => unavailable(cause instanceof Error ? cause : new Error(String(cause))),
+        })), Effect.mapError(unavailable), Effect.tapError((error) => error.failure === undefined
+            ? Effect.succeed(undefined)
+            : recordProviderCooldown(error.failure)));
+    });
+    const cache = yield* Cache.makeWith(judgeResource, {
         capacity,
         timeToLive: (exit) => Exit.isSuccess(exit) ? Duration.infinity : Duration.zero,
-    }));
+    });
     return {
-        async review(request, signal) {
+        review: Effect.fn("PermissionReviewer.review")(function* (request) {
             if (request.resources.length === 0)
                 return { effect: "ask", reason: "empty", judgments: [] };
+            const disabled = yield* activeProviderFailure();
+            if (disabled !== undefined) {
+                return { effect: "ask", reason: "unavailable", judgments: [], failure: disabled };
+            }
             const judgments = [];
             for (const resource of request.resources) {
-                if (isAborted(signal))
-                    throw abortReason(signal);
-                try {
-                    const judgment = await Effect.runPromise(Cache.get(cache, cacheKey(request.action, resource)), signal === undefined ? undefined : { signal });
-                    judgments.push(judgment);
-                    if (judgment.effect === "ask")
-                        return { effect: "ask", reason: "judged", judgments };
-                }
-                catch {
-                    if (isAborted(signal))
-                        throw abortReason(signal);
-                    return { effect: "ask", reason: "unavailable", judgments };
+                const result = yield* Cache.get(cache, cacheKey(request.action, resource)).pipe(Effect.match({
+                    onFailure: (error) => ({ kind: "failure", error }),
+                    onSuccess: (judgment) => ({ kind: "success", judgment }),
+                }));
+                if (result.kind === "failure") {
+                    if (result.error.failure !== undefined) {
+                        return {
+                            effect: "ask",
+                            reason: "unavailable",
+                            judgments,
+                            failure: result.error.failure,
+                        };
+                    }
+                    return {
+                        effect: "ask",
+                        reason: "unavailable",
+                        judgments,
+                    };
                 }
+                judgments.push(result.judgment);
+                if (result.judgment.effect === "ask")
+                    return { effect: "ask", reason: "judged", judgments };
             }
             return { effect: "allow", judgments };
-        },
-        async dispose() {
-            await client.dispose?.();
-        },
+        }),
     };
-};
+});

package/dist/opencode/credentials.d.ts

@@ -1,17 +1,7 @@
-import type { ProviderApiKeys, ProviderPreference } from "../config.ts";
+import { Effect } from "effect";
+import type { JevClient } from "../core.ts";
+import type { ProviderApiKeys, SelectedProvider } from "../providers.ts";
 export declare const OPENCODE_INTEGRATION = "opencode";
-export type ProviderCredential = {
-    readonly kind: "zen";
-    readonly key: string;
-    readonly model: string;
-    readonly origin: "opencode" | "config";
-} | {
-    readonly kind: "typesafe";
-    readonly key: string;
-    readonly origin: "config";
-} | {
-    readonly kind: "unavailable";
-};
 export type StoredCredential = {
     readonly type: "key";
     readonly key: string;
@@ -21,8 +11,8 @@ export type StoredCredential = {
     readonly access: string;
 };
 export interface CredentialPorts<C> {
-    readonly activeIntegration: (id: string) => Promise<C | undefined>;
-    readonly resolveIntegration: (connection: C) => Promise<StoredCredential | undefined>;
+    readonly activeIntegration: (id: string) => Effect.Effect<C | undefined>;
+    readonly resolveIntegration: (connection: C) => Effect.Effect<StoredCredential | undefined>;
     readonly readEnv: (name: string) => string | undefined;
 }
 export interface ConnectionLike {
@@ -30,4 +20,4 @@ export interface ConnectionLike {
     readonly envName?: string;
 }
 export declare const credentialToken: (credential: StoredCredential | undefined) => string | undefined;
-export declare const resolveCredential: <C>(ports: CredentialPorts<C>, preference: ProviderPreference, describe: (connection: C) => ConnectionLike, apiKeys?: ProviderApiKeys) => Promise<ProviderCredential>;
+export declare const selectOpenCodeProvider: <C>(ports: CredentialPorts<C>, preference: "auto" | "openrouter" | "typesafe" | "vercel" | "zen", describe: (connection: C) => ConnectionLike, apiKeys: ProviderApiKeys, createOpenCodeClient: (apiKey: string) => JevClient) => Effect.Effect<SelectedProvider | undefined, never, never>;

package/dist/opencode/credentials.js

@@ -1,12 +1,12 @@
-import { DEFAULT_ZEN_MODEL } from "../core.js";
-import { Redacted } from "effect";
+import { Effect } from "effect";
+import { createProvider, selectConfiguredProvider } from "../providers.js";
 export const OPENCODE_INTEGRATION = "opencode";
 export const credentialToken = (credential) => {
     const token = credential?.type === "key" ? credential.key : credential?.access;
     return token !== undefined && token.trim().length > 0 ? token : undefined;
 };
-const integrationCredential = async (ports, id, describe) => {
-    const connection = await ports.activeIntegration(id);
+const resolveOpenCodeCredential = Effect.fn("Credentials.resolveOpenCodeCredential")(function* (ports, describe) {
+    const connection = yield* ports.activeIntegration(OPENCODE_INTEGRATION);
     if (connection === undefined)
         return undefined;
     const like = describe(connection);
@@ -14,31 +14,16 @@ const integrationCredential = async (ports, id, describe) => {
         const key = ports.readEnv(like.envName);
         return key === undefined ? undefined : { type: "key", key };
     }
-    const resolved = await ports.resolveIntegration(connection);
+    const resolved = yield* ports.resolveIntegration(connection);
     return credentialToken(resolved) === undefined ? undefined : resolved;
-};
-const zenCandidate = async (ports, describe, configuredKey) => {
-    const opencode = await integrationCredential(ports, OPENCODE_INTEGRATION, describe);
-    const opencodeToken = credentialToken(opencode);
-    if (opencodeToken !== undefined) {
-        return { kind: "zen", key: opencodeToken, model: DEFAULT_ZEN_MODEL, origin: "opencode" };
-    }
-    if (configuredKey !== undefined) {
-        return { kind: "zen", key: Redacted.value(configuredKey), model: DEFAULT_ZEN_MODEL, origin: "config" };
-    }
-    return { kind: "unavailable" };
-};
-const typeSafeCandidate = (configuredKey) => {
-    if (configuredKey !== undefined) {
-        return { kind: "typesafe", key: Redacted.value(configuredKey), origin: "config" };
-    }
-    return { kind: "unavailable" };
-};
-export const resolveCredential = async (ports, preference, describe, apiKeys = {}) => {
-    if (preference === "zen")
-        return zenCandidate(ports, describe, apiKeys.zen);
-    if (preference === "typesafe")
-        return typeSafeCandidate(apiKeys.typesafe);
-    const zen = await zenCandidate(ports, describe, apiKeys.zen);
-    return zen.kind === "unavailable" ? typeSafeCandidate(apiKeys.typesafe) : zen;
-};
+});
+export const selectOpenCodeProvider = Effect.fn("Credentials.selectOpenCodeProvider")(function* (ports, preference, describe, apiKeys, createOpenCodeClient) {
+    const configured = selectConfiguredProvider(preference, apiKeys);
+    if (preference !== "auto" && preference !== "zen")
+        return configured;
+    const credential = yield* resolveOpenCodeCredential(ports, describe);
+    const apiKey = credentialToken(credential);
+    return apiKey === undefined
+        ? configured
+        : createProvider("zen", apiKey, createOpenCodeClient(apiKey));
+});

package/dist/opencode/evaluate.d.ts

@@ -1,5 +1,7 @@
-import type { PermissionEvaluation } from "@opencode/plugin/promise/permission";
+import type { PermissionEvaluation } from "@opencode/plugin/effect/permission";
+import { Effect } from "effect";
 import type { PermissionReviewer } from "../engine.ts";
+import type { JevProviderFailure } from "../core.ts";
 export interface EvaluationEvent {
     readonly sessionID: string;
     readonly action: string;
@@ -13,6 +15,7 @@ export interface EvaluateOptions {
         readonly effect: "allow" | "ask";
         readonly reason: "judged" | "unavailable" | "empty";
         readonly resources: number;
+        readonly failure?: JevProviderFailure;
     }) => void;
 }
-export declare const createEvaluate: (reviewer: PermissionReviewer | undefined, options: EvaluateOptions) => ((event: EvaluationEvent) => Promise<void>);
+export declare const createEvaluate: (reviewer: PermissionReviewer | undefined, options: EvaluateOptions) => ((event: EvaluationEvent) => Effect.Effect<void>);

package/dist/opencode/evaluate.js

@@ -1,7 +1,7 @@
-import { Option, Schema } from "effect";
+import { Effect, Option, Schema } from "effect";
 const CommandMetadata = Schema.Struct({ command: Schema.NonEmptyString });
 const commandFrom = (metadata) => Schema.decodeUnknownOption(CommandMetadata)(metadata).pipe(Option.map(({ command }) => command.trim()), Option.filter((command) => command.length > 0), Option.getOrUndefined);
-export const createEvaluate = (reviewer, options) => async (event) => {
+export const createEvaluate = (reviewer, options) => Effect.fn("OpenCode.evaluatePermission")(function* (event) {
     if (event.effect !== "ask" || event.action !== "shell" || reviewer === undefined)
         return;
     const command = commandFrom(event.metadata);
@@ -12,9 +12,14 @@ export const createEvaluate = (reviewer, options) => async (event) => {
     const resources = command === undefined
         ? event.resources
         : [...new Set([...event.resources, command])];
-    const review = await reviewer.review({ action: event.action, resources });
+    const review = yield* reviewer.review({ action: event.action, resources });
     const reason = review.effect === "ask" ? review.reason : "judged";
-    options.report?.({ effect: review.effect, reason, resources: resources.length });
+    if (review.effect === "ask" && review.failure !== undefined) {
+        options.report?.({ effect: review.effect, reason, resources: resources.length, failure: review.failure });
+    }
+    else {
+        options.report?.({ effect: review.effect, reason, resources: resources.length });
+    }
     if (review.effect === "allow")
         event.effect = "allow";
-};
+});

package/dist/opencode/index.d.ts

@@ -1,3 +1,3 @@
-import { Plugin } from "@opencode/plugin";
-declare const _default: Plugin.Plugin;
+import { Plugin } from "@opencode/plugin/effect";
+declare const _default: Plugin.Plugin<import("effect/Scope").Scope>;
 export default _default;

package/dist/opencode/index.js

@@ -1,10 +1,10 @@
-import { createTypeSafeClient, createZenClient, DEFAULT_TYPESAFE_MODEL } from "../core.js";
-import { Plugin } from "@opencode/plugin";
+import { createZenClient, JevProviderError } from "../core.js";
+import { Plugin } from "@opencode/plugin/effect";
 import { Effect } from "effect";
 import { loadJevvyConfig } from "../config.js";
 import { createPermissionReviewer } from "../engine.js";
 import { createEvaluate } from "./evaluate.js";
-import { credentialToken, OPENCODE_INTEGRATION, resolveCredential, } from "./credentials.js";
+import { credentialToken, OPENCODE_INTEGRATION, selectOpenCodeProvider, } from "./credentials.js";
 const describeConnection = (connection) => connection.type === "env"
     ? { kind: "env", envName: connection.name }
     : { kind: "credential" };
@@ -18,74 +18,65 @@ const storedCredentialFrom = (credential) => {
 };
 export default Plugin.define({
     id: "jevvy.permissions",
-    async setup(ctx) {
-        const permissionConfig = await Effect.runPromise(loadJevvyConfig());
+    effect: Effect.fn("JevvyPlugin.setup")(function* (ctx) {
+        const permissionConfig = yield* loadJevvyConfig();
         if (permissionConfig.kind === "invalid") {
-            console.warn("[jevvy] jevvy.jsonc failed validation, auto-approval is disabled", permissionConfig.message);
+            yield* Effect.sync(() => {
+                console.warn("[jevvy] jevvy.jsonc failed validation, auto-approval is disabled", permissionConfig.message);
+            });
         }
         const ports = {
             activeIntegration: (id) => ctx.integration.connection.active(id),
-            resolveIntegration: async (connection) => {
-                try {
-                    return storedCredentialFrom(await ctx.integration.connection.resolve(connection));
-                }
-                catch {
-                    return undefined;
-                }
-            },
+            resolveIntegration: (connection) => ctx.integration.connection.resolve(connection).pipe(Effect.map(storedCredentialFrom), Effect.catch(() => Effect.succeed(undefined))),
             readEnv: (name) => process.env[name],
         };
         const apiKeys = permissionConfig.kind === "invalid" ? {} : permissionConfig.apiKeys;
-        const provider = permissionConfig.kind === "invalid" ? "auto" : permissionConfig.provider;
-        const credential = await resolveCredential(ports, provider, describeConnection, apiKeys);
-        let client;
-        if (credential.kind === "typesafe") {
-            client = createTypeSafeClient(credential.key);
-        }
-        if (credential.kind === "zen") {
-            if (credential.origin === "opencode") {
-                client = {
-                    async evaluate(request, signal) {
-                        const connection = await ctx.integration.connection.active(OPENCODE_INTEGRATION);
-                        const stored = connection === undefined
-                            ? undefined
-                            : storedCredentialFrom(await ctx.integration.connection.resolve(connection));
-                        const token = credentialToken(stored);
-                        if (token === undefined)
-                            throw new Error("OpenCode login is unavailable");
-                        return createZenClient(token, credential.model).evaluate(request, signal);
-                    },
-                };
-            }
-            else {
-                client = createZenClient(credential.key, credential.model);
-            }
-        }
+        const preference = permissionConfig.kind === "invalid" ? "auto" : permissionConfig.provider;
+        const selected = permissionConfig.kind === "invalid"
+            ? undefined
+            : yield* selectOpenCodeProvider(ports, preference, describeConnection, apiKeys, () => ({
+                evaluate: Effect.fn("JevvyPlugin.evaluateWithOpenCodeCredential")(function* (request) {
+                    const connection = yield* ctx.integration.connection.active(OPENCODE_INTEGRATION);
+                    const stored = connection === undefined
+                        ? undefined
+                        : yield* ctx.integration.connection.resolve(connection).pipe(Effect.map(storedCredentialFrom), Effect.catch(() => Effect.succeed(undefined)));
+                    const token = credentialToken(stored);
+                    if (token === undefined) {
+                        return yield* new JevProviderError({
+                            provider: "zen",
+                            kind: "authentication",
+                            message: "OpenCode login is unavailable",
+                        });
+                    }
+                    return yield* createZenClient(token).evaluate(request);
+                }),
+            }));
         const questions = permissionConfig.kind === "custom" ? permissionConfig.questions : undefined;
-        const reviewer = client === undefined || permissionConfig.kind === "invalid"
+        const reviewer = selected === undefined || permissionConfig.kind === "invalid"
             ? undefined
-            : await createPermissionReviewer(client, { questions });
-        if (client === undefined && permissionConfig.kind !== "invalid") {
-            console.warn("[jevvy] no provider credential, native permission prompts remain unchanged");
+            : yield* createPermissionReviewer(selected.client, { questions }).pipe(Effect.orDie);
+        if (selected === undefined && permissionConfig.kind !== "invalid") {
+            yield* Effect.sync(() => {
+                console.warn("[jevvy] no provider credential, native permission prompts remain unchanged");
+            });
         }
         const evaluate = createEvaluate(reviewer, {
-            report: (entry) => console.info("[jevvy] permission review", entry),
+            report: (entry) => {
+                if (entry.failure !== undefined) {
+                    console.warn("[jevvy] provider failure, native permission prompt remains unchanged", entry);
+                    return;
+                }
+                console.info("[jevvy] permission review", entry);
+            },
         });
-        const permissions = await ctx.permission.hook("evaluate", evaluate);
-        let model;
-        if (credential.kind === "zen")
-            model = credential.model;
-        if (credential.kind === "typesafe")
-            model = DEFAULT_TYPESAFE_MODEL;
-        console.info("[jevvy] loaded", {
-            provider: credential.kind,
-            model,
-            questions: permissionConfig.kind === "custom" ? "custom" : "calibrated-defaults",
-            autoApproval: reviewer === undefined ? "disabled" : "enabled",
+        yield* ctx.permission.hook("evaluate", evaluate);
+        yield* Effect.sync(() => {
+            console.info("[jevvy] loaded", {
+                provider: selected?.provider ?? "unavailable",
+                model: selected?.model,
+                questions: permissionConfig.kind === "custom" ? "custom" : "calibrated-defaults",
+                autoApproval: reviewer === undefined ? "disabled" : "enabled",
+            });
         });
-        return async () => {
-            await permissions.dispose();
-            await reviewer?.dispose();
-        };
-    },
+    }),
 });

package/dist/providers.d.ts

@@ -0,0 +1,15 @@
+import type { JevClient, JevProvider as JevProviderType } from "./core.ts";
+import { Redacted, Schema } from "effect";
+export declare const ProviderPreference: Schema.Literals<readonly ["auto", "zen", "typesafe", "openrouter", "vercel"]>;
+export type ProviderPreference = Schema.Schema.Type<typeof ProviderPreference>;
+export type ProviderApiKeys = {
+    readonly [Provider in JevProviderType]?: Redacted.Redacted<string>;
+};
+export interface SelectedProvider {
+    readonly provider: JevProviderType;
+    readonly model: string;
+    readonly client: JevClient;
+    readonly redact: (text: string) => string;
+}
+export declare const createProvider: (provider: JevProviderType, apiKey: string, client?: JevClient) => SelectedProvider;
+export declare const selectConfiguredProvider: (preference: ProviderPreference, apiKeys: ProviderApiKeys) => SelectedProvider | undefined;

package/dist/providers.js

@@ -0,0 +1,43 @@
+import { createOpenRouterClient, createTypeSafeClient, createVercelClient, createZenClient, DEFAULT_OPENROUTER_MODEL, DEFAULT_TYPESAFE_MODEL, DEFAULT_VERCEL_MODEL, DEFAULT_ZEN_MODEL, JevProvider, } from "./core.js";
+import { Redacted, Schema } from "effect";
+export const ProviderPreference = Schema.Literals(["auto", ...JevProvider.literals]);
+const providerDefinitions = {
+    zen: {
+        automaticPriority: 0,
+        model: DEFAULT_ZEN_MODEL,
+        createClient: createZenClient,
+    },
+    typesafe: {
+        automaticPriority: 1,
+        model: DEFAULT_TYPESAFE_MODEL,
+        createClient: createTypeSafeClient,
+    },
+    openrouter: {
+        automaticPriority: 2,
+        model: DEFAULT_OPENROUTER_MODEL,
+        createClient: createOpenRouterClient,
+    },
+    vercel: {
+        automaticPriority: 3,
+        model: DEFAULT_VERCEL_MODEL,
+        createClient: createVercelClient,
+    },
+};
+const automaticProviders = [...JevProvider.literals].sort((left, right) => providerDefinitions[left].automaticPriority - providerDefinitions[right].automaticPriority);
+export const createProvider = (provider, apiKey, client = providerDefinitions[provider].createClient(apiKey)) => ({
+    provider,
+    model: providerDefinitions[provider].model,
+    client,
+    redact: (text) => apiKey.length === 0 ? text : text.replaceAll(apiKey, "[redacted]"),
+});
+export const selectConfiguredProvider = (preference, apiKeys) => {
+    const candidates = preference === "auto"
+        ? automaticProviders
+        : [preference];
+    for (const provider of candidates) {
+        const apiKey = apiKeys[provider];
+        if (apiKey !== undefined)
+            return createProvider(provider, Redacted.value(apiKey));
+    }
+    return undefined;
+};

package/dist/questions.d.ts

@@ -1,12 +1,38 @@
-import type { NoulQuestion } from "./core.ts";
-export interface ApprovalThreshold {
-    readonly direction: "atLeast" | "atMost";
-    readonly value: number;
+import { Schema } from "effect";
+import { NoulQuestion } from "./core.ts";
+export declare const ApprovalThreshold: Schema.Struct<{
+    readonly direction: Schema.Literals<readonly ["atLeast", "atMost"]>;
+    readonly value: Schema.Finite;
+}>;
+export interface ApprovalThreshold extends Schema.Schema.Type<typeof ApprovalThreshold> {
 }
-export interface ApprovalQuestion extends NoulQuestion {
-    readonly threshold: ApprovalThreshold;
+export declare const ApprovalQuestion: Schema.Struct<{
+    readonly type: Schema.Literal<"noul">;
+    readonly instructions: Schema.NonEmptyString;
+    readonly criteria: Schema.optionalKey<Schema.Struct<{
+        readonly false: Schema.NonEmptyString;
+        readonly true: Schema.NonEmptyString;
+    }>>;
+    readonly threshold: Schema.Struct<{
+        readonly direction: Schema.Literals<readonly ["atLeast", "atMost"]>;
+        readonly value: Schema.Finite;
+    }>;
+}>;
+export interface ApprovalQuestion extends Schema.Schema.Type<typeof ApprovalQuestion> {
 }
-export type ApprovalQuestions = Readonly<Record<string, ApprovalQuestion>>;
+export declare const ApprovalQuestions: Schema.$Record<Schema.NonEmptyString, Schema.Struct<{
+    readonly type: Schema.Literal<"noul">;
+    readonly instructions: Schema.NonEmptyString;
+    readonly criteria: Schema.optionalKey<Schema.Struct<{
+        readonly false: Schema.NonEmptyString;
+        readonly true: Schema.NonEmptyString;
+    }>>;
+    readonly threshold: Schema.Struct<{
+        readonly direction: Schema.Literals<readonly ["atLeast", "atMost"]>;
+        readonly value: Schema.Finite;
+    }>;
+}>>;
+export type ApprovalQuestions = Schema.Schema.Type<typeof ApprovalQuestions>;
 /**
  * The shipped inquiry set is calibrated as one unit with its thresholds and
  * pinned models. Rewording or overriding any entry creates a custom policy.