@demlik/tea 0.15.0 → 0.17.0

package/dist/jev/index.js

@@ -1,16 +1,16 @@
-import { createBatchWindow, subscribeBatchWindow } from '../chunk-QPEVCJ5Q.js';
+import { createBatchWindow } from '../chunk-DFUEAA6L.js';
 import '../chunk-LFZUK6J2.js';
-import { createFanOut } from '../chunk-MYXFNWAJ.js';
+import { describeError } from '../chunk-G5E74IJB.js';
+import { createFanOut } from '../chunk-QNGYQMZB.js';
 import '../chunk-TXN2KFHF.js';
-import { runCmdDef, createResilientCall, MsgType } from '../chunk-AYS5N6WY.js';
-export { mountResilientCall } from '../chunk-AYS5N6WY.js';
+import { runCmdDef, createResilientCall } from '../chunk-6XBEYZME.js';
 import '../chunk-VBDU4JL6.js';
-import { initCache, has, set, evictExpired, cacheEvictionSub, cacheEvictionSubscribe, get } from '../chunk-22POWGFA.js';
-export { deadlineSub, subscribeDeadline } from '../chunk-22POWGFA.js';
-import { describeError } from '../chunk-G5E74IJB.js';
-import { liftSlice, readInOrder } from '../chunk-66PY5WYF.js';
-import { z } from 'zod';
+import '../chunk-4LPY67E4.js';
+import { initCache, has, set, evictExpired, cacheEvictionSub, cacheEvictionSubscribe, get } from '../chunk-GWWCCSDH.js';
+import { liftSlice, readInOrder } from '../chunk-C4U5D5HP.js';
+import { Outcome } from '../chunk-K4ETBNKS.js';
 
