@renseiai/agentfactory 0.8.8 → 0.8.10

package/dist/src/routing/reward.d.ts

@@ -0,0 +1,16 @@
+import type { AgentProcess } from '../orchestrator/types.js';
+export declare const MAX_EXPECTED_COST = 5;
+export interface RoutingReward {
+    taskCompleted: boolean;
+    prCreated: boolean;
+    qaResult: 'passed' | 'failed' | 'unknown';
+    totalCostUsd: number;
+    inputTokens: number;
+    outputTokens: number;
+    wallClockTimeMs: number;
+    requiredRefinements: number;
+    humanEscalations: number;
+}
+export declare function computeReward(outcome: RoutingReward): number;
+export declare function extractRewardFromProcess(process: AgentProcess): RoutingReward;
+//# sourceMappingURL=reward.d.ts.map

package/dist/src/routing/reward.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reward.d.ts","sourceRoot":"","sources":["../../../src/routing/reward.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D,eAAO,MAAM,iBAAiB,IAAM,CAAA;AAEpC,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,OAAO,CAAA;IACtB,SAAS,EAAE,OAAO,CAAA;IAClB,QAAQ,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAA;IACzC,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,eAAe,EAAE,MAAM,CAAA;IACvB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAS5D;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa,CAe7E"}

package/dist/src/routing/reward.js

@@ -0,0 +1,29 @@
+export const MAX_EXPECTED_COST = 5.0; // USD
+export function computeReward(outcome) {
+    let reward = 0;
+    if (outcome.taskCompleted)
+        reward += 0.5;
+    if (outcome.prCreated)
+        reward += 0.2;
+    if (outcome.qaResult === 'passed')
+        reward += 0.3;
+    // Cost penalty (normalized)
+    const costPenalty = Math.min(outcome.totalCostUsd / MAX_EXPECTED_COST, 1);
+    reward -= 0.1 * costPenalty;
+    return Math.max(0, Math.min(1, reward));
+}
+export function extractRewardFromProcess(process) {
+    return {
+        taskCompleted: process.status === 'completed',
+        prCreated: process.pullRequestUrl !== undefined,
+        qaResult: process.workResult ?? 'unknown',
+        totalCostUsd: process.totalCostUsd ?? 0,
+        inputTokens: process.inputTokens ?? 0,
+        outputTokens: process.outputTokens ?? 0,
+        wallClockTimeMs: process.completedAt && process.startedAt
+            ? process.completedAt.getTime() - process.startedAt.getTime()
+            : 0,
+        requiredRefinements: 0,
+        humanEscalations: 0,
+    };
+}

package/dist/src/routing/reward.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reward.test.d.ts.map

package/dist/src/routing/reward.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reward.test.d.ts","sourceRoot":"","sources":["../../../src/routing/reward.test.ts"],"names":[],"mappings":""}

package/dist/src/routing/reward.test.js

