nexus-ai-pro 2.18.0 → 2.20.2

package/dist/decisions/completion.js

@@ -0,0 +1,195 @@
+import { DecisionError, } from './core.js';
+const LOGPROB_OPTIONS = 20;
+export function completionDecisions(client, options) {
+    const method = options.method ?? 'auto';
+    const sampled = new Set();
+    const info = {
+        name: options.name ?? options.model,
+        capabilities: {
+            types: ['yes-no', 'choice', 'score'],
+            maxOptions: 255,
+            maxLevels: 10,
+            defaultModel: options.model,
+        },
+        chargedByItsCalls: true,
+    };
+    const ask = async (model, state, question, context, usage) => {
+        const codes = codesOf(question);
+        const prompt = promptOf(state, question, codes, options.instructions);
+        const request = (extra) => ({
+            model,
+            messages: [
+                {
+                    role: 'system',
+                    content: 'You answer one question about a state with exactly one of the codes given, and nothing else.',
+                },
+                { role: 'user', content: prompt },
+            ],
+            signal: context.signal,
+            ...(context.tenantId !== undefined ? { tenantId: context.tenantId } : {}),
+            ...extra,
+        });
+        const readable = codes.length <= LOGPROB_OPTIONS && codes.every((code) => code.length === 1);
+        if (method !== 'sampling' && readable && !sampled.has(model)) {
+            let response;
+            try {
+                response = await client.complete(request({ temperature: 0, maxTokens: 2, logprobs: { top: 20 } }));
+            }
+            catch (error) {
+                if (method === 'logprobs' || !refusedOption(error))
+                    throw error;
+            }
+            if (response) {
+                usage.add(response);
+                const weights = weightsFrom(response.logprobs, codes);
+                if (weights)
+                    return distributionOf(question, codes, weights);
+                if (method === 'logprobs') {
+                    throw new DecisionError(`"${model}" reported no log probabilities for the codes it was given`, 'DECISION_FAILED');
+                }
+            }
+            sampled.add(model);
+        }
+        if (!readable && method === 'logprobs') {
+            throw new DecisionError(`A question of ${codes.length} options cannot be read from one token's ${LOGPROB_OPTIONS} alternatives`, 'DECISION_UNSUPPORTED');
+        }
+        const count = Math.max(1, Math.floor(options.samples ?? 8));
+        const answers = await Promise.all(Array.from({ length: count }, () => client.complete(request({ temperature: options.temperature ?? 1, maxTokens: 4 })).then((response) => {
+            usage.add(response);
+            return codeIn(response.content, codes);
+        })));
+        const weights = codes.map((code) => answers.filter((answer) => answer === code).length);
+        if (weights.every((weight) => weight === 0)) {
+            throw new DecisionError(`"${model}" answered none of ${count} samples with a code it was given`, 'DECISION_FAILED');
+        }
+        return distributionOf(question, codes, weights);
+    };
+    return {
+        info,
+        sampledModels: sampled,
+        async decide(request, context) {
+            const totals = new Totals();
+            const entries = Object.entries(request.questions);
+            const distributions = {};
+            const limit = Math.max(1, Math.floor(options.concurrency ?? 8));
+            let next = 0;
+            const worker = async () => {
+                while (next < entries.length) {
+                    const [name, question] = entries[next++];
+                    distributions[name] = await ask(request.model, request.state, question, context, totals);
+                }
+            };
+            await Promise.all(Array.from({ length: Math.min(limit, entries.length) }, worker));
+            return {
+                model: request.model,
+                distributions,
+                usage: totals.usage(),
+                ...(totals.cost() ? { cost: totals.cost() } : {}),
+            };
+        },
+    };
+}
+class Totals {
+    inputTokens = 0;
+    outputTokens = 0;
+    calls = 0;
+    amount = 0;
+    priced = false;
+    add(response) {
+        this.calls += 1;
+        this.inputTokens += response.meta.usage?.inputTokens ?? 0;
+        this.outputTokens += response.meta.usage?.outputTokens ?? 0;
+        if (response.meta.cost) {
+            this.amount += response.meta.cost.amount;
+            this.priced = true;
+        }
+    }
+    usage() {
+        return { inputTokens: this.inputTokens, outputTokens: this.outputTokens, calls: this.calls };
+    }
+    cost() {
+        return this.priced ? { amount: this.amount, currency: 'USD', basis: 'estimated' } : undefined;
+    }
+}
+function codesOf(question) {
+    if (question.type === 'yes-no')
+        return ['Y', 'N'];
+    if (question.type === 'score')
+        return question.levels.map((_, level) => String(level));
+    return question.options.length <= 26
+        ? question.options.map((_, index) => String.fromCharCode(65 + index))
+        : question.options.map((_, index) => String(index + 1));
+}
+function promptOf(state, question, codes, instructions) {
+    const text = typeof state === 'string' ? state : JSON.stringify(state, null, 2);
+    const lines = [`State:\n${text}`, ''];
+    if (instructions)
+        lines.push(instructions, '');
+    if (question.type === 'yes-no') {
+        lines.push(`Question: ${question.question ?? 'Is the statement true of the state?'}`);
+        lines.push(`Y: yes${question.criteria?.yes ? `, ${question.criteria.yes}` : ''}`);
+        lines.push(`N: no${question.criteria?.no ? `, ${question.criteria.no}` : ''}`);
+    }
+    else if (question.type === 'choice') {
+        lines.push(`Question: ${question.question ?? 'Which option fits the state?'}`);
+        question.options.forEach((option, index) => {
+            lines.push(`${codes[index]}: ${option.name}${option.description ? `, ${option.description}` : ''}`);
+        });
+    }
+    else {
+        lines.push(`Question: ${question.question ?? 'Which level fits the state?'}`);
+        question.levels.forEach((level, index) => {
+            lines.push(`${codes[index]}: ${level}`);
+        });
+    }
+    lines.push('', `Answer with one code: ${codes.join(', ')}.`);
+    return lines.join('\n');
+}
+function codeOf(token) {
+    return token.replace(/^[\s"'`*(]+|[\s"'`*).:,]+$/g, '').toUpperCase();
+}
+function weightsFrom(logprobs, codes) {
+    const first = logprobs?.find((item) => item.token.trim() !== '');
+    if (!first)
+        return undefined;
+    const candidates = first.top?.length ? first.top : [{ token: first.token, logprob: first.logprob }];
+    const weights = codes.map(() => 0);
+    let found = false;
+    for (const candidate of candidates) {
+        const index = matchCode(candidate.token, codes);
+        if (index < 0 || !Number.isFinite(candidate.logprob))
+            continue;
+        weights[index] = weights[index] + Math.exp(candidate.logprob);
+        found = true;
+    }
+    return found ? weights : undefined;
+}
+function codeIn(content, codes) {
+    const head = content.trim().split(/[\s:,.)]+/)[0] ?? '';
+    return codes[matchCode(head, codes)];
+}
+function matchCode(token, codes) {
+    const code = codeOf(token);
+    const index = codes.indexOf(code);
+    if (index >= 0 || codes.length !== 2 || codes[0] !== 'Y' || codes[1] !== 'N')
+        return index;
+    if (code === 'YES' || code === 'TRUE')
+        return 0;
+    return code === 'NO' || code === 'FALSE' ? 1 : -1;
+}
+function distributionOf(question, codes, weights) {
+    const total = weights.reduce((sum, weight) => sum + weight, 0);
+    const share = (index) => (total > 0 ? (weights[index] ?? 0) / total : 1 / codes.length);
+    if (question.type === 'yes-no')
+        return { type: 'yes-no', yes: share(0) };
+    if (question.type === 'score')
+        return { type: 'score', probabilities: codes.map((_, index) => share(index)) };
+    return {
+        type: 'choice',
+        probabilities: Object.fromEntries(question.options.map((option, index) => [option.name, share(index)])),
+    };
+}
+function refusedOption(error) {
+    const status = error?.status;
+    return status === 400 || status === 422;
+}