+// src/internal/jev/protocol/index.ts
 var jevQuestions = (questions) => questions;
 var JEV_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
 var JEV_ERR_TAG_WITNESS = {
@@ -36,48 +36,99 @@ var err = (error) => ({
   ok: false,
   error
 });
-var finite = z.number().finite();
-var answerSchema = (question) => {
+var pass = (value) => ({ ok: true, value });
+var fail = (path) => ({
+  ok: false,
+  issue: { path }
+});
+var isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+var object = (value, path, fields) => {
+  if (!isObj(value)) return fail(path);
+  const out = {};
+  for (const [key, check] of fields) {
+    const step = check(value[key], [...path, key]);
+    if (!step.ok) return step;
+    out[key] = step.value;
+  }
+  return pass(out);
+};
+var record = (isValue) => (value, path) => {
+  if (!isObj(value)) return fail(path);
+  for (const [key, v] of Object.entries(value)) {
+    if (!isValue(v)) return fail([...path, key]);
+  }
+  return pass({ ...value });
+};
+var literal = (expected) => (value, path) => value === expected ? pass(expected) : fail(path);
+var finite = (value, path) => isFiniteNumber(value) ? pass(value) : fail(path);
+var string = (value, path) => typeof value === "string" ? pass(value) : fail(path);
+var exactProbabilities = (options) => (value, path) => {
+  const named = object(
+    value,
+    path,
+    options.map((k) => [k, finite])
+  );
+  if (!named.ok || !isObj(value)) return named;
+  return Object.keys(value).every((k) => options.includes(k)) ? named : fail(path);
+};
+var checkAnswer = (question, value, path) => {
   switch (question.type) {
     case "noul":
-      return z.object({ type: z.literal("noul"), noul: finite });
+      return object(value, path, [
+        ["type", literal("noul")],
+        ["noul", finite]
+      ]);
     case "score":
-      return z.object({
-        type: z.literal("score"),
-        confidence: finite,
-        score: finite,
-        legend: z.record(z.string(), z.string()),
-        probabilities: z.record(z.string(), finite)
-      });
+      return object(value, path, [
+        ["type", literal("score")],
+        ["confidence", finite],
+        ["score", finite],
+        ["legend", record((v) => typeof v === "string")],
+        ["probabilities", record(isFiniteNumber)]
+      ]);
     case "choice": {
       const options = Object.keys(question.criteria);
-      return z.object({
-        type: z.literal("choice"),
-        choice: z.enum(options),
-        confidence: finite,
-        // `JevChoiceAnswer<K>` types `probabilities` as TOTAL over the criteria
-        // keys. A strict object whose shape is those keys IS that claim: a
-        // missing key fails the shape, an extra one is unrecognized.
-        probabilities: z.strictObject(
-          Object.fromEntries(options.map((k) => [k, finite]))
-        )
-      });
+      return object(value, path, [
+        ["type", literal("choice")],
+        [
+          "choice",
+          (v, p) => typeof v === "string" && options.includes(v) ? pass(v) : fail(p)
+        ],
+        ["confidence", finite],
+        ["probabilities", exactProbabilities(options)]
+      ]);
     }
   }
 };
-var jevAnswersSchema = (questions) => z.object(
-  Object.fromEntries(
-    Object.entries(questions).map(([id, question]) => [
-      id,
-      answerSchema(question)
-    ])
-  )
-);
-var responseSchema = (questions) => z.object({
-  model: z.string(),
-  usage: z.object({ input_tokens: finite, output_tokens: finite }),
-  answers: jevAnswersSchema(questions)
-});
+var checkResponse = (questions, body) => {
+  const envelope = object(
+    body,
+    [],
+    [
+      ["model", string],
+      [
+        "usage",
+        (v, p) => object(v, p, [
+          ["input_tokens", finite],
+          ["output_tokens", finite]
+        ])
+      ],
+      [
+        "answers",
+        (v, p) => object(
+          v,
+          p,
+          Object.entries(questions).map(
+            ([id, question]) => [id, (a, ap) => checkAnswer(question, a, ap)]
+          )
+        )
+      ]
+    ]
+  );
+  if (!envelope.ok) return envelope;
+  const { model, usage, answers } = envelope.value;
+  return pass({ model, usage, answers });
+};
 var ANSWER_FIELD_REASON = {
   confidence: "`confidence` is not a number",
   score: "`score` is not a number",
@@ -87,7 +138,7 @@ var ANSWER_FIELD_REASON = {
   noul: "`noul` is not a number"
 };
 var toJevErr = (questions, body, issue) => {
-  const [head, id, field] = issue?.path ?? [];
+  const [head, id, field] = issue.path;
   if (head === "model") {
     return { _tag: "malformed_body", reason: "`model` is not a string" };
   }
@@ -124,7 +175,7 @@ var toJevErr = (questions, body, issue) => {
     }
     if (field === "probabilities") {
       const probabilities = at(answer, "probabilities");
-      const key = issue?.path[3];
+      const key = issue.path[3];
       const badValue = isObj(probabilities) && typeof key === "string" && Object.hasOwn(probabilities, key);
       if (isObj(probabilities) && !badValue) {
         return {
@@ -141,15 +192,13 @@ var toJevErr = (questions, body, issue) => {
   return {
     _tag: "malformed_answer",
     id,
-    reason: named ?? issue?.message ?? "answer is malformed"
+    reason: named ?? "answer is malformed"
   };
 };
 var parseAnswers = (questions, body) => {
-  const parsed = responseSchema(questions).safeParse(body);
-  if (!parsed.success) {
-    return err(toJevErr(questions, body, parsed.error.issues[0]));
-  }
-  const { answers, model, usage } = parsed.data;
+  const parsed = checkResponse(questions, body);
+  if (!parsed.ok) return err(toJevErr(questions, body, parsed.issue));
+  const { answers, model, usage } = parsed.value;
   return { ok: true, answers, model, usage };
 };
 var classifyStatus = (status) => {
@@ -162,20 +211,53 @@ var classifyStatus = (status) => {
 function isTransientJevAskErr(error) {
   return error._tag === "http_retry" || error._tag === "port_threw";
 }
-var JevAskFailure = class extends Error {
-  constructor(jev) {
-    super(`jev ask: ${jev._tag}`);
-    this.jev = jev;
-    this.name = "JevAskFailure";
+function reject(jev) {
+  return Outcome.err({ _tag: "port_rejected", jev });
+}
+function jevAskErrOf(error) {
+  if (typeof error === "object" && error !== null) {
+    const jev = error.jev;
+    if (typeof jev === "object" && jev !== null && typeof jev._tag === "string") {
+      return jev;
+    }
   }
-  jev;
-};
-function toAskErr(error) {
-  if (error instanceof JevAskFailure) return error.jev;
   return { _tag: "port_threw", reason: describeError(error) };
 }
 var DEFAULT_JEV_MODEL = "jev-latest";
 var NO_USAGE = { input_tokens: 0, output_tokens: 0 };
+function isErrDecision(decided) {
+  return isJevErr(decided);
+}
+function decodeJevReply(request, reply) {
+  const kind = classifyStatus(reply.status);
+  if (kind === "retry")
+    return reject({ _tag: "http_retry", status: reply.status });
+  if (kind === "terminal") {
+    return reject({ _tag: "http_terminal", status: reply.status });
+  }
+  const parsed = parseAnswers(request.questions, reply.body);
+  if (!parsed.ok) return reject(parsed.error);
+  return Outcome.ok({
+    answers: parsed.answers,
+    model: parsed.model,
+    usage: parsed.usage,
+    source: "port"
+  });
+}
+function jevCallThrew(cause) {
+  return reject({ _tag: "port_threw", reason: describeError(cause) });
+}
+function offlineJevAnswer(request, fallback) {
+  if (fallback === void 0) return reject({ _tag: "no_answer_path" });
+  const decided = fallback(request);
+  if (isErrDecision(decided)) return reject(decided);
+  return Outcome.ok({
+    answers: decided,
+    model: request.model,
+    usage: NO_USAGE,
+    source: "fallback"
+  });
+}
 function jevAskCmdDef() {
   return runCmdDef();
 }
@@ -185,9 +267,6 @@ function createJevAsk(config, rng = Math.random) {
   };
   const rc = createResilientCall(resilientConfig, rng);
   const model = config.model ?? DEFAULT_JEV_MODEL;
-  function isErrDecision(decided) {
-    return isJevErr(decided);
-  }
   function liveRequest(s, key) {
     const call = s.calls[key];
     if (call?.phase === "running" || call?.phase === "waiting_retry") {
@@ -206,98 +285,59 @@ function createJevAsk(config, rng = Math.random) {
     };
     return rc.attempt(s, key, request, at2);
   }
-  function succeed(s, key, msg) {
-    return rc.succeed(s, key, msg);
+  function succeed(s, msg) {
+    const { call, cmds } = rc.settle(s, msg);
+    return [call, cmds];
   }
   function settleFromFallback(s, key, request, fallback, at2) {
-    const decided = fallback(request);
-    if (isErrDecision(decided)) return rc.settleFailed(s, key, decided);
-    return rc.succeed(s, key, {
-      type: MsgType.ResilientOk,
-      key,
-      result: {
-        answers: decided,
-        model: request.model,
-        usage: NO_USAGE,
-        source: "fallback"
-      },
+    const decided = offlineJevAnswer(request, fallback);
+    if (decided._tag === "Err") {
+      return rc.settleFailed(s, key, decided.error.jev, at2);
+    }
+    const { call, cmds } = rc.settle(s, {
+      cmd: { key },
+      value: decided.value,
       at: at2
     });
+    return [call, cmds];
   }
-  function fail(s, key, msg) {
-    if (!isTransientJevAskErr(msg.error)) {
-      return rc.settleFailed(s, key, msg.error);
+  function fail2(s, msg) {
+    const { key } = msg.cmd;
+    const error = jevAskErrOf(msg.error);
+    if (!isTransientJevAskErr(error)) {
+      return rc.settleFailed(s, key, error, msg.at);
     }
     const request = liveRequest(s, key);
-    const settled = rc.fail(s, key, msg);
-    const backedOff = settled[0].calls[key]?.phase !== "failed";
-    if (backedOff || config.fallback === void 0 || request === void 0) {
-      return settled;
+    const { call, cmds, outcome } = rc.settle(s, { ...msg, error });
+    if (outcome.kind !== "failed" || config.fallback === void 0 || request === void 0) {
+      return [call, cmds];
     }
     return settleFromFallback(s, key, request, config.fallback, msg.at);
   }
   function onTimer(s, msg) {
     return rc.onTimer(s, msg);
   }
-  function subs(s) {
-    return rc.subs(s);
-  }
-  async function ask(request, signal) {
-    if (config.port === void 0) {
-      if (config.fallback === void 0) {
-        throw new JevAskFailure({ _tag: "no_answer_path" });
-      }
-      const decided = config.fallback(request);
-      if (isErrDecision(decided)) throw new JevAskFailure(decided);
-      return {
-        answers: decided,
-        model: request.model,
-        usage: NO_USAGE,
-        source: "fallback"
-      };
-    }
-    const { status, body } = await config.port(request, signal);
-    const kind = classifyStatus(status);
-    if (kind === "retry")
-      throw new JevAskFailure({ _tag: "http_retry", status });
-    if (kind === "terminal") {
-      throw new JevAskFailure({ _tag: "http_terminal", status });
-    }
-    const parsed = parseAnswers(config.questions, body);
-    if (!parsed.ok) throw new JevAskFailure(parsed.error);
-    return {
-      answers: parsed.answers,
-      model: parsed.model,
-      usage: parsed.usage,
-      source: "port"
-    };
-  }
-  const resilientRunHandler = rc.handlers({
-    run: (request) => ask(request)
-  }).resilient_run;
-  async function settleOf(cmd) {
-    const settle = await resilientRunHandler(cmd, {});
-    if (settle.type === MsgType.ResilientOk) return settle;
-    return {
-      type: MsgType.ResilientErr,
-      key: settle.key,
-      error: toAskErr(settle.error),
-      at: settle.at
-    };
-  }
-  function handlers() {
-    return { resilient_run: (cmd) => settleOf(cmd) };
+  function deadlines(s) {
+    return rc.deadlines(s);
   }
   return {
     name: rc.name,
+    /** The `Cmd.define`d run Cmd — list it in the machine's `cmds`. */
+    run: rc.run,
     init,
     attempt,
     succeed,
-    fail,
+    fail: fail2,
     onTimer,
-    subs,
-    handlers,
-    ask
+    deadlines,
+    /** The built-in `timer` Sub's deps — resilient-call's `timer`. */
+    timer: rc.timer,
+    /** Your handler's outcome for an HTTP reply — {@link decodeJevReply}. */
+    decode: (request, reply) => decodeJevReply(request, reply),
+    /** Your handler's outcome when the call threw — {@link jevCallThrew}. */
+    rejected: jevCallThrew,
+    /** Your handler's outcome with no network — {@link offlineJevAnswer}. */
+    offline: (request) => offlineJevAnswer(request, config.fallback)
   };
 }
 function liftJevAsk(state, result) {
@@ -395,27 +435,28 @@ function createClassifyBatch(config) {
   }
   function onBatchOk(state, msg) {
     let cache = state.cache;
-    for (const [key, answer] of Object.entries(msg.result.answers)) {
+    for (const [key, answer] of Object.entries(msg.value.answers)) {
       cache = set(cache, key, answer, msg.at, config.ttlMs);
     }
     const failed = { ...state.failed };
-    for (const key of Object.keys(msg.result.answers)) delete failed[key];
+    for (const key of Object.keys(msg.value.answers)) delete failed[key];
     return liftSlice(
       "fanOut",
       { ...state, cache, failed },
-      fanOut.itemOk(state.fanOut, msg.key, msg.result)
+      fanOut.itemOk(state.fanOut, msg.cmd.key, msg.value)
     );
   }
   function onBatchErr(state, msg) {
-    const batch = runningBatch(state, msg.key);
+    const batch = runningBatch(state, msg.cmd.key);
+    const error = jevAskErrOf(msg.error);
     const failed = { ...state.failed };
     if (batch !== void 0) {
-      for (const item of batch.items) failed[config.keyOf(item)] = msg.error;
+      for (const item of batch.items) failed[config.keyOf(item)] = error;
     }
     return liftSlice(
       "fanOut",
       { ...state, failed },
-      fanOut.itemErr(state.fanOut, msg.key, msg.error)
+      fanOut.itemErr(state.fanOut, msg.cmd.key, error)
     );
   }
   function onEvict(state, at2) {
@@ -445,28 +486,22 @@ function createClassifyBatch(config) {
     return readInOrder({ state, key, at: at2 }, ANSWER_ORDER, { status: "absent" });
   }
   function subs(state, id = "jev-classify-batch") {
-    const windowSubs = window.subs(state.window, id);
-    if (config.evictEveryMs === void 0) return windowSubs;
-    return [...windowSubs, cacheEvictionSub(id, config.evictEveryMs)];
-  }
-  function subscribers() {
-    return { deadline: subscribeBatchWindow, cache: cacheEvictionSubscribe };
+    return window.subs(state.window, id);
   }
-  function handlers() {
-    return {
-      resilient_run: (cmd) => {
-        const request = cmd.input;
-        const ask = createJevAsk({
-          questions: request.questions,
-          ...config.port === void 0 ? {} : { port: config.port },
-          ...config.fallback === void 0 ? {} : { fallback: config.fallback },
-          ...config.model === void 0 ? {} : { model: config.model }
-        });
-        return ask.handlers().resilient_run(cmd);
-      }
+  function subEntries(select, id = "jev-classify-batch") {
+    const flush = {
+      type: "timer",
+      deps: (model) => window.timer(select(model).window, id)
     };
+    if (config.evictEveryMs === void 0) return [flush];
+    return [flush, cacheEvictionSub(id, config.evictEveryMs)];
+  }
+  function subscribers() {
+    return { cache: cacheEvictionSubscribe };
   }
   return {
+    /** The ask Cmd def — list it in the machine's `cmds`. */
+    ask: askCmd,
     init,
     add,
     onWindow,
@@ -475,11 +510,20 @@ function createClassifyBatch(config) {
     onEvict,
     answerFor,
     subs,
+    subEntries,
     subscribers,
-    handlers
+    /**
+     * Your handler's outcome for Jev's reply to one batch — `../ask`'s
+     * `decodeJevReply`, parsing against the questions the batch carried.
+     */
+    decode: (request, reply) => decodeJevReply(request, reply),
+    /** Your handler's outcome when the call threw — `../ask`'s `jevCallThrew`. */
+    rejected: jevCallThrew,
+    /** Your handler's outcome with no network — the configured `fallback`. */
+    offline: (request) => offlineJevAnswer(request, config.fallback)
   };
 }
 
-export { DEFAULT_CLASSIFY_MAX_ITEMS, DEFAULT_JEV_MODEL, JEV_ENDPOINT, JevAskFailure, classifyStatus, createClassifyBatch, createJevAsk, isJevErr, isTransientJevAskErr, jevAskCmdDef, jevQuestions, liftJevAsk, parseAnswers };
+export { DEFAULT_CLASSIFY_MAX_ITEMS, DEFAULT_JEV_MODEL, JEV_ENDPOINT, classifyStatus, createClassifyBatch, createJevAsk, decodeJevReply, isJevErr, isTransientJevAskErr, jevAskCmdDef, jevAskErrOf, jevCallThrew, jevQuestions, liftJevAsk, offlineJevAnswer, parseAnswers };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map