pi-fabric 0.109.5 → 0.110.0

package/dist/chunks/chunk-3R6NIF2N.js

@@ -0,0 +1,844 @@
+import {
+  JevClient,
+  JevCredentials
+} from "./chunk-W5CHVJBR.js";
+import {
+  checkObserve,
+  jevObserveSchema
+} from "./chunk-5DKVWEE4.js";
+import {
+  checkSchema,
+  checkValue,
+  jsonText,
+  object
+} from "./chunk-WHBJDTCR.js";
+import {
+  validationMessage
+} from "./chunk-A5XF3ZPJ.js";
+import {
+  runAbortable
+} from "./chunk-7TB7NXSL.js";
+import {
+  ApprovalController,
+  FabricAutoApprovalClassifier,
+  FabricSessionApprovals
+} from "./chunk-DSNR5U7X.js";
+import {
+  DECISION_APIS,
+  DECISION_MAX_BYTES
+} from "./chunk-GUZG4GGT.js";
+import {
+  resolveJevModelRoute
+} from "./chunk-B54Z662X.js";
+
+// src/providers/jev-provider.ts
+import { Type as Type2 } from "typebox";
+
+// src/jev/manager.ts
+import { randomUUID } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+
+// src/jev/decisions.ts
+var canonical = (provider) => provider === "vercel-ai-gateway" ? "vercel" : provider === "jev" ? "typesafe" : provider;
+var authProvider = (provider) => ["vercel", "vercel-evaluate", "vercel-decisions"].includes(provider) ? "vercel-ai-gateway" : provider;
+var envKeys = {
+  typesafe: ["TYPESAFE_API_KEY"],
+  openrouter: ["OPENROUTER_API_KEY", "TYPESAFE_OPENROUTER_API_KEY"],
+  "vercel-ai-gateway": ["AI_GATEWAY_API_KEY"],
+  openai: ["OPENAI_API_KEY"],
+  "cloudflare-workers-ai": ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_API_KEY"],
+  opencode: ["OPENCODE_API_KEY"],
+  "llama.cpp": ["LLAMA_API_KEY"],
+  "llama-system-one": ["LLAMA_API_KEY"],
+  anthropic: ["ANTHROPIC_API_KEY"],
+  google: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+  custom: ["DECISION_API_KEY"]
+};
+function decisionEnvironment(config, source = process.env) {
+  const env = { ...source };
+  for (const key of ["DECISION_PROVIDER", "DECISION_MODEL", "DECISION_ENDPOINT", "DECISION_PROFILE", "DECISION_PROFILES", "DECISION_PROFILES_FILE", "DECISION_CREDENTIAL_COMMAND", ...Object.values(envKeys).flat()]) delete env[key];
+  if (config.decisionProfiles) env.DECISION_PROFILES = JSON.stringify(config.decisionProfiles);
+  if (config.decisionProfile) env.DECISION_PROFILE = config.decisionProfile;
+  return env;
+}
+function registeredTarget(model, presets) {
+  const api = { "typesafe-system-one": "system-one", "cloudflare-workers-ai-system-one": "cloudflare", "openai-decisions": "openai-decisions", "llama-cpp-classify": "llama-cpp" }[model.api];
+  if (!api || !model.baseUrl) return void 0;
+  const provider = canonical(model.provider);
+  const preset = presets.find((p) => p.provider === provider);
+  const nativeProvider = preset?.api === api ? provider : "custom";
+  let endpoint = model.baseUrl.replace(/\/+$/, "");
+  const account = process.env.CLOUDFLARE_ACCOUNT_ID;
+  if (api === "cloudflare" && account && /^[a-fA-F0-9]{32}$/.test(account)) endpoint = endpoint.replaceAll("{CLOUDFLARE_ACCOUNT_ID}", account);
+  if (api === "system-one") endpoint += "/systemone";
+  if (api === "openai-decisions") endpoint += "/decisions";
+  if (api === "cloudflare") {
+    endpoint += "/run";
+    if (["clef", "clef-flash", "@cf/cloudflare/clef", "@cf/cloudflare/clef-flash"].includes(model.id)) endpoint += `/@cf/cloudflare/${model.id.split("/").at(-1)}`;
+  }
+  if (api === "llama-cpp") endpoint = endpoint.replace(/\/v1$/, "");
+  return { provider: nativeProvider, api, model: model.id, endpoint };
+}
+function catalog(registry) {
+  return registry?.getModelsOfType?.("classifier") ?? [];
+}
+function freeze(value) {
+  if (value && typeof value === "object") {
+    Object.freeze(value);
+    for (const child of Object.values(value)) freeze(child);
+  }
+  return value;
+}
+function snapshot(value) {
+  const text = JSON.stringify(value, (_key, item) => {
+    if (typeof item === "number" && !Number.isFinite(item) || ["bigint", "function", "symbol", "undefined"].includes(typeof item)) throw new Error("Decision requests must contain finite JSON values");
+    return item;
+  });
+  if (!text || Buffer.byteLength(text, "utf8") > DECISION_MAX_BYTES) throw new Error("Decision request exceeds 16 MiB JSON limit");
+  return freeze(JSON.parse(text));
+}
+function decisionUsage(result) {
+  const count = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0 ? v : null;
+  const input = count(result?.usage?.input_tokens), output = count(result?.usage?.output_tokens);
+  return { input, output, exhausted: input === null || output === null || result?.budget?.exhausted === true };
+}
+var JevDecisions = class _JevDecisions {
+  #config;
+  #commands = /* @__PURE__ */ new Map();
+  #exhausted = /* @__PURE__ */ new WeakSet();
+  constructor(config) {
+    this.#config = structuredClone(config);
+  }
+  /** Freeze the selected default for a newly launched managed program. */
+  fork() {
+    return new _JevDecisions(this.#config);
+  }
+  /** Trusted UI-only selector update. Existing request snapshots and budgets survive. */
+  setProfile(profile) {
+    if (profile !== void 0 && profile !== null && (!/^[A-Za-z0-9_.-]{1,128}$/.test(profile) || !this.#config.decisionProfiles || !Object.hasOwn(this.#config.decisionProfiles.profiles, profile)))
+      throw new Error("jev.decisionProfile must name a known decision profile");
+    if (profile === void 0) delete this.#config.decisionProfile;
+    else this.#config.decisionProfile = profile;
+  }
+  async providers(serve, signal) {
+    return serve.request("decisionProviders", {}, signal);
+  }
+  #profile(request) {
+    const profile = request.profile ?? (request.provider === void 0 ? this.#config.decisionProfile ?? this.#config.decisionProfiles?.defaultProfile : void 0);
+    if (profile !== void 0) {
+      const profiles = this.#config.decisionProfiles?.profiles;
+      const target = profiles && Object.hasOwn(profiles, profile) ? profiles[profile] : void 0;
+      if (!target) throw new Error("Unknown decision profile");
+      if (request.provider !== void 0 && canonical(request.provider) !== canonical(target.provider)) throw new Error("Decision profile and provider disagree");
+    }
+    return profile;
+  }
+  async #resolve(serve, original, context) {
+    const request = snapshot(original);
+    const profile = this.#profile(request);
+    const trustedProfile = profile ? this.#config.decisionProfiles.profiles[profile] : void 0;
+    const effective = { ...trustedProfile, ...request };
+    delete effective.profile;
+    const selectedProvider = canonical(effective.provider ?? "typesafe");
+    const selectedModel = effective.model;
+    const presets = await this.providers(serve, context.signal);
+    const models = catalog(context.extensionContext.modelRegistry);
+    const registered = models.find((m) => canonical(m.provider) === selectedProvider && m.id === selectedModel);
+    const target = registered ? registeredTarget(registered, presets) : void 0;
+    const baseline = { ...effective, provider: selectedProvider };
+    delete baseline.endpoint;
+    if (trustedProfile?.endpoint) {
+      baseline.endpoint = trustedProfile.endpoint;
+      if (!presets.some((p) => p.provider === selectedProvider)) {
+        baseline.provider = "custom";
+        if (baseline.api === void 0 && target?.api) baseline.api = target.api;
+      }
+    } else if (target) {
+      if (effective.api !== void 0 && effective.api !== target.api) throw new Error("Decision API differs from the registered classifier target");
+      Object.assign(baseline, target);
+    }
+    if (selectedProvider === "custom" && !trustedProfile && !target) throw new Error("Custom decision targets require a trusted profile or registered classifier");
+    const raw = await serve.request("resolveDecision", { request: baseline }, context.signal);
+    const resolvedEndpoint = raw.target.endpoint;
+    if (request.endpoint !== void 0 && request.endpoint !== resolvedEndpoint) throw new Error("Decision endpoint must exactly match a trusted profile, registered classifier route, or preset default");
+    const cleanTarget = {
+      provider: raw.target.provider,
+      api: raw.target.api,
+      model: raw.target.model,
+      endpoint: raw.target.endpoint,
+      allowLocal: raw.target.allowLocal,
+      allowGenerated: raw.target.allowGenerated,
+      ...raw.target.providerOptions === void 0 ? {} : { providerOptions: raw.target.providerOptions },
+      ...raw.target.temperature === void 0 ? {} : { temperature: raw.target.temperature }
+    };
+    const resolution = freeze({ target: cleanTarget, credential: { env: raw.credential.env, resolved: false }, imageSupport: raw.imageSupport, generated: raw.generated, ...profile ? { profile } : {} });
+    const prepared = freeze({ ...effective, ...resolution.target });
+    return { resolution, request: prepared, auth: authProvider(selectedProvider) };
+  }
+  async resolve(serve, request, context) {
+    return (await this.#resolve(serve, request, context)).resolution;
+  }
+  async models(serve, context) {
+    const presets = await this.providers(serve, context.signal);
+    const registry = context.extensionContext.modelRegistry;
+    return Promise.all(catalog(registry).map(async (model) => {
+      const target = registeredTarget(model, presets);
+      let capabilities;
+      if (target) {
+        try {
+          capabilities = await serve.request("resolveDecision", { request: {
+            ...target,
+            ...target.api === "llama-cpp" || target.api === "llama-system-one" ? { allowLocal: true } : {},
+            state: {},
+            questions: { capability: { type: "boolean", instructions: "Offline capability validation only" } }
+          } }, context.signal);
+        } catch (error) {
+          if (context.signal?.aborted || serve.closed) throw error;
+        }
+      }
+      const support = capabilities?.imageSupport ?? "unsupported";
+      const provider = authProvider(canonical(model.provider));
+      const configured = provider === "typesafe" && registry?.getProviderAuthStatus?.("jev")?.configured || registry?.getProviderAuthStatus?.(provider)?.configured || (envKeys[provider] ?? []).some((key) => !!process.env[key]?.trim()) || provider === authProvider(canonical(resolveJevModelRoute(this.#config.model).route.id)) && this.#config.credentialCommand.length > 0;
+      return {
+        model: { provider: model.provider, id: model.id },
+        name: model.name,
+        api: model.api,
+        ...target ? { target: { ...target, provider: model.provider } } : {},
+        supported: !!capabilities,
+        imageSupport: !model.input.includes("image") || support === "unsupported" || canonical(model.provider) === "openrouter" ? "unsupported" : support,
+        generated: capabilities?.generated ?? false,
+        logits: target?.api === "llama-cpp",
+        credentials: { configured: !!configured, verified: false }
+      };
+    }));
+  }
+  async #credential(provider, registry, signal, local) {
+    signal.throwIfAborted();
+    try {
+      const ids = provider === "typesafe" ? ["jev", "typesafe"] : [provider];
+      for (const id of ids) {
+        const key = await runAbortable(signal, () => registry?.getApiKeyForProvider?.(id));
+        if (key?.trim()) return key.trim();
+      }
+    } catch {
+      throw new Error("Decision Pi credential resolution failed");
+    }
+    const keys = envKeys[provider] ?? [];
+    for (const key of keys) if (process.env[key]?.trim()) return process.env[key].trim();
+    const legacyProvider = authProvider(canonical(resolveJevModelRoute(this.#config.model).route.id));
+    if (provider === legacyProvider && this.#config.credentialCommand.length) {
+      let credentials = this.#commands.get(provider);
+      if (!credentials) {
+        credentials = new JevCredentials(this.#config.credentialCommand, {}, void 0, keys);
+        this.#commands.set(provider, credentials);
+      }
+      return credentials.resolve(signal);
+    }
+    if (local) return "";
+    throw new Error("Decision credentials unavailable for the selected provider");
+  }
+  async decide(serve, request, context) {
+    if (this.#exhausted.has(serve)) throw new Error("Decision inference budget exhausted or prior usage unknown");
+    const signal = AbortSignal.any([...context.signal ? [context.signal] : [], AbortSignal.timeout(this.#config.requestTimeoutMs)]);
+    const selected = await this.#resolve(serve, request, { ...context, signal });
+    const url = new URL(selected.resolution.target.endpoint);
+    const local = selected.resolution.target.allowLocal && ["127.0.0.1", "[::1]"].includes(url.hostname) && !["anthropic", "google"].includes(selected.resolution.target.api);
+    const credential = await this.#credential(selected.auth, context.extensionContext.modelRegistry, signal, local);
+    signal.throwIfAborted();
+    if (this.#exhausted.has(serve)) throw new Error("Decision inference budget exhausted or prior usage unknown");
+    try {
+      const result = await serve.request("decide", { request: selected.request, timeoutMs: this.#config.requestTimeoutMs, credential }, signal);
+      if (decisionUsage(result).exhausted) this.#exhausted.add(serve);
+      return result;
+    } catch (error) {
+      this.#exhausted.add(serve);
+      if (signal.aborted) await serve.close();
+      throw error;
+    }
+  }
+  close() {
+    for (const credentials of this.#commands.values()) credentials.clear();
+    this.#commands.clear();
+  }
+};
+
+// src/jev/manager.ts
+var prelude = `const input = JSON.parse(\u03C0.__jevInput);
+const program = Object.freeze({
+  sleep: (ms: number): Promise<unknown> => tools.call({ ref: "jev.$sleep", args: { ms } }),
+  emit: (value: unknown): Promise<unknown> => tools.call({ ref: "jev.$emit", args: { value } }),
+  nextEvent: (): Promise<FabricJevHostEvent> => tools.call({ ref: "jev.$nextEvent" }) as Promise<FabricJevHostEvent>,
+  advise: (args: {eventId: string; message: string}): Promise<FabricJevAdviceResult> => tools.call({ ref: "jev.advise", args: {...args, id: \u03C0.__jevRunId} }) as Promise<FabricJevAdviceResult>,
+});
+`;
+var JevProgramManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  #runs = /* @__PURE__ */ new Map();
+  #approvals = new FabricSessionApprovals();
+  #closed = false;
+  #starting = 0;
+  usesDecisions(id) {
+    return this.#runs.get(id)?.usesDecisions ?? false;
+  }
+  inferenceLimits(id) {
+    return this.#runs.get(id)?.inferenceLimits;
+  }
+  list() {
+    return [...this.#runs.values()].map(({ info }) => ({
+      id: info.id,
+      name: info.name,
+      state: info.state,
+      background: info.background,
+      startedAt: info.startedAt,
+      evaluations: info.evaluations,
+      toolCalls: info.toolCalls,
+      ...info.observation ? { observation: structuredClone(info.observation) } : {}
+    }));
+  }
+  #get(id) {
+    const run = this.#runs.get(id);
+    if (!run) throw new Error("Unknown or expired Jev run ID");
+    return run;
+  }
+  status(id, after = 0) {
+    const info = this.#get(id).info;
+    return structuredClone({ ...info, events: info.events.filter((e) => e.sequence > after) });
+  }
+  async wait(id, signal) {
+    return structuredClone(await runAbortable(signal, () => this.#get(id).done));
+  }
+  /** Alias for wait. */
+  join(id, signal) {
+    return this.wait(id, signal);
+  }
+  async stop(id) {
+    const run = this.#get(id);
+    if (run.info.state === "running") run.controller.abort(new Error("Jev run stopped"));
+    return structuredClone(await run.done);
+  }
+  advise(id, eventId, message) {
+    if (typeof message !== "string" || !message.trim() || message.length > 2e3 || typeof eventId !== "string" || eventId.length > 256)
+      throw new Error("Advice requires a current eventId and 1\u20132000 message characters");
+    const run = this.#get(id);
+    if (!run.observation) throw new Error("Jev run has no observation subscription");
+    return run.observation.advise(eventId, message);
+  }
+  async launch(request, context, background) {
+    const { config, registry } = this.options;
+    if (this.#closed) throw new Error("Jev program manager is closed");
+    if (this.#starting + [...this.#runs.values()].filter((r) => r.info.state === "running").length >= config.jev.maxConcurrentRuns)
+      throw new Error("Jev concurrent run limit reached");
+    context.signal?.throwIfAborted();
+    this.#starting++;
+    let lease;
+    let starting = true;
+    try {
+      const { program: definition, input, observe } = structuredClone(request);
+      const observationHost = this.options.observationHost;
+      const observationRevision = observationHost?.revision;
+      if (observe !== void 0) {
+        checkObserve(observe);
+        if (!background) throw new Error("Observation requires jev.spawn; foreground runs cannot wait for their own turn to end");
+        if (!observationHost) throw new Error("Main lifecycle observation is unavailable in this host");
+        if (context.extensionContext.sessionManager?.getSessionId() !== observationHost.sessionId)
+          throw new Error("Jev observation is scoped to its owning Main session");
+      }
+      checkSchema(definition.inputSchema);
+      checkSchema(definition.outputSchema);
+      checkValue(definition.inputSchema, input, "Program input");
+      const requires = [...new Set(definition.requires)];
+      for (const ref of requires) {
+        if (!/^[a-z][a-z0-9_-]*\.[a-zA-Z0-9_.$-]+$/.test(ref) || ref.startsWith("jev.") && !["jev.evaluate", "jev.decide", "jev.resolveDecision", "jev.decisionProviders", "jev.models", "jev.advise"].includes(ref))
+          throw new Error("Programs require exact action refs; recursive Jev lifecycle calls are not allowed");
+        if (context.capabilityView && !Object.hasOwn(context.capabilityView.bindings, ref))
+          throw new Error(`Jev program cannot widen its caller's capabilities: ${ref}`);
+        if (!config.fullCodeMode && (ref.startsWith("pi.") || ref.startsWith("extensions.")))
+          throw new Error("Full-code tool access is disabled");
+      }
+      lease = await registry.acquireCapabilityView(requires, context);
+      if (!lease.satisfied || !lease.view) throw new Error(`Missing Jev program capabilities: ${lease.missing.join(", ")}`);
+      if (context.capabilityView) for (const ref of requires) {
+        const before = context.capabilityView.bindings[ref];
+        const after = lease.view.bindings[ref];
+        if (before.providerBindingId !== after.providerBindingId || before.descriptorHash !== after.descriptorHash)
+          throw new Error("Caller capability generation changed; relaunch with a fresh commitment");
+      }
+      const { TypeScriptKernelRuntime } = await import("../runtime/typescript-kernel.js");
+      const runtime = new TypeScriptKernelRuntime("quickjs");
+      const sources = await registry.guestTypeSources({ ...context, capabilityView: lease.view });
+      const { code, checked } = runtime.prepare(prelude + definition.code, true, [], sources, [], true);
+      if (checked.errors.length) throw new Error(`Jev program typecheck failed: ${checked.errors.map((e) => e.message).join("; ").slice(0, 2e3)}`);
+      const approval = new ApprovalController(config.approvals, context.extensionContext, this.#approvals, new FabricAutoApprovalClassifier(() => config.jev));
+      if (observe) await approval.approve({
+        ref: "jev.spawn",
+        provider: "jev",
+        name: "spawn",
+        description: "Observe future Main lifecycle events and explicitly selected content for a bounded Jev program",
+        inputSchema: {},
+        risk: "read"
+      }, { observe });
+      if (this.#closed) throw new Error("Jev program manager is closed");
+      context.signal?.throwIfAborted();
+      if (observe && observationHost.revision !== observationRevision)
+        throw new Error("Main lifecycle changed while preparing the observer; relaunch explicitly with current context");
+      const limits = definition.limits ?? {};
+      const bounded = (value, fallback, ceiling) => Math.min(value ?? fallback, ceiling);
+      const timeoutMs = bounded(limits.timeoutMs, 6e4, config.jev.maxDurationMs);
+      const maxEvaluations = bounded(limits.maxEvaluations, 100, config.jev.maxEvaluations);
+      const maxToolCalls = bounded(limits.maxToolCalls, 1e3, config.jev.maxToolCalls);
+      const maxTokens = bounded(limits.maxTokens, 1e5, config.jev.maxTokens);
+      const id = randomUUID();
+      const controller = new AbortController();
+      const info = {
+        id,
+        name: definition.name,
+        state: "running",
+        background,
+        startedAt: Date.now(),
+        evaluations: 0,
+        toolCalls: 0,
+        usage: { input_tokens: 0, output_tokens: 0 },
+        events: [],
+        nextSequence: 1,
+        logs: []
+      };
+      let budgetFailure;
+      const failBudget = (message) => {
+        budgetFailure = message;
+        queueMicrotask(() => controller.abort(new Error(message)));
+        throw new Error(message);
+      };
+      const observation = observe ? observationHost.subscribe(observe, { id, name: definition.name }, controller) : void 0;
+      if (observation) info.observation = observation.stats;
+      const runLease = lease;
+      lease = void 0;
+      const abort = () => controller.abort(new Error("Foreground caller cancelled"));
+      if (!background) context.signal?.addEventListener("abort", abort, { once: true });
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort(new Error("Jev deadline exceeded"));
+      }, timeoutMs);
+      let evaluating = false;
+      let inferenceBlocked = false;
+      let reportedTokens = 0;
+      const audits = [];
+      const emit = (value) => {
+        jsonText(value, 4096, "Program event");
+        info.events.push({ sequence: info.nextSequence++, at: Date.now(), value });
+        if (info.events.length > 64) info.events.shift();
+      };
+      const run = { info, controller, observation, usesDecisions: requires.includes("jev.decide"), inferenceLimits: { evaluations: maxEvaluations, tokens: maxTokens }, done: void 0 };
+      this.#runs.set(id, run);
+      this.options.onRunStarted?.(id);
+      this.#starting--;
+      starting = false;
+      this.#prune();
+      run.done = (async () => {
+        try {
+          await delay(0, void 0, { signal: controller.signal });
+          const result = await runtime.execute(code, async (rawRef, rawArgs, signal) => {
+            signal.throwIfAborted();
+            controller.signal.throwIfAborted();
+            if (budgetFailure) throw new Error(budgetFailure);
+            if (++info.toolCalls > maxToolCalls) return failBudget("Jev tool-call budget exhausted");
+            const ref = rawRef === "fabric.$call" ? rawArgs.ref : rawRef;
+            const args = rawRef === "fabric.$call" ? rawArgs.args ?? {} : rawArgs;
+            if (typeof ref !== "string" || !object(args)) throw new Error("Invalid Jev program tool call");
+            if (ref === "jev.$sleep") {
+              if (typeof args.ms !== "number" || !Number.isFinite(args.ms) || args.ms < 0 || args.ms > timeoutMs) throw new Error("Invalid program.sleep duration");
+              await delay(args.ms, void 0, { signal });
+              return null;
+            }
+            if (ref === "jev.$emit") {
+              emit(args.value);
+              return null;
+            }
+            if (ref === "jev.$nextEvent") {
+              if (!observation) throw new Error("program.nextEvent requires observe on jev.spawn");
+              return observation.next();
+            }
+            if (ref === "jev.advise" && args.id !== id) throw new Error("A Jev program can only advise through its own run");
+            if (!Object.hasOwn(runLease.view.bindings, ref)) throw new Error(`Capability not granted to Jev program: ${ref}`);
+            const inference = ref === "jev.evaluate" || ref === "jev.decide";
+            if (inference) {
+              if (evaluating) throw new Error("One Jev evaluation may be in flight per program; batch independent questions in one request");
+              if (inferenceBlocked || info.evaluations >= maxEvaluations || reportedTokens >= maxTokens)
+                return failBudget("Jev inference budget exhausted");
+              info.evaluations++;
+              evaluating = true;
+            }
+            let accounted = false;
+            try {
+              const value = await registry.invoke(ref, args, {
+                cwd: context.cwd,
+                extensionContext: context.extensionContext,
+                signal,
+                capabilityView: runLease.view,
+                ...context.effectPolicy ? { effectPolicy: context.effectPolicy } : {},
+                parentToolCallId: `jev:${id}`,
+                nestedToolCallId: `jev:${id}:${info.toolCalls}`,
+                update() {
+                },
+                activity() {
+                },
+                attachMedia() {
+                },
+                attachPreview() {
+                },
+                authorize: async (action) => {
+                  await this.options.authorize?.(action.ref, `jev:${id}`);
+                },
+                approve: async (action, prepared) => {
+                  if (action.ref === "schema.commit") {
+                    await approval.approve({ ...action, risk: "write" }, prepared);
+                    await approval.approve({ ...action, risk: "execute" }, prepared);
+                  } else await approval.approve(action, prepared);
+                },
+                audits,
+                maxResultChars: ref === "jev.decide" ? DECISION_MAX_BYTES : ref === "jev.evaluate" ? 1048576 : config.executor.maxNestedResultChars
+              });
+              if (inference) {
+                const response = ref === "jev.decide" ? decisionUsage(value) : {
+                  input: value.usage.input_tokens,
+                  output: value.usage.output_tokens,
+                  exhausted: false
+                };
+                info.usage.input_tokens = response.input === null || info.usage.input_tokens === null ? null : info.usage.input_tokens + response.input;
+                info.usage.output_tokens = response.output === null || info.usage.output_tokens === null ? null : info.usage.output_tokens + response.output;
+                reportedTokens += (response.input ?? 0) + (response.output ?? 0);
+                inferenceBlocked ||= response.exhausted || reportedTokens >= maxTokens;
+                accounted = true;
+                if (ref === "jev.evaluate" && reportedTokens > maxTokens)
+                  return failBudget("Jev reported-token budget exhausted");
+              }
+              return value;
+            } catch (error) {
+              if (inference && !accounted) {
+                inferenceBlocked = true;
+                info.usage.input_tokens = null;
+                info.usage.output_tokens = null;
+              }
+              throw error;
+            } finally {
+              if (inference) evaluating = false;
+              if (audits.length > 64) audits.splice(0, audits.length - 64);
+            }
+          }, {
+            timeoutMs,
+            memoryLimitBytes: Math.min(config.executor.memoryLimitBytes, 64 * 1024 * 1024),
+            maxCpuSliceMs: 100,
+            maxPendingTimers: 128,
+            maxLogChars: 4096,
+            strings: { __jevInput: JSON.stringify(input), __jevRunId: id },
+            signal: controller.signal
+          });
+          info.logs = result.logs;
+          if (budgetFailure) {
+            info.state = "failed";
+            info.error = budgetFailure;
+          } else if (timedOut || result.terminationReason === "timed_out") {
+            info.state = "timed_out";
+            info.error = result.error ?? "Jev deadline exceeded";
+          } else if (controller.signal.aborted || result.terminationReason === "aborted") {
+            info.state = "cancelled";
+          } else if (result.terminationReason !== "completed") {
+            info.state = "failed";
+            info.error = result.error ?? "Jev program failed";
+          } else {
+            checkValue(definition.outputSchema, result.value, "Program output");
+            info.result = result.value;
+            info.state = "completed";
+          }
+        } catch (error) {
+          info.state = budgetFailure ? "failed" : timedOut ? "timed_out" : controller.signal.aborted ? "cancelled" : "failed";
+          info.error = (budgetFailure ?? (error instanceof Error ? error.message : "Jev program failed")).slice(0, 2e3);
+        } finally {
+          clearTimeout(timer);
+          observation?.close();
+          context.signal?.removeEventListener("abort", abort);
+          await registry.endInvocation(`jev:${id}`).catch(() => void 0);
+          await runLease.release();
+          info.endedAt = Date.now();
+          this.#prune();
+        }
+        return info;
+      })();
+      return background ? this.status(id) : structuredClone(await run.done);
+    } finally {
+      if (starting) this.#starting--;
+      await lease?.release();
+    }
+  }
+  #prune() {
+    for (const [id, run] of this.#runs) {
+      if (this.#runs.size <= this.options.config.jev.maxRetainedRuns) break;
+      if (run.info.state !== "running") this.#runs.delete(id);
+    }
+  }
+  stopAll() {
+    for (const run of this.#runs.values()) if (run.info.state === "running") run.controller.abort(new Error("Jev provider closed"));
+  }
+  async close() {
+    this.#closed = true;
+    const running = [...this.#runs.values()].filter((r) => r.info.state === "running");
+    this.stopAll();
+    await Promise.all(running.map((r) => r.done));
+    this.#runs.clear();
+  }
+};
+
+// src/jev/decision-schema.ts
+import { Type } from "typebox";
+var description = Type.Union([Type.String(), Type.Array(Type.Unknown()), Type.Record(Type.String(), Type.Unknown())]);
+var question = Type.Union([
+  Type.Object({ type: Type.Union(["boolean", "bool", "noul", "predicate"].map((v) => Type.Literal(v))), instructions: description, criteria: Type.Optional(Type.Object({ true: Type.Optional(description), false: Type.Optional(description) }, { additionalProperties: false })) }, { additionalProperties: false }),
+  Type.Object({ type: Type.Literal("choice"), instructions: description, criteria: Type.Record(Type.String(), Type.Union([description, Type.Null()]), { minProperties: 1, maxProperties: 255 }) }, { additionalProperties: false }),
+  Type.Object({ type: Type.Literal("score"), instructions: description, criteria: Type.Array(description, { minItems: 2, maxItems: 10 }) }, { additionalProperties: false })
+]);
+var decisionRequestSchema = Type.Object({
+  state: description,
+  questions: Type.Record(Type.String({ minLength: 1, maxLength: 128 }), question, { minProperties: 1, maxProperties: 128 }),
+  profile: Type.Optional(Type.String({ pattern: "^[A-Za-z0-9_.-]{1,128}$" })),
+  provider: Type.Optional(Type.String({ minLength: 1, maxLength: 128 })),
+  api: Type.Optional(Type.Union(DECISION_APIS.map((v) => Type.Literal(v)))),
+  model: Type.Optional(Type.String({ minLength: 1 })),
+  endpoint: Type.Optional(Type.String({ minLength: 1 })),
+  allowLocal: Type.Optional(Type.Boolean()),
+  allowGenerated: Type.Optional(Type.Boolean()),
+  providerOptions: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+  temperature: Type.Optional(Type.Number()),
+  images: Type.Optional(Type.Array(Type.Object({ type: Type.Optional(Type.Literal("image")), data: Type.String({ minLength: 1 }), mimeType: Type.Union(["image/png", "image/jpeg", "image/webp", "image/gif"].map((v) => Type.Literal(v))) }, { additionalProperties: false }), { maxItems: 128 }))
+}, { additionalProperties: false });
+
+// src/providers/jev-provider.ts
+var description2 = Type2.Union([Type2.String(), Type2.Array(Type2.Unknown()), Type2.Record(Type2.String(), Type2.Unknown())]);
+var question2 = Type2.Union([
+  Type2.Object({ type: Type2.Literal("noul"), instructions: description2, criteria: Type2.Optional(Type2.Object({ true: Type2.Optional(description2), false: Type2.Optional(description2) }, { additionalProperties: false })) }, { additionalProperties: false }),
+  Type2.Object({ type: Type2.Literal("choice"), instructions: description2, criteria: Type2.Record(Type2.String(), Type2.Union([description2, Type2.Null()]), { minProperties: 1, maxProperties: 255 }) }, { additionalProperties: false }),
+  Type2.Object({ type: Type2.Literal("score"), instructions: description2, criteria: Type2.Array(description2, { minItems: 2, maxItems: 10 }) }, { additionalProperties: false })
+]);
+var jevRequestSchema = Type2.Object({
+  state: description2,
+  questions: Type2.Record(Type2.String(), question2, { minProperties: 1, maxProperties: 128 }),
+  model: Type2.Optional(Type2.String({ minLength: 1, maxLength: 128 }))
+}, { additionalProperties: false });
+var jevLaunchSchema = Type2.Object({
+  program: Type2.Object({
+    name: Type2.String({ minLength: 1, maxLength: 128 }),
+    code: Type2.String({ minLength: 1, maxLength: 65536 }),
+    inputSchema: Type2.Record(Type2.String(), Type2.Unknown()),
+    outputSchema: Type2.Record(Type2.String(), Type2.Unknown()),
+    requires: Type2.Array(Type2.String({ minLength: 3, maxLength: 256 }), { maxItems: 64, uniqueItems: true }),
+    limits: Type2.Optional(Type2.Object({
+      timeoutMs: Type2.Optional(Type2.Integer({ minimum: 1 })),
+      maxEvaluations: Type2.Optional(Type2.Integer({ minimum: 0 })),
+      maxToolCalls: Type2.Optional(Type2.Integer({ minimum: 1 })),
+      maxTokens: Type2.Optional(Type2.Integer({ minimum: 1 }))
+    }, { additionalProperties: false }))
+  }, { additionalProperties: false }),
+  input: Type2.Unknown(),
+  observe: Type2.Optional(jevObserveSchema)
+}, { additionalProperties: false });
+var idSchema = Type2.Object({ id: Type2.String({ minLength: 1, maxLength: 128 }) }, { additionalProperties: false });
+var statusSchema = Type2.Object({
+  id: Type2.Optional(Type2.String({ minLength: 1, maxLength: 128 })),
+  after: Type2.Optional(Type2.Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+var jevAdviceSchema = Type2.Object({
+  id: Type2.String({ minLength: 1, maxLength: 128 }),
+  eventId: Type2.String({ minLength: 1, maxLength: 256 }),
+  message: Type2.String({ minLength: 1, maxLength: 2e3 })
+}, { additionalProperties: false });
+var JEV_ACTION_DESCRIPTORS = [
+  { name: "decide", description: "Explicit lossless decision inference through native adapters. Returns status (including error), rawJson, provenance, refusals and nullable usage without legacy normalization. Requires decisions and decision-targets; no classify fallback. Endpoint overrides require an exact trusted profile/registered/preset route. Inspect budget.exhausted; calls consume credits.", inputSchema: decisionRequestSchema, risk: "network", effect: { kind: "emission", resources: ["decision:inference"], ordering: "ordered" } },
+  { name: "resolveDecision", description: "Resolve a per-call decision target offline before credentials. No model requests or key lookup; returns target, unresolved credential env, image support, generated flag and selected profile only.", inputSchema: Type2.Object({ request: decisionRequestSchema }, { additionalProperties: false }), risk: "read" },
+  { name: "decisionProviders", description: "List native decision adapter presets and capabilities offline. These are not verified live models or credential checks.", inputSchema: Type2.Object({}, { additionalProperties: false }), risk: "read" },
+  { name: "models", description: "List registered Pi classifier handles intersected with native decision adapter capabilities, image support, generated/logit provenance and unverified credential presence. No inference or credential resolver execution.", inputSchema: Type2.Object({}, { additionalProperties: false }), risk: "read" },
+  { name: "evaluate", description: "Ask Jev typed Choice, Noul (probability of yes), and Score questions over shared state. No generated text. Batch independent questions. Sends state to TypeSafe and consumes API credits; no automatic retries.", inputSchema: jevRequestSchema, risk: "network", effect: { kind: "emission", resources: ["typesafe:inference"], ordering: "unknown" } },
+  { name: "run", description: "Run a bounded TypeScript shell orchestrator or typed-decision program in the foreground. Returns a terminal run envelope with schema-validated result or error. Globals: input, jev.evaluate, program.sleep(ms), program.emit(value), and Fabric tools restricted to exact requires. Use granted pi.bash and tasks.wait/watch for shell orchestration; maxEvaluations:0 disables program inference. No automatic judgments, host imports or secrets.", inputSchema: jevLaunchSchema, risk: "execute" },
+  { name: "spawn", description: "Launch a session-owned background Jev program. Optional observe requires read approval and subscribes to Main lifecycle events; program.nextEvent waits without polling and shares only explicitly selected bounded context. program.advise needs observe.delivery and requires jev.advise. Use status, wait/join, and stop; not restart-durable.", inputSchema: jevLaunchSchema, risk: "execute" },
+  { name: "status", description: "Without id: credential configuration status (never retrieves secrets) and run summaries. With id: state, usage, bounded events after sequence, logs, result/error. Retains at most 64 events; nextSequence allows detecting gaps.", inputSchema: statusSchema, risk: "read" },
+  { name: "wait", description: "Wait for a background Jev program's terminal run envelope. Cancelling the wait does not cancel the program.", inputSchema: idSchema, risk: "read" },
+  { name: "join", description: "Alias for jev.wait: wait for a background Jev program's terminal run envelope without cancelling the program when the wait is cancelled.", inputSchema: idSchema, risk: "read" },
+  { name: "advise", description: "Deliver bounded advice from an observing Jev run to Main. Requires its current consumed eventId, explicit observe.delivery, freshness, message budget, and the per-input feedback gate. The program helper program.advise supplies its own id. Subject to agent approvals; returns delivered and an optional suppression reason.", inputSchema: jevAdviceSchema, risk: "agent", effect: { kind: "emission", resources: ["main:messages"], ordering: "ordered" } },
+  { name: "stop", description: "Cancel a Jev program and await sandbox cleanup. Idempotent for retained terminal runs; already-issued external effects cannot be undone.", inputSchema: idSchema, risk: "execute" }
+];
+var JevProvider = class {
+  name = "jev";
+  description = "Shell-first TypeScript orchestration with explicit typed Jev decisions";
+  manager;
+  client;
+  route;
+  /** One jev-fabric `serve` connection per program run: one client, one budget, like a Bend program. */
+  #runs = /* @__PURE__ */ new Map();
+  #transport;
+  #jevFabric;
+  #decisions;
+  #runDecisions = /* @__PURE__ */ new Map();
+  #decisionEnv;
+  #closed = false;
+  constructor(options, client) {
+    this.#jevFabric = options.jevFabric;
+    this.#decisions = new JevDecisions(options.config.jev);
+    this.#decisionEnv = decisionEnvironment(options.config.jev);
+    this.manager = new JevProgramManager({ ...options, onRunStarted: (id) => {
+      this.#runDecisions.set(`jev:${id}`, this.#decisions.fork());
+      options.onRunStarted?.(id);
+    } });
+    this.route = resolveJevModelRoute(options.config.jev.model).route;
+    this.client = client ?? new JevClient(
+      options.config.jev,
+      void 0,
+      new JevCredentials(options.config.jev.credentialCommand, process.env, options.credentialSource, this.route.envKeys),
+      this.route
+    );
+  }
+  /** UI integration: future direct calls/new programs only; never resets the session budget. */
+  setDecisionProfile(profile) {
+    this.#decisions.setProfile(profile);
+  }
+  async list(request) {
+    const query = request.query?.toLowerCase();
+    return JEV_ACTION_DESCRIPTORS.filter((d) => !query || `${d.name} ${d.description}`.toLowerCase().includes(query));
+  }
+  async describe(name) {
+    return JEV_ACTION_DESCRIPTORS.find((d) => d.name === name);
+  }
+  async invoke(name, args, context) {
+    if (this.#closed) throw new Error("Jev provider is closed");
+    const descriptor = await this.describe(name);
+    if (!descriptor) throw new Error(`Unknown Jev action: ${name}`);
+    const invalid = validationMessage(descriptor.inputSchema, args);
+    if (invalid) throw new Error(`Invalid jev.${name} arguments: ${invalid}`);
+    switch (name) {
+      case "decide":
+      case "resolveDecision":
+      case "decisionProviders":
+      case "models": {
+        const scope = context.parentToolCallId.startsWith("jev:") ? context.parentToolCallId : "$decision-session";
+        const serve = await this.#connection(scope, true);
+        const adapter = this.#runDecisions.get(scope) ?? this.#decisions;
+        if (name === "decide") return adapter.decide(serve, args, context);
+        if (name === "resolveDecision") return adapter.resolve(serve, args.request, context);
+        if (name === "models") return adapter.models(serve, context);
+        return adapter.providers(serve, context.signal);
+      }
+      case "evaluate": {
+        const dispatch = await this.#dispatchFor(context.parentToolCallId);
+        this.#transport = dispatch ? "jev-fabric" : "fabric";
+        return this.client.evaluate(args, context.signal ?? new AbortController().signal, dispatch);
+      }
+      case "run":
+        return this.manager.launch(args, context, false);
+      case "spawn":
+        return this.manager.launch(args, context, true);
+      case "status":
+        return typeof args.id === "string" ? this.manager.status(args.id, args.after) : {
+          credentials: this.client.credentials.status(),
+          model: this.client.config.model,
+          route: this.route.id,
+          runs: this.manager.list(),
+          transport: { configured: this.client.config.transport, ...this.#transport ? { last: this.#transport } : {} }
+        };
+      case "join":
+      case "wait":
+        return this.manager.wait(args.id, context.signal);
+      case "advise":
+        return this.manager.advise(args.id, args.eventId, args.message);
+      case "stop":
+        return this.manager.stop(args.id);
+    }
+  }
+  /**
+   * Program decisions go through the run's own jev-fabric connection when
+   * configured and available; direct calls stay in-process. `auto` falls back
+   * to in-process only when no suitable binary resolves, never after a request fails.
+   */
+  async #dispatchFor(scope) {
+    if (!scope?.startsWith("jev:")) return void 0;
+    const decisions = this.manager.usesDecisions(scope.slice(4));
+    if (this.client.config.transport === "fabric" && !decisions) return void 0;
+    const serve = await this.#connection(scope, decisions);
+    if (!serve) return void 0;
+    const provider = this.route.id === "vercel-ai-gateway" ? "vercel" : this.route.id;
+    return (request, credential, signal) => serve.request("jev", {
+      request,
+      provider,
+      credential,
+      timeoutMs: this.client.config.requestTimeoutMs
+    }, signal);
+  }
+  async #connection(scope, decisions) {
+    const transport = this.client.config.transport;
+    const bridge = this.#jevFabric;
+    if (!bridge) {
+      if (decisions || transport === "jev-fabric") throw new Error("Jev decisions/jev.transport jev-fabric needs jev-fabric, which runs on macOS and Linux outside managed hosts");
+      return void 0;
+    }
+    let pending = this.#runs.get(scope);
+    if (!pending) {
+      pending = (async () => {
+        let binary;
+        try {
+          binary = (await bridge.resolve(decisions ? "decisions" : "jev")).path;
+        } catch (error) {
+          if (decisions || transport === "jev-fabric") throw error;
+          return void 0;
+        }
+        const { JevFabricServe } = await import("../jev-fabric/serve.js");
+        const limits = scope.startsWith("jev:") ? this.manager.inferenceLimits(scope.slice(4)) : void 0;
+        return JevFabricServe.open(binary, {
+          home: bridge.home,
+          cwd: bridge.options.cwd,
+          timeoutMs: 864e5,
+          evaluations: limits?.evaluations ?? this.client.config.maxEvaluations,
+          tokens: limits?.tokens ?? this.client.config.maxTokens,
+          env: this.#decisionEnv
+        });
+      })();
+      this.#runs.set(scope, pending);
+    }
+    const serve = await pending;
+    if (decisions && (!serve || serve.banner.protocol < 2 || !["decisions", "decision-targets"].every((feature) => serve.banner.features?.includes(feature)))) {
+      await serve?.close();
+      throw new Error("Lossless decisions require native decisions and decision-targets features; no legacy fallback is permitted");
+    }
+    return serve;
+  }
+  async invocationEnded(parentToolCallId) {
+    this.#runDecisions.get(parentToolCallId)?.close();
+    this.#runDecisions.delete(parentToolCallId);
+    const pending = this.#runs.get(parentToolCallId);
+    if (!pending) return;
+    this.#runs.delete(parentToolCallId);
+    await (await pending.catch(() => void 0))?.close();
+  }
+  async close() {
+    this.#closed = true;
+    await this.manager.close();
+    this.client.close();
+    this.#decisions.close();
+    for (const adapter of this.#runDecisions.values()) adapter.close();
+    this.#runDecisions.clear();
+    const connections = [...this.#runs.values()];
+    this.#runs.clear();
+    await Promise.allSettled(connections.map(async (pending) => (await pending)?.close()));
+  }
+};
+
+export {
+  decisionEnvironment,
+  decisionUsage,
+  JevDecisions,
+  JevProgramManager,
+  decisionRequestSchema,
+  jevRequestSchema,
+  jevLaunchSchema,
+  jevAdviceSchema,
+  JEV_ACTION_DESCRIPTORS,
+  JevProvider
+};
+//# sourceMappingURL=chunk-3R6NIF2N.js.map