@@ -0,0 +1,210 @@
+import { describe, it, expect } from 'vitest';
+import { computeReward, extractRewardFromProcess, MAX_EXPECTED_COST } from './reward.js';
+function makeReward(overrides = {}) {
+    return {
+        taskCompleted: false,
+        prCreated: false,
+        qaResult: 'unknown',
+        totalCostUsd: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        wallClockTimeMs: 0,
+        requiredRefinements: 0,
+        humanEscalations: 0,
+        ...overrides,
+    };
+}
+function makeProcess(overrides = {}) {
+    return {
+        issueId: 'issue-1',
+        identifier: 'SUP-100',
+        pid: 1234,
+        status: 'running',
+        startedAt: new Date('2024-01-01T00:00:00Z'),
+        lastActivityAt: new Date('2024-01-01T00:01:00Z'),
+        ...overrides,
+    };
+}
+describe('computeReward', () => {
+    it('returns ~1.0 for full success with zero cost', () => {
+        const reward = computeReward(makeReward({
+            taskCompleted: true,
+            prCreated: true,
+            qaResult: 'passed',
+            totalCostUsd: 0,
+        }));
+        // 0.5 + 0.2 + 0.3 - 0 = 1.0
+        expect(reward).toBe(1.0);
+    });
+    it('returns 0.0 for full failure', () => {
+        const reward = computeReward(makeReward());
+        expect(reward).toBe(0.0);
+    });
+    it('returns 0.5 for taskCompleted only', () => {
+        const reward = computeReward(makeReward({ taskCompleted: true }));
+        expect(reward).toBe(0.5);
+    });
+    it('returns 0.2 for prCreated only', () => {
+        const reward = computeReward(makeReward({ prCreated: true }));
+        expect(reward).toBe(0.2);
+    });
+    it('returns 0.3 for qaResult passed only', () => {
+        const reward = computeReward(makeReward({ qaResult: 'passed' }));
+        expect(reward).toBe(0.3);
+    });
+    it('returns 0.7 for taskCompleted + prCreated', () => {
+        const reward = computeReward(makeReward({ taskCompleted: true, prCreated: true }));
+        expect(reward).toBe(0.7);
+    });
+    it('applies full cost penalty of 0.1 when cost equals MAX_EXPECTED_COST', () => {
+        const reward = computeReward(makeReward({
+            taskCompleted: true,
+            prCreated: true,
+            qaResult: 'passed',
+            totalCostUsd: MAX_EXPECTED_COST,
+        }));
+        // 0.5 + 0.2 + 0.3 - 0.1 * 1.0 = 0.9
+        expect(reward).toBeCloseTo(0.9);
+    });
+    it('caps cost penalty when cost exceeds MAX_EXPECTED_COST', () => {
+        const reward = computeReward(makeReward({
+            taskCompleted: true,
+            prCreated: true,
+            qaResult: 'passed',
+            totalCostUsd: 100,
+        }));
+        // Cost penalty capped at 0.1, so 1.0 - 0.1 = 0.9
+        expect(reward).toBeCloseTo(0.9);
+    });
+    it('applies proportional cost penalty', () => {
+        const reward = computeReward(makeReward({
+            taskCompleted: true,
+            totalCostUsd: MAX_EXPECTED_COST / 2,
+        }));
+        // 0.5 - 0.1 * 0.5 = 0.45
+        expect(reward).toBeCloseTo(0.45);
+    });
+    it('clamps reward to minimum of 0', () => {
+        // Only cost, no success signals: 0 - 0.1 = -0.1 => clamped to 0
+        const reward = computeReward(makeReward({ totalCostUsd: MAX_EXPECTED_COST }));
+        expect(reward).toBe(0);
+    });
+    it('clamps reward to maximum of 1', () => {
+        // Full success with zero cost should be exactly 1.0 (0.5 + 0.2 + 0.3)
+        const reward = computeReward(makeReward({
+            taskCompleted: true,
+            prCreated: true,
+            qaResult: 'passed',
+            totalCostUsd: 0,
+        }));
+        expect(reward).toBeLessThanOrEqual(1);
+        expect(reward).toBeGreaterThanOrEqual(0);
+    });
+    it('does not add reward for qaResult failed', () => {
+        const reward = computeReward(makeReward({ qaResult: 'failed' }));
+        expect(reward).toBe(0);
+    });
+    it('does not add reward for qaResult unknown', () => {
+        const reward = computeReward(makeReward({ qaResult: 'unknown' }));
+        expect(reward).toBe(0);
+    });
+});
+describe('extractRewardFromProcess', () => {
+    it('maps completed process with PR and passed QA', () => {
+        const process = makeProcess({
+            status: 'completed',
+            pullRequestUrl: 'https://github.com/org/repo/pull/1',
+            workResult: 'passed',
+            totalCostUsd: 1.5,
+            inputTokens: 10000,
+            outputTokens: 5000,
+            startedAt: new Date('2024-01-01T00:00:00Z'),
+            completedAt: new Date('2024-01-01T00:05:00Z'),
+        });
+        const result = extractRewardFromProcess(process);
+        expect(result.taskCompleted).toBe(true);
+        expect(result.prCreated).toBe(true);
+        expect(result.qaResult).toBe('passed');
+        expect(result.totalCostUsd).toBe(1.5);
+        expect(result.inputTokens).toBe(10000);
+        expect(result.outputTokens).toBe(5000);
+        expect(result.wallClockTimeMs).toBe(300000); // 5 minutes
+        expect(result.requiredRefinements).toBe(0);
+        expect(result.humanEscalations).toBe(0);
+    });
+    it('maps failed process', () => {
+        const process = makeProcess({
+            status: 'failed',
+        });
+        const result = extractRewardFromProcess(process);
+        expect(result.taskCompleted).toBe(false);
+        expect(result.prCreated).toBe(false);
+        expect(result.qaResult).toBe('unknown');
+    });
+    it('maps running process as not completed', () => {
+        const result = extractRewardFromProcess(makeProcess({ status: 'running' }));
+        expect(result.taskCompleted).toBe(false);
+    });
+    it('maps incomplete process as not completed', () => {
+        const result = extractRewardFromProcess(makeProcess({ status: 'incomplete' }));
+        expect(result.taskCompleted).toBe(false);
+    });
+    it('maps stopped process as not completed', () => {
+        const result = extractRewardFromProcess(makeProcess({ status: 'stopped' }));
+        expect(result.taskCompleted).toBe(false);
+    });
+    it('handles undefined pullRequestUrl', () => {
+        const result = extractRewardFromProcess(makeProcess({ pullRequestUrl: undefined }));
+        expect(result.prCreated).toBe(false);
+    });
+    it('handles undefined workResult', () => {
+        const result = extractRewardFromProcess(makeProcess({ workResult: undefined }));
+        expect(result.qaResult).toBe('unknown');
+    });
+    it('handles undefined totalCostUsd', () => {
+        const result = extractRewardFromProcess(makeProcess({ totalCostUsd: undefined }));
+        expect(result.totalCostUsd).toBe(0);
+    });
+    it('handles undefined inputTokens', () => {
+        const result = extractRewardFromProcess(makeProcess({ inputTokens: undefined }));
+        expect(result.inputTokens).toBe(0);
+    });
+    it('handles undefined outputTokens', () => {
+        const result = extractRewardFromProcess(makeProcess({ outputTokens: undefined }));
+        expect(result.outputTokens).toBe(0);
+    });
+    it('handles undefined completedAt (wallClockTimeMs is 0)', () => {
+        const result = extractRewardFromProcess(makeProcess({
+            startedAt: new Date('2024-01-01T00:00:00Z'),
+            completedAt: undefined,
+        }));
+        expect(result.wallClockTimeMs).toBe(0);
+    });
+    it('computes correct wallClockTimeMs from startedAt and completedAt', () => {
+        const result = extractRewardFromProcess(makeProcess({
+            startedAt: new Date('2024-01-01T00:00:00Z'),
+            completedAt: new Date('2024-01-01T01:00:00Z'),
+        }));
+        expect(result.wallClockTimeMs).toBe(3600000); // 1 hour
+    });
+    it('end-to-end: extractRewardFromProcess feeds into computeReward correctly', () => {
+        const process = makeProcess({
+            status: 'completed',
+            pullRequestUrl: 'https://github.com/org/repo/pull/1',
+            workResult: 'passed',
+            totalCostUsd: 0,
+        });
+        const routingReward = extractRewardFromProcess(process);
+        const reward = computeReward(routingReward);
+        expect(reward).toBe(1.0);
+    });
+    it('end-to-end: failed process with high cost yields 0', () => {
+        const process = makeProcess({
+            status: 'failed',
+            totalCostUsd: 10,
+        });
+        const routingReward = extractRewardFromProcess(process);
+        const reward = computeReward(routingReward);
+        expect(reward).toBe(0);
+    });
+});

