Jev 不再生成文本：用类型化概率直接驱动业务决策

{
  "category": "billing",
  "confidence": 0.91
}

输入事件
  └─ 决策模型
       ├─ decision: "review"
       ├─ probabilities: { approve: 0.12, reject: 0.21, review: 0.67 }
       └─ confidence: 0.74

margin = top_probability - second_probability

confidence >= 0.80 且 margin >= 0.15  -> 自动处理
否则                                      -> 人工复核

mkdir jev-decision-demo
cd jev-decision-demo
npm init -y
npm install --save-dev typescript tsx

type Route = "sales" | "support" | "billing";

type Decision<T extends string> = {
  decision: T;
  probabilities: Record<T, number>;
  confidence: number;
};

const routes = ["sales", "support", "billing"] as const;

function validateDecision(value: unknown): Decision<Route> {
  if (!value || typeof value !== "object") {
    throw new Error("Decision response must be an object");
  }

  const result = value as Partial<Decision<Route>>;

  if (!routes.includes(result.decision as Route)) {
    throw new Error(`Unexpected decision: ${String(result.decision)}`);
  }

  if (
    typeof result.confidence !== "number" ||
    result.confidence < 0 ||
    result.confidence > 1
  ) {
    throw new Error("Confidence must be between 0 and 1");
  }

  if (!result.probabilities) {
    throw new Error("Missing probabilities");
  }

  for (const route of routes) {
    const probability = result.probabilities[route];
    if (typeof probability !== "number" || probability < 0 || probability > 1) {
      throw new Error(`Invalid probability for ${route}`);
    }
  }

  return result as Decision<Route>;
}

function marginOf(probabilities: Record<Route, number>): number {
  const sorted = Object.values(probabilities).sort((a, b) => b - a);
  return sorted[0] - sorted[1];
}

async function classifyTicket(message: string): Promise<Decision<Route>> {
  const endpoint = process.env.JEV_ENDPOINT;
  const apiKey = process.env.JEV_API_KEY;

  if (!endpoint || !apiKey) {
    throw new Error("Set JEV_ENDPOINT and JEV_API_KEY before running");
  }

  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      authorization: `Bearer ${apiKey}`,
    },
    body: JSON.stringify({
      input: message,
      output: {
        type: "enum",
        values: routes,
      },
    }),
  });

  if (!response.ok) {
    throw new Error(`Decision API failed: ${response.status}`);
  }

  return validateDecision(await response.json());
}

const result = await classifyTicket(
  "I was charged twice for the same subscription."
);
const margin = marginOf(result.probabilities);

if (result.confidence >= 0.8 && margin >= 0.15) {
  console.log(`Auto-route to: ${result.decision}`, result);
} else {
  console.log("Send to manual triage", { ...result, margin });
}

export JEV_ENDPOINT="https://your-decision-endpoint.example/v1/decide"
export JEV_API_KEY="replace-with-your-key"
npx tsx decision.ts

async function mapWithConcurrency<T, R>(
  items: T[],
  concurrency: number,
  worker: (item: T) => Promise<R>
): Promise<PromiseSettledResult<R>[]> {
  const results: PromiseSettledResult<R>[] = new Array(items.length);
  let nextIndex = 0;

  async function run(): Promise<void> {
    while (true) {
      const index = nextIndex++;
      if (index >= items.length) return;

      try {
        results[index] = {
          status: "fulfilled",
          value: await worker(items[index]),
        };
      } catch (reason) {
        results[index] = { status: "rejected", reason };
      }
    }
  }

  await Promise.all(
    Array.from(
      { length: Math.min(concurrency, items.length) },
      () => run()
    )
  );

  return results;
}