okengine 0.11.1 → 0.11.2

package/src/elements/ai/errors.test.ts

@@ -0,0 +1,35 @@
+/**
+ * AI error classification + timeout parsing.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { aiHttpError, isRetryableAiError, outExpectsVia, resolveTimeoutMs } from "./errors.ts";
+
+describe("resolveTimeoutMs", () => {
+  test("parses clock durations and ms numbers", () => {
+    expect(resolveTimeoutMs("30s")).toBe(30_000);
+    expect(resolveTimeoutMs(250)).toBe(250);
+    expect(resolveTimeoutMs(undefined)).toBeUndefined();
+    expect(resolveTimeoutMs("nope")).toBeUndefined();
+  });
+});
+
+describe("isRetryableAiError", () => {
+  test("classifies status and HTTP message", () => {
+    expect(isRetryableAiError(aiHttpError("rate", 429))).toBe(true);
+    expect(isRetryableAiError(aiHttpError("boom", 503))).toBe(true);
+    expect(isRetryableAiError(aiHttpError("auth", 401))).toBe(false);
+    expect(isRetryableAiError(new Error("openai-compatible HTTP 401"))).toBe(false);
+    const abort = new Error("aborted");
+    abort.name = "AbortError";
+    expect(isRetryableAiError(abort)).toBe(true);
+  });
+});
+
+describe("outExpectsVia", () => {
+  test("detects JSON-schema and Zod-like shape", () => {
+    expect(outExpectsVia({ properties: { via: { type: "string" } } })).toBe(true);
+    expect(outExpectsVia({ shape: { via: {} } })).toBe(true);
+    expect(outExpectsVia({ properties: { summary: { type: "string" } } })).toBe(false);
+  });
+});

package/src/elements/ai/errors.ts

@@ -0,0 +1,139 @@
+/**
+ * AI provider / transport error classification for recovery chains.
+ *
+ * Retryable failures may retry once on the same model, then advance `via`.
+ * Permanent failures stop the chain immediately.
+ */
+
+import { parseDurationMs } from "../clock/duration.ts";
+import type { AiTimeout } from "./declare.ts";
+
+/** Optional structured fields drivers may attach to thrown errors. */
+export interface AiErrorFields {
+  readonly status?: number;
+  readonly code?: string;
+}
+
+/**
+ * Resolve a prompt/ask timeout to milliseconds.
+ *
+ * @param timeout - Duration string (`"30s"`) or ms number
+ * @returns Milliseconds, or `undefined` when unset / invalid
+ */
+export function resolveTimeoutMs(timeout: AiTimeout | undefined): number | undefined {
+  if (timeout === undefined) return undefined;
+  if (typeof timeout === "number") {
+    return Number.isFinite(timeout) && timeout > 0 ? timeout : undefined;
+  }
+  const ms = parseDurationMs(timeout);
+  return ms > 0 ? ms : undefined;
+}
+
+/**
+ * Merge an optional deadline into an ambient abort signal.
+ *
+ * @param timeoutMs - Deadline in ms
+ * @param ambient - Existing signal (e.g. request cancel)
+ */
+export function mergeAskAbortSignal(
+  timeoutMs: number | undefined,
+  ambient?: AbortSignal,
+): AbortSignal | undefined {
+  if (timeoutMs === undefined) return ambient;
+  const deadline = AbortSignal.timeout(timeoutMs);
+  if (!ambient) return deadline;
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any([ambient, deadline]);
+  }
+  return deadline;
+}
+
+/**
+ * HTTP / abort / network failures that may succeed on retry or another model.
+ *
+ * @param err - Thrown value from a model attempt
+ */
+export function isRetryableAiError(err: unknown): boolean {
+  if (err == null) return false;
+
+  const status = readStatus(err);
+  if (status !== undefined) {
+    if (status === 429) return true;
+    if (status >= 500 && status <= 599) return true;
+    if (status >= 400 && status <= 499) return false;
+  }
+
+  const name = err instanceof Error ? err.name : "";
+  const message = err instanceof Error ? err.message : String(err);
+  const lower = message.toLowerCase();
+
+  const httpMatch = /\bHTTP\s*(\d{3})\b/i.exec(message);
+  if (httpMatch?.[1]) {
+    const code = Number(httpMatch[1]);
+    if (code === 429 || (code >= 500 && code <= 599)) return true;
+    if (code >= 400 && code <= 499) return false;
+  }
+
+  if (name === "AbortError" || name === "TimeoutError") return true;
+  if (lower.includes("aborterror") || lower.includes("timeout")) return true;
+  if (
+    lower.includes("econnreset") ||
+    lower.includes("econnrefused") ||
+    lower.includes("enotfound") ||
+    lower.includes("socket hang up") ||
+    lower.includes("fetch failed") ||
+    lower.includes("network")
+  ) {
+    return true;
+  }
+
+  // Unclassified provider/transport errors — allow recovery to the next model.
+  return err instanceof Error;
+}
+
+/**
+ * Attach an HTTP status onto an Error for {@link isRetryableAiError}.
+ *
+ * @param message - Error message
+ * @param status - HTTP status
+ */
+export function aiHttpError(message: string, status: number): Error {
+  const err = new Error(message) as Error & { status: number };
+  err.status = status;
+  return err;
+}
+
+function readStatus(err: unknown): number | undefined {
+  if (typeof err !== "object" || err === null) return undefined;
+  const status = (err as AiErrorFields).status;
+  return typeof status === "number" && Number.isFinite(status) ? status : undefined;
+}
+
+/**
+ * Whether a declared prompt `out` schema expects a `via` field
+ * (JSON-schema properties or Zod `.shape`).
+ *
+ * @param schema - Prompt `out` declaration
+ */
+export function outExpectsVia(schema: unknown): boolean {
+  if (schema == null || typeof schema !== "object") return false;
+  if (
+    "properties" in schema &&
+    schema.properties &&
+    typeof schema.properties === "object" &&
+    !Array.isArray(schema.properties) &&
+    "via" in (schema.properties as Record<string, unknown>)
+  ) {
+    return true;
+  }
+  if (
+    "shape" in schema &&
+    schema.shape &&
+    typeof schema.shape === "object" &&
+    !Array.isArray(schema.shape) &&
+    "via" in (schema.shape as Record<string, unknown>)
+  ) {
+    return true;
+  }
+  return false;
+}

