@agent-native/core 0.186.0 → 0.187.0-nightly-20260923203303

package/corpus/templates/mail/server/lib/automation-engine.ts

@@ -11,8 +11,14 @@ import {
   saveOAuthTokens,
 } from "@agent-native/core/oauth-tokens";
 import {
+  getRequestContext,
+  getJevContextCredentials,
+  isJevEnabled,
   readDeployCredentialEnv,
+  requestJevThroughBuilder,
   runWithRequestContext,
+  type JevContextCredentials,
+  type JevResponse,
 } from "@agent-native/core/server";
 import { getUserSetting, putUserSetting } from "@agent-native/core/settings";
 import {
@@ -44,6 +50,7 @@ import {
   resolveAutomationModelSettings,
   resolveTextAutomationModelSettings,
   TYPESAFE_AUTOMATION_ENGINE,
+  TYPESAFE_AUTOMATION_MODEL,
   type AutomationModelSettings,
 } from "./automation-model.js";
 import {
@@ -381,14 +388,45 @@ function isMissingProviderError(message: string): boolean {
 async function canUseAutomationModel(
   ownerEmail: string,
   settings: AutomationModelSettings,
-): Promise<boolean> {
+): Promise<{
+  available: boolean;
+  jevCredentials?: JevContextCredentials;
+  legacyTypesafeApiKey?: string;
+}> {
   if (settings.engine === TYPESAFE_AUTOMATION_ENGINE) {
-    return Boolean(readDeployCredentialEnv("TYPESAFE_API_KEY"));
+    return runWithRequestContext(
+      { ...getRequestContext(), userEmail: ownerEmail },
+      async () => {
+        const jevCredentials = await getJevContextCredentials(ownerEmail);
+        const legacyTypesafeApiKey =
+          readDeployCredentialEnv("TYPESAFE_API_KEY")?.trim() || undefined;
+        let available: boolean;
+        try {
+          available = await isJevEnabled(jevCredentials);
+        } catch (error) {
+          if (!legacyTypesafeApiKey) throw error;
+          console.warn(
+            "[automation-engine] Jev entitlement check failed; using the legacy Typesafe deployment key.",
+            error,
+          );
+          available = false;
+        }
+        return {
+          available: available || Boolean(legacyTypesafeApiKey),
+          jevCredentials,
+          ...(!available && legacyTypesafeApiKey
+            ? { legacyTypesafeApiKey }
+            : {}),
+        };
+      },
+    );
   }
 
   const cacheKey = `${ownerEmail}:${settings.engine ?? ""}:${settings.model ?? ""}`;
   const cached = modelAvailabilityCache.get(cacheKey);
-  if (cached && cached.expiresAt > Date.now()) return cached.ok;
+  if (cached && cached.expiresAt > Date.now()) {
+    return { available: cached.ok };
+  }
 
   try {
     registerBuiltinEngines();
@@ -413,7 +451,7 @@ async function canUseAutomationModel(
       ok: true,
       expiresAt: Date.now() + MODEL_AVAILABILITY_CACHE_TTL_MS,
     });
-    return true;
+    return { available: true };
   } catch (err: any) {
     const message = err?.message || "Automation model unavailable";
     if (!isMissingProviderError(message)) throw err;
@@ -422,7 +460,7 @@ async function canUseAutomationModel(
       error: message,
       expiresAt: Date.now() + MODEL_AVAILABILITY_CACHE_TTL_MS,
     });
-    return false;
+    return { available: false };
   }
 }
 
@@ -529,10 +567,9 @@ async function evaluateRulesWithJev(
   emails: EmailSummary[],
   rules: RuleRecord[],
   ownerEmail: string,
+  credentials: JevContextCredentials,
+  legacyTypesafeApiKey?: string,
 ): Promise<Map<string, RuleMatch[]>> {
-  const apiKey = readDeployCredentialEnv("TYPESAFE_API_KEY");
-  if (!apiKey) throw new Error("TypeSafe Jev is not configured.");
-
   const questionEntries = emails.flatMap((email, emailIndex) =>
     rules.map((rule, ruleIndex) => {
       const id = `q_${emailIndex}_${ruleIndex}`;
@@ -573,33 +610,23 @@ async function evaluateRulesWithJev(
     questions: Object.fromEntries(questionEntries),
   };
 
-  let response: Response | undefined;
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    response = await fetch("https://api.typesafe.ai/v1/systemone", {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(12_000),
-    });
-    if (response.ok) break;
-    if (attempt === 0 && (response.status === 429 || response.status === 529)) {
-      await new Promise((resolve) => setTimeout(resolve, 200));
-      continue;
+  let payload: JevResponse;
+  if (credentials.builderAuth && !legacyTypesafeApiKey) {
+    try {
+      payload = await requestJevThroughBuilder(credentials.builderAuth, body, {
+        timeoutMs: 12_000,
+      });
+    } catch (error) {
+      if (!credentials.personalApiKey) throw error;
+      payload = await requestJevDirect(credentials.personalApiKey, body);
     }
-    const detail = (await response.text()).slice(0, 300);
-    throw new Error(
-      `TypeSafe Jev request failed (${response.status})${detail ? `: ${detail}` : ""}`,
-    );
+  } else if (credentials.personalApiKey) {
+    payload = await requestJevDirect(credentials.personalApiKey, body);
+  } else if (legacyTypesafeApiKey) {
+    payload = await requestJevDirect(legacyTypesafeApiKey, body);
+  } else {
+    throw new Error("Jev is not enabled.");
   }
-
-  if (!response?.ok) throw new Error("TypeSafe Jev request failed.");
-  const payload = (await response.json()) as {
-    answers?: Record<string, { type?: string; noul?: number }>;
-    usage?: { input_tokens?: number; output_tokens?: number };
-  };
   if (!payload.answers || typeof payload.answers !== "object") {
     throw new Error("TypeSafe Jev returned no answers.");
   }
@@ -653,13 +680,22 @@ async function evaluateRules(
   ownerEmail: string,
   modelSettings: AutomationModelSettings,
   aiFilterState?: AiFilterState,
+  jevCredentials?: JevContextCredentials,
+  legacyTypesafeApiKey?: string,
 ): Promise<Map<string, RuleMatch[]>> {
   // Returns: messageId → array of matched rules with model confidence/reason.
   const results = new Map<string, RuleMatch[]>();
   if (emails.length === 0 || rules.length === 0) return results;
 
   if (modelSettings.engine === TYPESAFE_AUTOMATION_ENGINE) {
-    return evaluateRulesWithJev(emails, rules, ownerEmail);
+    if (!jevCredentials) throw new Error("Jev is not enabled.");
+    return evaluateRulesWithJev(
+      emails,
+      rules,
+      ownerEmail,
+      jevCredentials,
+      legacyTypesafeApiKey,
+    );
   }
 
   // Process in batches of 10 emails per call
@@ -783,10 +819,13 @@ async function evaluatePriorityWithJev(
   emails: EmailSummary[],
   instruction: string,
   ownerEmail: string,
+  credentials: JevContextCredentials,
   signal?: AbortSignal,
 ): Promise<Map<string, PriorityScore>> {
-  const apiKey = readDeployCredentialEnv("TYPESAFE_API_KEY");
-  if (!apiKey) throw new Error("TypeSafe Jev is not configured.");
+  const { builderAuth, personalApiKey } = credentials;
+  if (!personalApiKey && !builderAuth) {
+    throw new Error("Jev is not enabled.");
+  }
 
   const questions = Object.fromEntries(
     emails.map((email, index) => [
@@ -817,36 +856,23 @@ async function evaluatePriorityWithJev(
     questions,
   };
 
-  let response: Response | undefined;
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    signal?.throwIfAborted();
-    response = await fetch("https://api.typesafe.ai/v1/systemone", {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(body),
-      signal: signal
-        ? AbortSignal.any([signal, AbortSignal.timeout(12_000)])
-        : AbortSignal.timeout(12_000),
-    });
-    if (response.ok) break;
-    if (attempt === 0 && (response.status === 429 || response.status === 529)) {
-      await new Promise((resolve) => setTimeout(resolve, 200));
-      continue;
+  const request: Record<string, unknown> = { ...body };
+  let payload: JevResponse;
+  if (builderAuth) {
+    try {
+      payload = await requestJevThroughBuilder(builderAuth, request, {
+        signal,
+        timeoutMs: 12_000,
+      });
+    } catch (error) {
+      if (!personalApiKey) throw error;
+      payload = await requestJevDirect(personalApiKey, request, signal);
     }
-    const detail = (await response.text()).slice(0, 300);
-    throw new Error(
-      `TypeSafe Jev request failed (${response.status})${detail ? `: ${detail}` : ""}`,
-    );
+  } else if (personalApiKey) {
+    payload = await requestJevDirect(personalApiKey, request, signal);
+  } else {
+    throw new Error("Jev is not enabled.");
   }
-
-  if (!response?.ok) throw new Error("TypeSafe Jev request failed.");
-  const payload = (await response.json()) as {
-    answers?: Record<string, { noul?: number }>;
-    usage?: { input_tokens?: number; output_tokens?: number };
-  };
   if (!payload.answers || typeof payload.answers !== "object") {
     throw new Error("TypeSafe Jev returned no answers.");
   }
@@ -888,78 +914,54 @@ async function evaluatePriorityWithJev(
   return results;
 }
 
-async function evaluatePriorityWithTextModel(
-  emails: EmailSummary[],
-  instruction: string,
-  ownerEmail: string,
-  modelSettings: AutomationModelSettings,
+async function requestJevDirect(
+  apiKey: string,
+  body: Record<string, unknown>,
   signal?: AbortSignal,
-): Promise<Map<string, PriorityScore>> {
-  const results = new Map<string, PriorityScore>();
-  const batchSize = 25;
-  for (let i = 0; i < emails.length; i += batchSize) {
+): Promise<JevResponse> {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
     signal?.throwIfAborted();
-    const batch = emails.slice(i, i + batchSize);
-    const emailsText = batch
-      .map(
-        (email) =>
-          `--- Email (id: ${email.id}) ---\nFrom: ${email.from}\nTo: ${email.to}\nSubject: ${email.subject}\nSnippet: ${email.snippet}\nLabels: [${email.labelIds.join(", ")}]\nDate: ${email.date}`,
-      )
-      .join("\n\n");
-    const prompt = `Rank these emails for inbox priority using this user guidance: "${instruction}".
-
-Emails:
-${emailsText}
-
-Respond with ONLY a JSON array in this format:
-[{"emailId":"<id>","score":0.0,"reason":"short explanation"}]
-
-Use a score from 0 to 1. Give higher scores to emails that deserve attention sooner. Do not use the age of the email alone as the reason.`;
-    const text = await callModel(prompt, ownerEmail, modelSettings, signal);
-    const jsonStr = text
-      .replace(/```json?\n?/g, "")
-      .replace(/```/g, "")
-      .trim();
-    const parsed = JSON.parse(jsonStr) as Array<{
-      emailId: string;
-      score: number;
-      reason?: string;
-    }>;
-    if (!Array.isArray(parsed)) {
-      throw new Error("Priority model returned a non-array result.");
-    }
-    for (const result of parsed) {
-      if (
-        typeof result?.emailId !== "string" ||
-        typeof result.score !== "number" ||
-        !Number.isFinite(result.score)
-      ) {
-        continue;
-      }
-      results.set(result.emailId, {
-        score: Math.min(1, Math.max(0, result.score)),
-        ...(typeof result.reason === "string"
-          ? { reason: result.reason.slice(0, 500) }
-          : {}),
-      });
+    const response = await fetch("https://api.typesafe.ai/v1/systemone", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+      signal: signal
+        ? AbortSignal.any([signal, AbortSignal.timeout(12_000)])
+        : AbortSignal.timeout(12_000),
+    });
+    if (response.ok) return (await response.json()) as JevResponse;
+    if (attempt === 0 && (response.status === 429 || response.status === 529)) {
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      continue;
     }
+    const detail = (await response.text()).slice(0, 300);
+    throw new Error(
+      `TypeSafe Jev request failed (${response.status})${detail ? `: ${detail}` : ""}`,
+    );
   }
-  return results;
+  throw new Error("TypeSafe Jev request failed.");
 }
 
 export async function previewAutomationPriority(
   emails: AiPriorityEmail[],
   ownerEmail: string,
   instruction = AI_PRIORITY_DEFAULT_INSTRUCTION,
+  jevCredentials: JevContextCredentials,
   signal?: AbortSignal,
 ): Promise<{
   scores: Map<string, PriorityScore>;
   model: AutomationModelSettings;
 }> {
-  const model = await getAutomationModelSettings(ownerEmail);
-  if (!(await canUseAutomationModel(ownerEmail, model))) {
-    throw new Error("No LLM provider is connected for Mail priority sort.");
+  if (!jevCredentials.personalApiKey && !jevCredentials.builderAuth) {
+    throw new Error("Jev is not enabled.");
   }
+  const model = {
+    engine: TYPESAFE_AUTOMATION_ENGINE,
+    model: TYPESAFE_AUTOMATION_MODEL,
+  };
 
   const messages: EmailSummary[] = emails
     .filter(
@@ -983,16 +985,13 @@ export async function previewAutomationPriority(
   for (let i = 0; i < messages.length; i += 50) {
     signal?.throwIfAborted();
     const batch = messages.slice(i, i + 50);
-    const batchScores =
-      model.engine === TYPESAFE_AUTOMATION_ENGINE
-        ? await evaluatePriorityWithJev(batch, instruction, ownerEmail, signal)
-        : await evaluatePriorityWithTextModel(
-            batch,
-            instruction,
-            ownerEmail,
-            model,
-            signal,
-          );
+    const batchScores = await evaluatePriorityWithJev(
+      batch,
+      instruction,
+      ownerEmail,
+      jevCredentials,
+      signal,
+    );
     for (const [emailId, score] of batchScores) scores.set(emailId, score);
   }
   return { scores, model };
@@ -1008,7 +1007,8 @@ export async function previewAutomationRules(
   model: AutomationModelSettings;
 }> {
   const model = await getAutomationModelSettings(ownerEmail);
-  if (!(await canUseAutomationModel(ownerEmail, model))) {
+  const modelAccess = await canUseAutomationModel(ownerEmail, model);
+  if (!modelAccess.available) {
     throw new Error("No LLM provider is connected for Mail AI rules.");
   }
   const messages: EmailSummary[] = emails
@@ -1041,6 +1041,8 @@ export async function previewAutomationRules(
     ownerEmail,
     model,
     aiFilterState,
+    modelAccess.jevCredentials,
+    modelAccess.legacyTypesafeApiKey,
   );
   return { matches, model };
 }
@@ -1137,7 +1139,18 @@ export async function processAutomationsForAccount(
   // 2. Resolve model settings. Credentials are resolved by the selected engine
   // under the owner's request context, so Builder-managed models work here too.
   const modelSettings = await getAutomationModelSettings(ownerEmail);
-  if (!(await canUseAutomationModel(ownerEmail, modelSettings))) {
+  let modelAccess: Awaited<ReturnType<typeof canUseAutomationModel>>;
+  try {
+    modelAccess = await canUseAutomationModel(ownerEmail, modelSettings);
+  } catch (error) {
+    console.error(
+      "[automation-engine] Model availability check failed:",
+      error,
+    );
+    result.errors = 1;
+    return result;
+  }
+  if (!modelAccess.available) {
     result.errors = 1;
     return result;
   }
@@ -1194,6 +1207,8 @@ export async function processAutomationsForAccount(
     ownerEmail,
     modelSettings,
     aiFilterState,
+    modelAccess.jevCredentials,
+    modelAccess.legacyTypesafeApiKey,
   );
 
   // 6. Execute matched actions

package/corpus/templates/mail/server/lib/automation-model.ts

@@ -4,6 +4,8 @@ import {
   resolveEngine,
 } from "@agent-native/core/agent/engine";
 import {
+  getJevContextCredentials,
+  isJevEnabled,
   readDeployCredentialEnv,
   runWithRequestContext,
 } from "@agent-native/core/server";
@@ -67,7 +69,34 @@ async function resolveEngineDefaultModel(
 export async function resolveDefaultAutomationModel(
   ownerEmail: string,
 ): Promise<AutomationModelSettings> {
-  if (readDeployCredentialEnv("TYPESAFE_API_KEY")) {
+  const jevAvailability = await runWithRequestContext(
+    { userEmail: ownerEmail },
+    async () => {
+      try {
+        return {
+          status: "checked" as const,
+          enabled: await isJevEnabled(
+            await getJevContextCredentials(ownerEmail),
+          ),
+        };
+      } catch (error) {
+        return { status: "error" as const, error };
+      }
+    },
+  );
+  if (jevAvailability.status === "error") {
+    console.warn(
+      "[automation-model] Jev availability check failed; using the configured model.",
+      jevAvailability.error,
+    );
+  }
+  if (jevAvailability.status === "checked" && jevAvailability.enabled) {
+    return {
+      engine: TYPESAFE_AUTOMATION_ENGINE,
+      model: TYPESAFE_AUTOMATION_MODEL,
+    };
+  }
+  if (readDeployCredentialEnv("TYPESAFE_API_KEY")?.trim()) {
     return {
       engine: TYPESAFE_AUTOMATION_ENGINE,
       model: TYPESAFE_AUTOMATION_MODEL,
@@ -137,6 +166,8 @@ export async function resolveAutomationModelSettings(
   ownerEmail: string,
   settings: AutomationModelSettings | null | undefined,
 ): Promise<AutomationModelSettings> {
+  if (settings?.engine && settings.model) return settings;
+
   const defaults = await resolveDefaultAutomationModel(ownerEmail);
   if (!settings?.engine && !settings?.model) return defaults;
 

package/dist/agent/jev-tool-prefetch.d.ts

@@ -1,7 +1,19 @@
-import type { BuilderGatewayAuth } from "../server/credential-provider.js";
+import { type BuilderGatewayAuth } from "../server/credential-provider.js";
 import type { EngineTool } from "./engine/types.js";
-import type { ActionEntry } from "./production-agent.js";
-export declare const BUILDER_JEV_PROXY_ENABLED = true;
+import type { ActionEntry, JevContextCredentials } from "./production-agent.js";
+type JevChoiceAnswer = {
+    choice?: unknown;
+    probabilities?: unknown;
+};
+export type JevResponse = {
+    answers?: Record<string, JevChoiceAnswer & {
+        noul?: unknown;
+    }>;
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+    };
+};
 export interface JevCandidate {
     id: string;
     description: string;
@@ -11,6 +23,7 @@ export interface JevCandidate {
 export interface JevRankCandidatesOptions {
     request: string;
     apiKey?: string;
+    personalApiKey?: string;
     builderAuth?: BuilderGatewayAuth | null;
     candidates: readonly JevCandidate[];
     candidateStateKey: string;
@@ -28,6 +41,7 @@ export declare function shortlistJevCandidates<T extends JevCandidate>(request:
 export interface JevToolPrefetchOptions {
     request: string;
     apiKey?: string;
+    personalApiKey?: string;
     builderAuth?: BuilderGatewayAuth | null;
     registry: Record<string, ActionEntry>;
     initialTools: EngineTool[];
@@ -42,3 +56,13 @@ export interface JevToolPrefetchOptions {
  * Jev is an accelerator, not a dependency of agent execution.
  */
 export declare function preloadJevTools(options: JevToolPrefetchOptions): Promise<EngineTool[]>;
+export declare function requestJevThroughBuilder(auth: BuilderGatewayAuth, request: Record<string, unknown>, options?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<JevResponse>;
+export declare function isBuilderJevEnabled(auth: BuilderGatewayAuth, options?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<boolean>;
+export declare function isJevEnabled(credentials: JevContextCredentials): Promise<boolean>;
+export {};