package/dist/src/routing/routing-engine.d.ts

@@ -0,0 +1,20 @@
+import type { AgentProviderName } from '../providers/types.js';
+import type { AgentWorkType } from '../orchestrator/work-types.js';
+import type { RoutingDecision, RoutingConfig } from './types.js';
+import type { PosteriorStore } from './posterior-store.js';
+export declare const DEFAULT_ROUTING_CONFIG: RoutingConfig;
+export declare function betaMean(alpha: number, beta: number): number;
+export declare function betaVariance(alpha: number, beta: number): number;
+/**
+ * Sample from a Beta distribution using the ratio of Gamma variates.
+ * If X ~ Gamma(alpha), Y ~ Gamma(beta), then X/(X+Y) ~ Beta(alpha, beta).
+ *
+ * If a random generator is provided, use it for deterministic testing.
+ */
+export declare function betaSample(alpha: number, beta: number, rng?: () => number): number;
+export interface SelectProviderOptions {
+    forcedExploration?: boolean;
+    rng?: () => number;
+}
+export declare function selectProvider(posteriorStore: PosteriorStore, workType: AgentWorkType, availableProviders: AgentProviderName[], config?: RoutingConfig, opts?: SelectProviderOptions): Promise<RoutingDecision>;
+//# sourceMappingURL=routing-engine.d.ts.map

package/dist/src/routing/routing-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-engine.d.ts","sourceRoot":"","sources":["../../../src/routing/routing-engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,eAAO,MAAM,sBAAsB,EAAE,aAOpC,CAAA;AAGD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGhE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,MAAM,GAAG,MAAM,CAQlF;AAkCD,MAAM,WAAW,qBAAqB;IACpC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CACnB;AAED,wBAAsB,cAAc,CAClC,cAAc,EAAE,cAAc,EAC9B,QAAQ,EAAE,aAAa,EACvB,kBAAkB,EAAE,iBAAiB,EAAE,EACvC,MAAM,GAAE,aAAsC,EAC9C,IAAI,CAAC,EAAE,qBAAqB,GAC3B,OAAO,CAAC,eAAe,CAAC,CAgE1B"}

package/dist/src/routing/routing-engine.js

