pi-fabric 0.92.13 → 0.92.15

package/dist/chunks/chunk-OX7BU3RX.js

@@ -0,0 +1,590 @@
+import {
+  ApprovalController,
+  FabricSessionApprovals
+} from "./chunk-LUX7VAM2.js";
+import {
+  validationMessage
+} from "./chunk-PSNXUZMY.js";
+import {
+  runAbortable
+} from "./chunk-7TB7NXSL.js";
+
+// src/providers/jev-provider.ts
+import { Type } from "typebox";
+
+// src/jev/client.ts
+import { execFile } from "node:child_process";
+
+// src/jev/validation.ts
+import { Value } from "typebox/value";
+function jsonText(value, maxBytes, label) {
+  let nodes = 0;
+  const visit = (v, depth) => {
+    if (++nodes > 1e5 || depth > 32) throw new Error(`${label} exceeds JSON complexity limits`);
+    if (v === null || typeof v === "string" || typeof v === "boolean") return;
+    if (typeof v === "number" && Number.isFinite(v)) return;
+    if (Array.isArray(v)) {
+      for (const item of v) visit(item, depth + 1);
+      return;
+    }
+    if (typeof v === "object" && v !== null && Object.getPrototypeOf(v) === Object.prototype) {
+      for (const item of Object.values(v)) visit(item, depth + 1);
+      return;
+    }
+    throw new Error(`${label} must contain only finite JSON values`);
+  };
+  visit(value, 0);
+  const text = JSON.stringify(value);
+  if (Buffer.byteLength(text) > maxBytes) throw new Error(`${label} exceeds ${maxBytes} bytes`);
+  return text;
+}
+var object = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var description = (v) => typeof v === "string" || object(v) || Array.isArray(v);
+var keysOnly = (v, keys) => Object.keys(v).every((k) => keys.includes(k));
+function checkRequest(value, maxBytes) {
+  jsonText(value, maxBytes, "Jev request");
+  if (!object(value) || !keysOnly(value, ["state", "questions", "model"]) || !description(value.state) || !object(value.questions) || Object.keys(value.questions).length < 1 || Object.keys(value.questions).length > 128 || value.model !== void 0 && (typeof value.model !== "string" || !/^[a-zA-Z0-9._-]{1,128}$/.test(value.model))) {
+    throw new Error("Invalid Jev request: provide state, 1\u2013128 questions, and an optional model ID");
+  }
+  for (const [id, q] of Object.entries(value.questions)) {
+    if (!id || id.length > 128 || !object(q) || !keysOnly(q, ["type", "instructions", "criteria"]) || !description(q.instructions))
+      throw new Error("Invalid Jev question: each question needs a type and complete instructions");
+    if (q.type === "choice") {
+      if (!object(q.criteria) || Object.keys(q.criteria).length < 1 || Object.keys(q.criteria).length > 255 || !Object.entries(q.criteria).every(([key, v]) => key.length > 0 && key.length <= 256 && (v === null || description(v))))
+        throw new Error("Choice requires 1\u2013255 named options with descriptions or null");
+    } else if (q.type === "score") {
+      if (!Array.isArray(q.criteria) || q.criteria.length < 2 || q.criteria.length > 10 || !q.criteria.every(description))
+        throw new Error("Score requires 2\u201310 ordered descriptive levels");
+    } else if (q.type === "noul") {
+      if (q.criteria !== void 0 && (!object(q.criteria) || !keysOnly(q.criteria, ["true", "false"]) || !Object.values(q.criteria).every(description)))
+        throw new Error("Noul criteria may describe true and false only");
+    } else throw new Error("Jev supports choice, score, and noul\u2014not free-text generation");
+  }
+}
+var probability = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 1;
+function checkResponse(value, request) {
+  const invalid = () => {
+    throw new Error("TypeSafe returned an invalid typed response");
+  };
+  if (!object(value) || typeof value.model !== "string" || value.model.length > 128 || !object(value.answers) || !object(value.usage)) return invalid();
+  const usage = value.usage;
+  if (![usage.input_tokens, usage.output_tokens].every((v) => Number.isSafeInteger(v) && v >= 0)) return invalid();
+  if (Object.keys(value.answers).length !== Object.keys(request.questions).length) return invalid();
+  const entries = [];
+  for (const [id, question2] of Object.entries(request.questions)) {
+    const a = Object.hasOwn(value.answers, id) ? value.answers[id] : void 0;
+    if (!object(a) || a.type !== question2.type) return invalid();
+    if (question2.type === "noul") {
+      if (!probability(a.noul)) return invalid();
+      entries.push([id, { type: "noul", noul: a.noul }]);
+      continue;
+    }
+    const keys = question2.type === "choice" ? Object.keys(question2.criteria) : question2.criteria.map((_, i) => String(i));
+    const p = a.probabilities;
+    if (!probability(a.confidence) || !object(p) || Object.keys(p).length !== keys.length || !keys.every((k) => Object.hasOwn(p, k) && probability(p[k])) || Math.abs(Object.values(p).reduce((sum, v) => sum + v, 0) - 1) > 0.02) return invalid();
+    const probabilities = Object.fromEntries(keys.map((k) => [k, p[k]]));
+    if (question2.type === "choice") {
+      if (typeof a.choice !== "string" || !Object.hasOwn(question2.criteria, a.choice)) return invalid();
+      entries.push([id, { type: "choice", choice: a.choice, confidence: a.confidence, probabilities }]);
+    } else {
+      if (typeof a.score !== "number" || !Number.isFinite(a.score) || a.score < 0 || a.score > keys.length - 1) return invalid();
+      const legend = Object.fromEntries(question2.criteria.map((level, i) => [String(i), level]));
+      entries.push([id, { type: "score", score: a.score, confidence: a.confidence, probabilities, legend }]);
+    }
+  }
+  return { model: value.model, answers: Object.fromEntries(entries), usage: {
+    input_tokens: usage.input_tokens,
+    output_tokens: usage.output_tokens
+  } };
+}
+var schemaKeys = /* @__PURE__ */ new Set(["type", "properties", "required", "additionalProperties", "items", "enum", "const", "anyOf", "oneOf", "allOf", "minimum", "maximum", "minLength", "maxLength", "minItems", "maxItems", "minProperties", "maxProperties", "description", "title"]);
+function checkSchema(schema) {
+  jsonText(schema, 16384, "Program schema");
+  let nodes = 0;
+  const visit = (s, depth) => {
+    if (!object(s) || ++nodes > 128 || depth > 12 || Object.keys(s).some((k) => !schemaKeys.has(k)))
+      throw new Error("Unsupported program schema; use the documented bounded JSON Schema subset (no references or regexes)");
+    if (s.type !== void 0 && !["object", "array", "string", "number", "integer", "boolean", "null"].includes(s.type)) throw new Error("Invalid schema type");
+    if (s.properties !== void 0) {
+      if (!object(s.properties)) throw new Error("Schema properties must be an object");
+      Object.values(s.properties).forEach((v) => visit(v, depth + 1));
+    }
+    if (s.required !== void 0 && (!Array.isArray(s.required) || !s.required.every((v) => typeof v === "string"))) throw new Error("Schema required must be a string array");
+    if (s.additionalProperties !== void 0 && typeof s.additionalProperties !== "boolean") visit(s.additionalProperties, depth + 1);
+    if (s.items !== void 0) visit(s.items, depth + 1);
+    for (const k of ["anyOf", "oneOf", "allOf"]) if (s[k] !== void 0) {
+      if (!Array.isArray(s[k]) || s[k].length < 1 || s[k].length > 16) throw new Error("Invalid schema alternatives");
+      s[k].forEach((v) => visit(v, depth + 1));
+    }
+    for (const k of ["minimum", "maximum", "minLength", "maxLength", "minItems", "maxItems", "minProperties", "maxProperties"])
+      if (s[k] !== void 0 && (typeof s[k] !== "number" || !Number.isFinite(s[k]) || !["minimum", "maximum"].includes(k) && (!Number.isSafeInteger(s[k]) || s[k] < 0))) throw new Error("Invalid schema bound");
+    if (s.enum !== void 0 && (!Array.isArray(s.enum) || s.enum.length === 0 || s.enum.length > 256)) throw new Error("Invalid schema enum");
+  };
+  visit(schema, 0);
+}
+function checkValue(schema, value, label) {
+  jsonText(value, 32768, label);
+  if (!Value.Check(schema, value)) throw new Error(`${label} does not match its declared schema`);
+}
+
+// src/jev/client.ts
+var JevCredentials = class {
+  constructor(command, env = process.env, providerAuth) {
+    this.command = command;
+    this.env = env;
+    this.providerAuth = providerAuth;
+  }
+  #cached;
+  status() {
+    const source = this.providerAuth?.configured() ? "pi" : this.env.TYPESAFE_API_KEY?.trim() ? "environment" : this.command.length ? "command" : "missing";
+    return { configured: source !== "missing", source, verified: false };
+  }
+  async resolve(signal) {
+    signal.throwIfAborted();
+    if (this.providerAuth) {
+      try {
+        const key = await this.providerAuth.resolve(signal);
+        signal.throwIfAborted();
+        if (key?.trim()) return key.trim();
+      } catch {
+        throw new Error("Jev Pi credential resolution failed");
+      }
+    }
+    const env = this.env.TYPESAFE_API_KEY?.trim();
+    if (env) return env;
+    if (this.#cached) return this.#cached;
+    const [file, ...args] = this.command;
+    if (!file) throw new Error("Jev credentials unavailable: set TYPESAFE_API_KEY or configure jev.credentialCommand");
+    const secret = await new Promise((resolve, reject) => {
+      execFile(file, args, { encoding: "utf8", timeout: 5e3, maxBuffer: 16384, signal, windowsHide: true }, (error, stdout) => {
+        if (error) reject(new Error("Jev credential resolver failed"));
+        else resolve(stdout.trim());
+      });
+    });
+    signal.throwIfAborted();
+    if (!secret || /[\r\n]/.test(secret)) throw new Error("Jev credential resolver returned an invalid credential");
+    this.#cached = secret;
+    return secret;
+  }
+  clear() {
+    this.#cached = void 0;
+  }
+};
+var JevClient = class {
+  constructor(config, fetcher = fetch, credentials) {
+    this.config = config;
+    this.fetcher = fetcher;
+    this.credentials = credentials ?? new JevCredentials(config.credentialCommand);
+  }
+  credentials;
+  async evaluate(request, signal) {
+    checkRequest(request, this.config.maxRequestBytes);
+    const timedSignal = AbortSignal.any([signal, AbortSignal.timeout(this.config.requestTimeoutMs)]);
+    const key = await runAbortable(timedSignal, () => this.credentials.resolve(timedSignal));
+    const body = jsonText({ ...request, model: request.model ?? this.config.model }, this.config.maxRequestBytes, "Jev request");
+    let response;
+    try {
+      response = await runAbortable(timedSignal, () => this.fetcher("https://api.typesafe.ai/v1/systemone", {
+        method: "POST",
+        redirect: "error",
+        signal: timedSignal,
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${key}` },
+        body
+      }));
+    } catch {
+      throw new Error(timedSignal.aborted ? "Jev request cancelled or timed out" : "Jev network request failed");
+    }
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new Error(`TypeSafe HTTP ${response.status}${[429, 529].includes(response.status) ? ": rate limited; back off before retrying" : ""}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("TypeSafe returned an empty response");
+    const chunks = [];
+    let bytes = 0;
+    try {
+      for (; ; ) {
+        const { value, done } = await runAbortable(timedSignal, () => reader.read());
+        if (done) break;
+        bytes += value.byteLength;
+        if (bytes > 1048576) throw new Error("oversize");
+        chunks.push(value);
+      }
+      return checkResponse(JSON.parse(Buffer.concat(chunks).toString("utf8")), request);
+    } catch {
+      throw new Error(timedSignal.aborted ? "Jev response cancelled or timed out" : "TypeSafe returned an invalid or oversized typed response");
+    } finally {
+      await reader.cancel().catch(() => void 0);
+    }
+  }
+  close() {
+    this.credentials.clear();
+  }
+};
+
+// src/jev/manager.ts
+import { randomUUID } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+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 } }),
+});
+`;
+var JevProgramManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  #runs = /* @__PURE__ */ new Map();
+  #approvals = new FabricSessionApprovals();
+  #closed = false;
+  #starting = 0;
+  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
+    }));
+  }
+  #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);
+  }
+  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 } = structuredClone(request);
+      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.") && ref !== "jev.evaluate")
+          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)}`);
+      if (this.#closed) throw new Error("Jev program manager is closed");
+      context.signal?.throwIfAborted();
+      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 approval = new ApprovalController(config.approvals, context.extensionContext, this.#approvals);
+      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;
+      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, done: void 0 };
+      this.#runs.set(id, run);
+      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 (!Object.hasOwn(runLease.view.bindings, ref)) throw new Error(`Capability not granted to Jev program: ${ref}`);
+            if (ref === "jev.evaluate") {
+              if (evaluating) throw new Error("One Jev evaluation may be in flight per program; batch independent questions in one request");
+              if (info.evaluations >= maxEvaluations || info.usage.input_tokens + info.usage.output_tokens >= maxTokens)
+                return failBudget("Jev inference budget exhausted");
+              info.evaluations++;
+              evaluating = true;
+            }
+            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.evaluate" ? 1048576 : config.executor.maxNestedResultChars
+              });
+              if (ref === "jev.evaluate") {
+                const response = value;
+                info.usage.input_tokens += response.usage.input_tokens;
+                info.usage.output_tokens += response.usage.output_tokens;
+                if (info.usage.input_tokens + info.usage.output_tokens > maxTokens)
+                  return failBudget("Jev reported-token budget exhausted");
+              }
+              return value;
+            } finally {
+              if (ref === "jev.evaluate") 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) },
+            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);
+          context.signal?.removeEventListener("abort", abort);
+          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/providers/jev-provider.ts
+var description2 = Type.Union([Type.String(), Type.Array(Type.Unknown()), Type.Record(Type.String(), Type.Unknown())]);
+var question = Type.Union([
+  Type.Object({ type: Type.Literal("noul"), instructions: description2, criteria: Type.Optional(Type.Object({ true: Type.Optional(description2), false: Type.Optional(description2) }, { additionalProperties: false })) }, { additionalProperties: false }),
+  Type.Object({ type: Type.Literal("choice"), instructions: description2, criteria: Type.Record(Type.String(), Type.Union([description2, Type.Null()]), { minProperties: 1, maxProperties: 255 }) }, { additionalProperties: false }),
+  Type.Object({ type: Type.Literal("score"), instructions: description2, criteria: Type.Array(description2, { minItems: 2, maxItems: 10 }) }, { additionalProperties: false })
+]);
+var jevRequestSchema = Type.Object({
+  state: description2,
+  questions: Type.Record(Type.String(), question, { minProperties: 1, maxProperties: 128 }),
+  model: Type.Optional(Type.String({ minLength: 1, maxLength: 128 }))
+}, { additionalProperties: false });
+var jevLaunchSchema = Type.Object({
+  program: Type.Object({
+    name: Type.String({ minLength: 1, maxLength: 128 }),
+    code: Type.String({ minLength: 1, maxLength: 65536 }),
+    inputSchema: Type.Record(Type.String(), Type.Unknown()),
+    outputSchema: Type.Record(Type.String(), Type.Unknown()),
+    requires: Type.Array(Type.String({ minLength: 3, maxLength: 256 }), { maxItems: 64, uniqueItems: true }),
+    limits: Type.Optional(Type.Object({
+      timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
+      maxEvaluations: Type.Optional(Type.Integer({ minimum: 1 })),
+      maxToolCalls: Type.Optional(Type.Integer({ minimum: 1 })),
+      maxTokens: Type.Optional(Type.Integer({ minimum: 1 }))
+    }, { additionalProperties: false }))
+  }, { additionalProperties: false }),
+  input: Type.Unknown()
+}, { additionalProperties: false });
+var idSchema = Type.Object({ id: Type.String({ minLength: 1, maxLength: 128 }) }, { additionalProperties: false });
+var statusSchema = Type.Object({
+  id: Type.Optional(Type.String({ minLength: 1, maxLength: 128 })),
+  after: Type.Optional(Type.Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+var JEV_ACTION_DESCRIPTORS = [
+  { 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 an isolated TypeScript System One 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. Loops are supported; no host imports or secrets.", inputSchema: jevLaunchSchema, risk: "execute" },
+  { name: "spawn", description: "Launch the same Jev program in the background and return its run ID. Session-owned, not restart-durable. Poll status for bounded events or join for completion; stop cancels future actions, not past effects.", 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: "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 = "TypeSafe System One judgments and foreground/background reactive TypeScript programs";
+  manager;
+  client;
+  constructor(options, client) {
+    this.manager = new JevProgramManager(options);
+    this.client = client ?? new JevClient(options.config.jev, void 0, new JevCredentials(options.config.jev.credentialCommand, process.env, options.credentialSource));
+  }
+  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) {
+    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 "evaluate":
+        return this.client.evaluate(args, context.signal ?? new AbortController().signal);
+      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,
+          runs: this.manager.list()
+        };
+      case "join":
+      case "wait":
+        return this.manager.wait(args.id, context.signal);
+      case "stop":
+        return this.manager.stop(args.id);
+    }
+  }
+  async close() {
+    await this.manager.close();
+    this.client.close();
+  }
+};
+
+export {
+  JevCredentials,
+  JevClient,
+  JevProgramManager,
+  jevRequestSchema,
+  jevLaunchSchema,
+  JEV_ACTION_DESCRIPTORS,
+  JevProvider
+};
+//# sourceMappingURL=chunk-OX7BU3RX.js.map