package/src/elements/ai/eval.ts

@@ -47,13 +47,38 @@ export interface RunPromptEvalsOptions {
   readonly equals?: (actual: unknown, expect: unknown) => boolean;
 }
 
+/**
+ * Deep equality for eval expectations — ignore a runtime-stamped `via`
+ * when the case did not declare one.
+ *
+ * @param actual - Ask output
+ * @param expect - Case expectation
+ */
+function defaultEvalEquals(actual: unknown, expect: unknown): boolean {
+  if (JSON.stringify(actual) === JSON.stringify(expect)) return true;
+  if (
+    actual &&
+    typeof actual === "object" &&
+    !Array.isArray(actual) &&
+    expect &&
+    typeof expect === "object" &&
+    !Array.isArray(expect) &&
+    !("via" in expect) &&
+    "via" in actual
+  ) {
+    const { via: _via, ...rest } = actual as Record<string, unknown>;
+    return JSON.stringify(rest) === JSON.stringify(expect);
+  }
+  return false;
+}
+
 /**
  * Run a prompt eval set. Fails CI when any case fails (`ok === false`).
  *
  * @param options - Cases + ask fn
  */
 export async function runPromptEvals(options: RunPromptEvalsOptions): Promise<EvalSuiteResult> {
-  const equals = options.equals ?? ((a, b) => JSON.stringify(a) === JSON.stringify(b));
+  const equals = options.equals ?? defaultEvalEquals;
   const results: EvalCaseResult[] = [];
 
   for (let i = 0; i < options.cases.length; i++) {

package/src/elements/ai/runtime.ts

@@ -12,7 +12,13 @@ import type { IndexStore } from "../../drivers/types.ts";
 import { maskRedactedDeep } from "../../kernel/redacted.ts";
 import type { GatePolicyContext } from "../gate/declare.ts";
 import type { GateRuntime } from "../gate/runtime.ts";
-import type { AiAgentDecl, AiEmbedDecl, AiModelDecl, AiPromptDecl } from "./declare.ts";
+import type { AiAgentDecl, AiEmbedDecl, AiModelDecl, AiPromptDecl, AiTimeout } from "./declare.ts";
+import {
+  isRetryableAiError,
+  mergeAskAbortSignal,
+  outExpectsVia,
+  resolveTimeoutMs,
+} from "./errors.ts";
 import {
   AiSchemaValidationError,
   coerceModelObject,
@@ -20,6 +26,9 @@ import {
   type AiSchemaMismatch,
 } from "./schema.ts";
 
+/** Brief pause before the same-model retry on a retryable failure. */
+const AI_SAME_MODEL_RETRY_BACKOFF_MS = 250;
+
 /** Default bound for tool / agent loops. */
 export const AI_DEFAULT_MAX_STEPS = 6;
 
@@ -146,6 +155,8 @@ export interface CreateAiRuntimeOptions {
 /** Ask options. */
 export interface AiAskOptions {
   readonly via?: readonly string[];
+  /** Per-call deadline — overrides prompt `timeout` (`"30s"` or ms). */
+  readonly timeout?: AiTimeout;
   readonly allowPii?: boolean;
   /** Flow names offered as tools — each model call dispatches via `callTool`. */
   readonly tools?: readonly string[];
@@ -275,6 +286,8 @@ export function createAiRuntime(options: CreateAiRuntimeOptions = {}): AiRuntime
     const model = models.get(name);
     const opened = await options.defaultDriver.open({
       model: model?.model ?? name,
+      ...(model?.baseUrl !== undefined ? { baseUrl: model.baseUrl } : {}),
+      ...(model?.apiKey !== undefined ? { apiKey: model.apiKey } : {}),
     });
     clients.set(name, opened);
     return opened;
@@ -389,6 +402,7 @@ export function createAiRuntime(options: CreateAiRuntimeOptions = {}): AiRuntime
     readonly maxSteps: number;
     readonly agentLabel: string;
     readonly responseFormat?: unknown;
+    readonly signal?: AbortSignal;
     readonly callTool?: (name: string, input: unknown) => Promise<unknown>;
     readonly auth?: GatePolicyContext["auth"];
     readonly operator?: GatePolicyContext["operator"];
@@ -421,6 +435,7 @@ export function createAiRuntime(options: CreateAiRuntimeOptions = {}): AiRuntime
         messages,
         tools: defs.length > 0 ? defs : undefined,
         responseFormat: opts.responseFormat,
+        ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
       });
       cost += result.usage?.cost ?? 0;
       lastText = result.text;
@@ -498,6 +513,7 @@ export function createAiRuntime(options: CreateAiRuntimeOptions = {}): AiRuntime
       const version = decl.version;
       const started = now();
       const tools = opts?.tools ?? [];
+      const signal = mergeAskAbortSignal(resolveTimeoutMs(opts?.timeout ?? decl.timeout));
 
       // Replay from journal when input matches (nondeterministic contract)
       if (journalingForced && tools.length === 0) {
@@ -514,7 +530,8 @@ export function createAiRuntime(options: CreateAiRuntimeOptions = {}): AiRuntime
         }
       }
 
-      const via = opts?.via ?? (decl.model ? [decl.model] : [...models.keys()].slice(0, 1));
+      const via =
+        opts?.via ?? decl.via ?? (decl.model ? [decl.model] : [...models.keys()].slice(0, 1));
       const attempts: AiFallbackAttempt[] = [];
       let lastError: string | undefined;
       let lastSchema: AiSchemaMismatch | undefined;
@@ -522,72 +539,66 @@ export function createAiRuntime(options: CreateAiRuntimeOptions = {}): AiRuntime
       const userContent = promptContentFromInput(input);
 
       for (const modelName of via) {
-        const attemptStart = now();
-        try {
-          const client = await clientFor(modelName);
-          let raw: unknown;
-          let attemptCost = 0;
-
-          if (tools.length > 0) {
-            const loop = await toolLoop({
-              client,
-              modelName,
-              messages: [{ role: "user", content: userContent }],
-              tools,
-              maxSteps: opts?.maxSteps ?? AI_DEFAULT_MAX_STEPS,
-              agentLabel: prompt,
-              responseFormat: decl.out,
-              callTool: opts?.callTool,
-            });
-            raw = loop.lastToolResult !== undefined && !loop.text ? loop.lastToolResult : loop.raw;
-            attemptCost = loop.cost;
-            totalCost += attemptCost;
-            if (loop.denials.length > 0 && loop.trail.every((t) => t.status === "denied")) {
-              throw new Error(
-                `ai: all tool calls denied for prompt "${prompt}": ${loop.denials[0]?.reason}`,
-              );
-            }
-          } else {
-            const result = await client.complete({
-              model: wireModel(modelName, client),
-              messages: [{ role: "user", content: userContent }],
-              responseFormat: decl.out,
-            });
-            attemptCost = result.usage?.cost ?? 0;
-            totalCost += attemptCost;
-            raw = result.raw !== undefined ? result.raw : result.text;
-          }
-
-          const latencyMs = Math.max(0, now() - attemptStart);
-
+        let sameModelTries = 0;
+        let advance = true;
+        while (sameModelTries < 2 && advance) {
+          sameModelTries++;
+          const attemptStart = now();
           try {
-            const output = decl.out
-              ? validatePromptOut(prompt, version, decl.out, raw)
-              : coerceModelObject(raw);
-            attempts.push({
-              model: modelName,
-              ok: true,
-              cost: attemptCost,
-              latencyMs,
-              at: now(),
-            });
-            if (journalingForced) {
-              journal.push({
-                prompt,
-                ...(version !== undefined ? { version } : {}),
-                input,
-                output,
-                attempts: [...attempts],
-                outcome: "ok",
-                cost: totalCost,
-                latencyMs: Math.max(0, now() - started),
-                at: now(),
+            const client = await clientFor(modelName);
+            let raw: unknown;
+            let attemptCost = 0;
+
+            if (tools.length > 0) {
+              const loop = await toolLoop({
+                client,
+                modelName,
+                messages: [{ role: "user", content: userContent }],
+                tools,
+                maxSteps: opts?.maxSteps ?? AI_DEFAULT_MAX_STEPS,
+                agentLabel: prompt,
+                responseFormat: decl.out,
+                callTool: opts?.callTool,
+                ...(signal !== undefined ? { signal } : {}),
+              });
+              raw =
+                loop.lastToolResult !== undefined && !loop.text ? loop.lastToolResult : loop.raw;
+              attemptCost = loop.cost;
+              totalCost += attemptCost;
+              if (loop.denials.length > 0 && loop.trail.every((t) => t.status === "denied")) {
+                throw new Error(
+                  `ai: all tool calls denied for prompt "${prompt}": ${loop.denials[0]?.reason}`,
+                );
+              }
+            } else {
+              const result = await client.complete({
+                model: wireModel(modelName, client),
+                messages: [{ role: "user", content: userContent }],
+                responseFormat: decl.out,
+                ...(signal !== undefined ? { signal } : {}),
               });
+              attemptCost = result.usage?.cost ?? 0;
+              totalCost += attemptCost;
+              // Prefer assistant text — `raw` is often the transport envelope
+              // (OpenAI chat.completion object), which must not shadow the content.
+              raw =
+                typeof result.text === "string" && result.text.length > 0
+                  ? result.text
+                  : result.raw !== undefined
+                    ? result.raw
+                    : result.text;
             }
-            return output;
-          } catch (err) {
-            if (err instanceof AiSchemaValidationError) {
-              lastSchema = err.mismatch;
+
+            const latencyMs = Math.max(0, now() - attemptStart);
+
+            try {
+              const coerced = coerceModelObject(raw);
+              const prepared = outExpectsVia(decl.out) ? { ...coerced, via: modelName } : coerced;
+              const validated = decl.out
+                ? validatePromptOut(prompt, version, decl.out, prepared)
+                : prepared;
+              // Always report the winning logical model for recovery chains.
+              const output = { ...validated, via: modelName };
               attempts.push({
                 model: modelName,
                 ok: true,
@@ -600,30 +611,79 @@ export function createAiRuntime(options: CreateAiRuntimeOptions = {}): AiRuntime
                   prompt,
                   ...(version !== undefined ? { version } : {}),
                   input,
-                  output: coerceModelObject(raw),
+                  output,
                   attempts: [...attempts],
-                  outcome: "schema_invalid",
+                  outcome: "ok",
                   cost: totalCost,
                   latencyMs: Math.max(0, now() - started),
-                  schemaMismatch: err.mismatch,
                   at: now(),
                 });
               }
+              return output;
+            } catch (err) {
+              if (err instanceof AiSchemaValidationError) {
+                lastSchema = err.mismatch;
+                attempts.push({
+                  model: modelName,
+                  ok: true,
+                  cost: attemptCost,
+                  latencyMs,
+                  at: now(),
+                });
+                if (journalingForced) {
+                  journal.push({
+                    prompt,
+                    ...(version !== undefined ? { version } : {}),
+                    input,
+                    output: coerceModelObject(raw),
+                    attempts: [...attempts],
+                    outcome: "schema_invalid",
+                    cost: totalCost,
+                    latencyMs: Math.max(0, now() - started),
+                    schemaMismatch: err.mismatch,
+                    at: now(),
+                  });
+                }
+                throw err;
+              }
               throw err;
             }
-            throw err;
+          } catch (err) {
+            if (err instanceof AiSchemaValidationError) throw err;
+            lastError = err instanceof Error ? err.message : String(err);
+            attempts.push({
+              model: modelName,
+              ok: false,
+              error: lastError,
+              cost: 0,
+              latencyMs: Math.max(0, now() - attemptStart),
+              at: now(),
+            });
+
+            if (!isRetryableAiError(err)) {
+              if (journalingForced) {
+                journal.push({
+                  prompt,
+                  ...(version !== undefined ? { version } : {}),
+                  input,
+                  output: { error: lastError },
+                  attempts,
+                  outcome: "provider_error",
+                  cost: totalCost,
+                  latencyMs: Math.max(0, now() - started),
+                  at: now(),
+                });
+              }
+              throw err instanceof Error ? err : new Error(String(err));
+            }
+
+            if (sameModelTries < 2) {
+              await new Promise((r) => setTimeout(r, AI_SAME_MODEL_RETRY_BACKOFF_MS));
+              continue;
+            }
+            advance = true;
+            break;
           }
-        } catch (err) {
-          if (err instanceof AiSchemaValidationError) throw err;
-          lastError = err instanceof Error ? err.message : String(err);
-          attempts.push({
-            model: modelName,
-            ok: false,
-            error: lastError,
-            cost: 0,
-            latencyMs: Math.max(0, now() - attemptStart),
-            at: now(),
-          });
         }
       }
 

package/src/elements/ai/tools.test.ts

@@ -58,7 +58,7 @@ describe("fx.ask tools via fx.call", () => {
     });
 
     const out = await fx.ask(prompt, { q: "status?" }, { tools: ["lookup.booking"], maxSteps: 4 });
-    expect(out).toEqual({ answer: "found" });
+    expect(out).toEqual({ answer: "found", via: "smart" });
     expect(calls).toEqual([{ name: "lookup.booking", input: { id: "B9" } }]);
     expect(ledger.entries.some((e) => e.kind === "ask" && e.resource === "assistant")).toBe(true);
     expect(

package/src/elements/ai.test.ts

@@ -29,10 +29,14 @@ describe("ai declaration", () => {
       version: 3,
       evals: "./evals/triage.jsonl",
       budget: { maxCostPerCall: 0.02 },
+      via: ["smart", "fast"],
+      timeout: "30s",
     });
     expect(triage.name).toBe("ticket-triage");
     expect(triage.version).toBe(3);
     expect(triage.model).toBe("smart");
+    expect(triage.via).toEqual(["smart", "fast"]);
+    expect(triage.timeout).toBe("30s");
 
     const agent = ai.agent("support", {
       tools: [{ name: "bookings.getBooking" }, "bookings.refundBooking"],
@@ -334,12 +338,105 @@ describe("model fallback chain", () => {
       },
     );
     expect(out.urgency).toBe("low");
+    expect(out.via).toBe("fast");
     const entry = runtime.journal[0]!;
-    expect(entry.attempts).toHaveLength(2);
+    // Same-model retry (1) + second model success.
+    expect(entry.attempts.length).toBeGreaterThanOrEqual(2);
     expect(entry.attempts[0]).toMatchObject({ model: "smart", ok: false });
-    expect(entry.attempts[1]).toMatchObject({ model: "fast", ok: true });
+    expect(entry.attempts.at(-1)).toMatchObject({ model: "fast", ok: true });
     expect(entry.outcome).toBe("ok");
   });
+
+  test("prompt.via is used when ask omits via", async () => {
+    const failing = {
+      driverId: "mock" as const,
+      model: "smart",
+      async complete() {
+        throw new Error("smart down");
+      },
+    };
+    const ok = await createMockAiDriver({
+      "*": { summary: "ok" },
+    }).open({ model: "local" });
+    const smart = ai.model("smart", { provider: "mock" });
+    const local = ai.model("local", { provider: "mock" });
+    const summarize = smart.prompt("summarize-note", {
+      via: ["smart", "local"],
+      timeout: "30s",
+    });
+    const runtime = createAiRuntime({
+      models: [smart, local],
+      prompts: [summarize],
+      clients: { smart: failing, local: ok },
+    });
+    const out = await runtime.ask("summarize-note", { body: "x" });
+    expect(out.summary).toBe("ok");
+    expect(out.via).toBe("local");
+  });
+
+  test("permanent 401 does not advance via", async () => {
+    const unauthorized = {
+      driverId: "mock" as const,
+      model: "smart",
+      async complete() {
+        const err = new Error("openai-compatible HTTP 401") as Error & { status: number };
+        err.status = 401;
+        throw err;
+      },
+    };
+    let localCalls = 0;
+    const local = {
+      driverId: "mock" as const,
+      model: "local",
+      async complete() {
+        localCalls++;
+        return { text: "{}", raw: { summary: "nope" }, model: "local", driverId: "mock" as const };
+      },
+    };
+    const smart = ai.model("smart", { provider: "mock" });
+    const localModel = ai.model("local", { provider: "mock" });
+    const prompt = smart.prompt("summarize-note", { via: ["smart", "local"] });
+    const runtime = createAiRuntime({
+      models: [smart, localModel],
+      prompts: [prompt],
+      clients: { smart: unauthorized, local },
+    });
+    await expect(runtime.ask("summarize-note", {})).rejects.toThrow(/401/);
+    expect(localCalls).toBe(0);
+  });
+
+  test("timeout aborts a hanging complete", async () => {
+    const hanging = {
+      driverId: "mock" as const,
+      model: "smart",
+      async complete(opts: { signal?: AbortSignal }) {
+        const signal = opts.signal;
+        if (!signal) throw new Error("expected abort signal");
+        await new Promise<void>((_resolve, reject) => {
+          const onAbort = () => {
+            const err = new Error("aborted");
+            err.name = "AbortError";
+            reject(err);
+          };
+          if (signal.aborted) {
+            onAbort();
+            return;
+          }
+          signal.addEventListener("abort", onAbort, { once: true });
+        });
+        return { text: "late", raw: { text: "late" }, model: "smart", driverId: "mock" as const };
+      },
+    };
+    const smart = ai.model("smart", { provider: "mock" });
+    const prompt = smart.prompt("hang", { timeout: 40 });
+    const runtime = createAiRuntime({
+      models: [smart],
+      prompts: [prompt],
+      clients: { smart: hanging },
+      forceJournal: false,
+    });
+    await expect(runtime.ask("hang", {})).rejects.toThrow();
+  }, 2_000);
 });
 
 describe("schema-validation is its own class", () => {

package/src/elements/ai.ts

@@ -12,7 +12,7 @@
  * @module
  */
 
-export { ai } from "./ai/declare.ts";
+export { ai, listAiDecls, resetAiDecls } from "./ai/declare.ts";
 export type {
   AiAgentDecl,
   AiAgentOptions,
@@ -23,8 +23,18 @@ export type {
   AiModelOptions,
   AiPromptDecl,
   AiPromptOptions,
+  AiTimeout,
 } from "./ai/declare.ts";
 
+export {
+  aiHttpError,
+  isRetryableAiError,
+  mergeAskAbortSignal,
+  outExpectsVia,
+  resolveTimeoutMs,
+} from "./ai/errors.ts";
+export type { AiErrorFields } from "./ai/errors.ts";
+
 export {
   createAiRuntime,
   AiSchemaValidationError,

package/src/elements/index.ts

@@ -163,6 +163,8 @@ export type {
 
 export {
   ai,
+  listAiDecls,
+  resetAiDecls,
   createAiRuntime,
   assertAllowPiiForAsk,
   AiPiiBuildError,