@@ -0,0 +1,113 @@
+export const DEFAULT_ROUTING_CONFIG = {
+    enabled: false,
+    explorationRate: 0.1,
+    windowSize: 100,
+    discountFactor: 0.99,
+    minObservationsForExploit: 5,
+    changeDetectionThreshold: 0.2,
+};
+// Beta distribution utilities - pure math, no external dependencies
+export function betaMean(alpha, beta) {
+    return alpha / (alpha + beta);
+}
+export function betaVariance(alpha, beta) {
+    const ab = alpha + beta;
+    return (alpha * beta) / (ab * ab * (ab + 1));
+}
+/**
+ * Sample from a Beta distribution using the ratio of Gamma variates.
+ * If X ~ Gamma(alpha), Y ~ Gamma(beta), then X/(X+Y) ~ Beta(alpha, beta).
+ *
+ * If a random generator is provided, use it for deterministic testing.
+ */
+export function betaSample(alpha, beta, rng) {
+    const random = rng ?? Math.random;
+    const x = gammaSample(alpha, random);
+    const y = gammaSample(beta, random);
+    if (x + y === 0)
+        return 0.5; // Edge case
+    return x / (x + y);
+}
+/**
+ * Sample from a Gamma distribution using Marsaglia and Tsang's method.
+ */
+function gammaSample(shape, random) {
+    if (shape < 1) {
+        // For shape < 1, use the trick: Gamma(shape) = Gamma(shape+1) * U^(1/shape)
+        return gammaSample(shape + 1, random) * Math.pow(random(), 1 / shape);
+    }
+    const d = shape - 1 / 3;
+    const c = 1 / Math.sqrt(9 * d);
+    while (true) {
+        let x;
+        let v;
+        do {
+            // Generate standard normal using Box-Muller
+            const u1 = random();
+            const u2 = random();
+            x = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+            v = 1 + c * x;
+        } while (v <= 0);
+        v = v * v * v;
+        const u = random();
+        if (u < 1 - 0.0331 * (x * x) * (x * x))
+            return d * v;
+        if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v)))
+            return d * v;
+    }
+}
+export async function selectProvider(posteriorStore, workType, availableProviders, config = DEFAULT_ROUTING_CONFIG, opts) {
+    const posteriors = await Promise.all(availableProviders.map(p => posteriorStore.getPosterior(p, workType)));
+    const rng = opts?.rng;
+    // Forced exploration: random selection
+    if (opts?.forcedExploration || (rng ?? Math.random)() < config.explorationRate) {
+        const idx = Math.floor((rng ?? Math.random)() * availableProviders.length);
+        const chosen = posteriors[idx];
+        const mean = betaMean(chosen.alpha, chosen.beta);
+        const confidence = 1 - Math.sqrt(betaVariance(chosen.alpha, chosen.beta));
+        const others = posteriors
+            .filter((_, i) => i !== idx)
+            .map(p => ({
+            provider: p.provider,
+            expectedReward: betaMean(p.alpha, p.beta),
+            confidence: 1 - Math.sqrt(betaVariance(p.alpha, p.beta)),
+        }));
+        return {
+            selectedProvider: chosen.provider,
+            confidence,
+            expectedReward: mean,
+            explorationReason: 'forced',
+            source: 'mab-routing',
+            alternatives: others,
+        };
+    }
+    // Thompson Sampling: draw from each posterior's Beta distribution
+    const samples = posteriors.map(post => ({
+        provider: post.provider,
+        sample: betaSample(post.alpha, post.beta, rng),
+        confidence: 1 - Math.sqrt(betaVariance(post.alpha, post.beta)),
+        expectedReward: betaMean(post.alpha, post.beta),
+    }));
+    // Select highest sample
+    samples.sort((a, b) => b.sample - a.sample);
+    const selected = samples[0];
+    // Only trust posteriors with enough observations
+    const selectedPosterior = posteriors.find(p => p.provider === selected.provider);
+    const isTrusted = selectedPosterior.totalObservations >= config.minObservationsForExploit;
+    return {
+        selectedProvider: selected.provider,
+        confidence: selected.confidence,
+        expectedReward: selected.expectedReward,
+        explorationReason: !isTrusted
+            ? 'uncertainty'
+            : selected.confidence < 0.3
+                ? 'uncertainty'
+                : undefined,
+        source: 'mab-routing',
+        alternatives: samples.slice(1).map(s => ({
+            provider: s.provider,
+            expectedReward: s.expectedReward,
+            confidence: s.confidence,
+        })),
+    };
+}

package/dist/src/routing/routing-engine.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=routing-engine.test.d.ts.map

package/dist/src/routing/routing-engine.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-engine.test.d.ts","sourceRoot":"","sources":["../../../src/routing/routing-engine.test.ts"],"names":[],"mappings":""}