@cassiomc1/forgeloop 1.13.0 → 2.0.0-rc.2

package/src/adapters/typesafe/engine.js

@@ -0,0 +1,63 @@
+import { choice, noul } from "@typesafe-ai/sdk";
+import { createTypesafeClient, hasTypesafeCredentials } from "./client.js";
+import { normalizeTypesafeResult } from "./normalize.js";
+import { DECISION_ENGINE_ID, PINNED_JEV_MODEL } from "../../core/decision/constants.js";
+import { DECISION_ERROR_CODES, decisionError, safeDecisionError } from "../../core/decision/errors.js";
+
+function safeFailureFields(error) {
+  const diagnostics = error?.diagnostics;
+  if (!diagnostics) return {};
+  return {
+    httpStatus: diagnostics.httpStatus ?? null,
+    providerErrorType: diagnostics.providerErrorType ?? null,
+    requestId: diagnostics.requestId ?? null,
+    networkClass: diagnostics.networkClass ?? null,
+  };
+}
+
+function sdkQuestions(questionSet) {
+  return Object.fromEntries(Object.entries(questionSet.questions).map(([name, question]) => {
+    if (question.type === "choice") return [name, choice(`Answer the bounded ${name} question.`, question.criteria)];
+    return [name, noul(`Answer the bounded ${name} question.`, question.criteria)];
+  }));
+}
+
+export function createTypesafeEngine({ policy }) {
+  const engine = {
+    id: DECISION_ENGINE_ID,
+    model: PINNED_JEV_MODEL,
+    async evaluate(request) {
+      if (!hasTypesafeCredentials()) throw decisionError(DECISION_ERROR_CODES.AUTH_REQUIRED, "TYPESAFE_API_KEY is required for a semantic decision.");
+      const started = Date.now();
+      try {
+        const client = createTypesafeClient(policy);
+        const raw = await client.systemOne({ state: request.state, questions: sdkQuestions(request.questionSet), model: PINNED_JEV_MODEL }, { timeout: policy.requestTimeoutMs, retry: { maxRetries: policy.maxRetries } });
+        return { ...normalizeTypesafeResult(raw, request.questionSet), latencyMs: Date.now() - started };
+      } catch (error) {
+        throw safeDecisionError(error);
+      }
+    },
+    async health() {
+      if (!hasTypesafeCredentials()) return { status: "missing", engine: DECISION_ENGINE_ID, model: PINNED_JEV_MODEL };
+      const started = Date.now();
+      try {
+        const client = createTypesafeClient(policy);
+        const raw = await client.systemOne({ state: { healthCheck: true }, questions: { healthy: noul("Is this bounded health-check request well-formed?", { yes: "The request is well-formed", no: "The request is not well-formed" }) }, model: PINNED_JEV_MODEL }, { timeout: policy.requestTimeoutMs, retry: { maxRetries: 0 } });
+        if (raw.model !== PINNED_JEV_MODEL) throw decisionError(DECISION_ERROR_CODES.MODEL_UNSUPPORTED, "The semantic decision service returned an unsupported model.");
+        return { status: "healthy", engine: DECISION_ENGINE_ID, model: PINNED_JEV_MODEL, latencyMs: Date.now() - started, usage: raw.usage ?? null };
+      } catch (error) {
+        const normalized = safeDecisionError(error);
+        return {
+          status: normalized.code === DECISION_ERROR_CODES.RATE_LIMITED ? "rate-limited"
+            : normalized.code === DECISION_ERROR_CODES.AUTH_INVALID ? "invalid"
+              : "unreachable",
+          engine: DECISION_ENGINE_ID,
+          model: PINNED_JEV_MODEL,
+          errorCode: normalized.code,
+          ...safeFailureFields(normalized),
+        };
+      }
+    },
+  };
+  return Object.freeze(engine);
+}

package/src/adapters/typesafe/normalize.js

@@ -0,0 +1,41 @@
+import { normalizeDecisionResult } from "../../core/decision/result.js";
+import { safeDecisionError } from "../../core/decision/errors.js";
+
+function finiteProbability(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+
+function confidenceFromAnswer(answer) {
+  if (!answer || typeof answer !== "object" || Array.isArray(answer)) return null;
+  if (finiteProbability(answer.confidence)) return answer.confidence;
+  if (answer.type === "noul" && finiteProbability(answer.noul)) {
+    return Math.max(answer.noul, 1 - answer.noul);
+  }
+  return null;
+}
+
+// The live TypeSafe SystemOne result carries per-answer confidence inside each
+// answer (choice.confidence, or the noul judgment probability itself) and no
+// top-level confidence map; translate that into the canonical
+// answer-name -> confidence shape ForgeLoop's decision layer consumes. A
+// provider-reported top-level map remains authoritative per key when present.
+function deriveTypesafeConfidence(raw) {
+  const answers = raw?.answers;
+  const derived = answers && typeof answers === "object" && !Array.isArray(answers)
+    ? Object.fromEntries(Object.entries(answers).map(([name, answer]) => [name, confidenceFromAnswer(answer)]))
+    : {};
+  const provided = raw?.confidence;
+  if (!provided || typeof provided !== "object" || Array.isArray(provided)) return derived;
+  for (const [name, value] of Object.entries(provided)) {
+    if (finiteProbability(value)) derived[name] = value;
+  }
+  return derived;
+}
+
+export function normalizeTypesafeResult(raw, questionSet) {
+  try {
+    return normalizeDecisionResult({ ...raw, confidence: deriveTypesafeConfidence(raw) }, { questionSet });
+  } catch (error) {
+    throw safeDecisionError(error, "E_DECISION_RESULT_INVALID");
+  }
+}