@renseiai/agentfactory 0.8.7 → 0.8.9

package/dist/src/providers/index.test.js

@@ -1,5 +1,5 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { resolveProviderName, resolveProviderWithSource, extractProviderFromLabels, extractProviderFromMention, PROVIDER_ALIASES, isValidProviderName, } from './index.js';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { resolveProviderName, resolveProviderWithSource, resolveProviderWithSourceAsync, resolveProviderNameAsync, extractProviderFromLabels, extractProviderFromMention, PROVIDER_ALIASES, isValidProviderName, } from './index.js';
 describe('extractProviderFromLabels', () => {
     it('extracts provider from "provider:<name>" label', () => {
         expect(extractProviderFromLabels(['Bug', 'provider:codex', 'Feature'])).toBe('codex');
@@ -223,3 +223,341 @@ describe('isValidProviderName', () => {
         expect(isValidProviderName('opus')).toBe(false); // alias, not a provider name
     });
 });
+// ---------------------------------------------------------------------------
+// Async provider resolution (with MAB routing)
+// ---------------------------------------------------------------------------
+// Mock the routing engine module
+vi.mock('../routing/routing-engine.js', () => ({
+    selectProvider: vi.fn(),
+}));
+// Mock the logger to suppress warnings in tests
+vi.mock('../logger.js', () => ({
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+function createMockPosteriorStore() {
+    return {
+        getPosterior: vi.fn(),
+        updatePosterior: vi.fn(),
+        getAllPosteriors: vi.fn(),
+        resetPosterior: vi.fn(),
+    };
+}
+function createMockRoutingConfig(overrides) {
+    return {
+        enabled: true,
+        explorationRate: 0.1,
+        windowSize: 100,
+        discountFactor: 0.99,
+        minObservationsForExploit: 5,
+        changeDetectionThreshold: 0.2,
+        ...overrides,
+    };
+}
+function createHighConfidenceDecision(provider = 'codex') {
+    return {
+        selectedProvider: provider,
+        confidence: 0.85,
+        expectedReward: 0.9,
+        source: 'mab-routing',
+        alternatives: [],
+    };
+}
+function createLowConfidenceDecision() {
+    return {
+        selectedProvider: 'codex',
+        confidence: 0.2,
+        expectedReward: 0.5,
+        explorationReason: 'uncertainty',
+        source: 'mab-routing',
+        alternatives: [],
+    };
+}
+describe('resolveProviderWithSourceAsync — full cascade with MAB routing', () => {
+    const envBackup = {};
+    beforeEach(async () => {
+        // Save and clear relevant env vars
+        for (const key of ['AGENT_PROVIDER', 'AGENT_PROVIDER_QA', 'AGENT_PROVIDER_DEVELOPMENT', 'AGENT_PROVIDER_SOCIAL', 'AGENT_PROVIDER_AGENT']) {
+            envBackup[key] = process.env[key];
+            delete process.env[key];
+        }
+        // Reset the routing engine mock
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        vi.mocked(selectProvider).mockReset();
+    });
+    afterEach(() => {
+        // Restore env vars
+        for (const [key, value] of Object.entries(envBackup)) {
+            if (value === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = value;
+            }
+        }
+    });
+    it('10. defaults to claude when no context provided', async () => {
+        const result = await resolveProviderWithSourceAsync();
+        expect(result).toEqual({ name: 'claude', source: 'default' });
+    });
+    it('1. label overrides everything including MAB', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        vi.mocked(selectProvider).mockResolvedValue(createHighConfidenceDecision('amp'));
+        process.env.AGENT_PROVIDER = 'amp';
+        process.env.AGENT_PROVIDER_QA = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            labels: ['provider:codex'],
+            mentionContext: 'use amp',
+            workType: 'qa',
+            project: 'Social',
+            configProviders: {
+                default: 'amp',
+                byWorkType: { qa: 'amp' },
+                byProject: { Social: 'amp' },
+            },
+            routingContext: {
+                posteriorStore: createMockPosteriorStore(),
+                routingConfig: createMockRoutingConfig(),
+            },
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toContain('label');
+    });
+    it('2. mention overrides MAB, config, and env', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        vi.mocked(selectProvider).mockResolvedValue(createHighConfidenceDecision('amp'));
+        process.env.AGENT_PROVIDER = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            mentionContext: 'use codex',
+            workType: 'qa',
+            configProviders: { byWorkType: { qa: 'amp' } },
+            routingContext: {
+                posteriorStore: createMockPosteriorStore(),
+                routingConfig: createMockRoutingConfig(),
+            },
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toContain('mention');
+    });
+    it('3. config byWorkType overrides MAB, env, and config defaults', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        vi.mocked(selectProvider).mockResolvedValue(createHighConfidenceDecision('amp'));
+        process.env.AGENT_PROVIDER_QA = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            workType: 'qa',
+            configProviders: { byWorkType: { qa: 'codex' }, default: 'amp' },
+            routingContext: {
+                posteriorStore: createMockPosteriorStore(),
+                routingConfig: createMockRoutingConfig(),
+            },
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toContain('config providers.byWorkType.qa');
+    });
+    it('4. config byProject overrides MAB and env vars', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        vi.mocked(selectProvider).mockResolvedValue(createHighConfidenceDecision('amp'));
+        process.env.AGENT_PROVIDER_SOCIAL = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            project: 'Social',
+            workType: 'qa',
+            configProviders: { byProject: { Social: 'codex' } },
+            routingContext: {
+                posteriorStore: createMockPosteriorStore(),
+                routingConfig: createMockRoutingConfig(),
+            },
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toContain('config providers.byProject.Social');
+    });
+    it('5. MAB routing selects provider when enabled with high confidence', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        vi.mocked(selectProvider).mockResolvedValue(createHighConfidenceDecision('codex'));
+        process.env.AGENT_PROVIDER_QA = 'amp';
+        process.env.AGENT_PROVIDER = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            workType: 'qa',
+            routingContext: {
+                posteriorStore: createMockPosteriorStore(),
+                routingConfig: createMockRoutingConfig(),
+            },
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toBe('mab-routing');
+    });
+    it('5. MAB routing passes available providers and config to selectProvider', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        vi.mocked(selectProvider).mockResolvedValue(createHighConfidenceDecision('amp'));
+        const mockStore = createMockPosteriorStore();
+        const mockConfig = createMockRoutingConfig({ explorationRate: 0.05 });
+        const result = await resolveProviderWithSourceAsync({
+            workType: 'development',
+            routingContext: {
+                posteriorStore: mockStore,
+                routingConfig: mockConfig,
+                availableProviders: ['claude', 'codex', 'amp'],
+            },
+        });
+        expect(result.name).toBe('amp');
+        expect(result.source).toBe('mab-routing');
+        expect(vi.mocked(selectProvider)).toHaveBeenCalledWith(mockStore, 'development', ['claude', 'codex', 'amp'], mockConfig);
+    });
+    it('5. low-confidence MAB decisions fall through to env var', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        vi.mocked(selectProvider).mockResolvedValue(createLowConfidenceDecision());
+        process.env.AGENT_PROVIDER_QA = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            workType: 'qa',
+            routingContext: {
+                posteriorStore: createMockPosteriorStore(),
+                routingConfig: createMockRoutingConfig(),
+            },
+        });
+        expect(result.name).toBe('amp');
+        expect(result.source).toBe('env AGENT_PROVIDER_QA');
+    });
+    it('5. MAB errors gracefully fall through to env var', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        vi.mocked(selectProvider).mockRejectedValue(new Error('Redis connection failed'));
+        process.env.AGENT_PROVIDER_QA = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            workType: 'qa',
+            routingContext: {
+                posteriorStore: createMockPosteriorStore(),
+                routingConfig: createMockRoutingConfig(),
+            },
+        });
+        expect(result.name).toBe('amp');
+        expect(result.source).toBe('env AGENT_PROVIDER_QA');
+    });
+    it('5. MAB tier skipped when routing disabled (default)', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        process.env.AGENT_PROVIDER_QA = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            workType: 'qa',
+            routingContext: {
+                posteriorStore: createMockPosteriorStore(),
+                routingConfig: createMockRoutingConfig({ enabled: false }),
+            },
+        });
+        expect(result.name).toBe('amp');
+        expect(result.source).toBe('env AGENT_PROVIDER_QA');
+        // selectProvider should NOT have been called
+        expect(vi.mocked(selectProvider)).not.toHaveBeenCalled();
+    });
+    it('5. MAB tier skipped when no posteriorStore provided', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        process.env.AGENT_PROVIDER_QA = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            workType: 'qa',
+            routingContext: {
+                routingConfig: createMockRoutingConfig(),
+            },
+        });
+        expect(result.name).toBe('amp');
+        expect(result.source).toBe('env AGENT_PROVIDER_QA');
+        expect(vi.mocked(selectProvider)).not.toHaveBeenCalled();
+    });
+    it('5. MAB tier skipped when no workType provided', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        const result = await resolveProviderWithSourceAsync({
+            routingContext: {
+                posteriorStore: createMockPosteriorStore(),
+                routingConfig: createMockRoutingConfig(),
+            },
+        });
+        // Should fall through to hardcoded default
+        expect(result.name).toBe('claude');
+        expect(result.source).toBe('default');
+        expect(vi.mocked(selectProvider)).not.toHaveBeenCalled();
+    });
+    it('5. MAB tier skipped when no routingContext provided', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        process.env.AGENT_PROVIDER_QA = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            workType: 'qa',
+        });
+        expect(result.name).toBe('amp');
+        expect(result.source).toBe('env AGENT_PROVIDER_QA');
+        expect(vi.mocked(selectProvider)).not.toHaveBeenCalled();
+    });
+    it('6. env AGENT_PROVIDER_{WORKTYPE} overrides env project and defaults', async () => {
+        process.env.AGENT_PROVIDER_QA = 'codex';
+        process.env.AGENT_PROVIDER_SOCIAL = 'amp';
+        process.env.AGENT_PROVIDER = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            workType: 'qa',
+            project: 'Social',
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toBe('env AGENT_PROVIDER_QA');
+    });
+    it('7. env AGENT_PROVIDER_{PROJECT} overrides global default', async () => {
+        process.env.AGENT_PROVIDER_SOCIAL = 'codex';
+        process.env.AGENT_PROVIDER = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            project: 'Social',
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toBe('env AGENT_PROVIDER_SOCIAL');
+    });
+    it('8. config providers.default overrides env AGENT_PROVIDER', async () => {
+        process.env.AGENT_PROVIDER = 'amp';
+        const result = await resolveProviderWithSourceAsync({
+            configProviders: { default: 'codex' },
+        });
+        expect(result.name).toBe('codex');
+        expect(result.source).toBe('config providers.default');
+    });
+    it('9. env AGENT_PROVIDER overrides hardcoded default', async () => {
+        process.env.AGENT_PROVIDER = 'codex';
+        const result = await resolveProviderWithSourceAsync();
+        expect(result.name).toBe('codex');
+        expect(result.source).toBe('env AGENT_PROVIDER');
+    });
+});
+describe('resolveProviderNameAsync — backwards compatibility', () => {
+    const envBackup = {};
+    beforeEach(() => {
+        for (const key of ['AGENT_PROVIDER', 'AGENT_PROVIDER_QA', 'AGENT_PROVIDER_SOCIAL']) {
+            envBackup[key] = process.env[key];
+            delete process.env[key];
+        }
+    });
+    afterEach(() => {
+        for (const [key, value] of Object.entries(envBackup)) {
+            if (value === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = value;
+            }
+        }
+    });
+    it('returns claude by default', async () => {
+        expect(await resolveProviderNameAsync()).toBe('claude');
+    });
+    it('respects { project, workType } shape', async () => {
+        process.env.AGENT_PROVIDER_QA = 'codex';
+        expect(await resolveProviderNameAsync({ workType: 'qa' })).toBe('codex');
+    });
+    it('accepts labels in context', async () => {
+        expect(await resolveProviderNameAsync({ labels: ['provider:codex'] })).toBe('codex');
+    });
+    it('uses MAB routing when configured', async () => {
+        const { selectProvider } = await import('../routing/routing-engine.js');
+        vi.mocked(selectProvider).mockResolvedValue(createHighConfidenceDecision('amp'));
+        const result = await resolveProviderNameAsync({
+            workType: 'qa',
+            routingContext: {
+                posteriorStore: createMockPosteriorStore(),
+                routingConfig: createMockRoutingConfig(),
+            },
+        });
+        expect(result).toBe('amp');
+    });
+});

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

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './observation-store.js';
+export * from './reward.js';
+export * from './posterior-store.js';
+export * from './observation-recorder.js';
+export * from './routing-engine.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/routing/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,wBAAwB,CAAA;AACtC,cAAc,aAAa,CAAA;AAC3B,cAAc,sBAAsB,CAAA;AACpC,cAAc,2BAA2B,CAAA;AACzC,cAAc,qBAAqB,CAAA"}

package/dist/src/routing/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './observation-store.js';
+export * from './reward.js';
+export * from './posterior-store.js';
+export * from './observation-recorder.js';
+export * from './routing-engine.js';

package/dist/src/routing/observation-recorder.d.ts

@@ -0,0 +1,19 @@
+import type { AgentProcess, OrchestratorEvents } from '../orchestrator/types.js';
+import type { RoutingObservation } from './types.js';
+import type { ObservationStore } from './observation-store.js';
+import type { PosteriorStore } from './posterior-store.js';
+export interface RoutingRecorderOptions {
+    observationStore: ObservationStore;
+    posteriorStore: PosteriorStore;
+}
+/**
+ * Create a routing observation from an AgentProcess.
+ * Returns null if provider or workType is missing (can't record without them).
+ */
+export declare function buildObservation(agent: AgentProcess): RoutingObservation | null;
+/**
+ * Wrap OrchestratorEvents to record routing observations on agent completion.
+ * Best-effort: failures are logged but don't block agent completion flow.
+ */
+export declare function wrapEventsWithRecorder(events: OrchestratorEvents, options: RoutingRecorderOptions): OrchestratorEvents;
+//# sourceMappingURL=observation-recorder.d.ts.map

package/dist/src/routing/observation-recorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation-recorder.d.ts","sourceRoot":"","sources":["../../../src/routing/observation-recorder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AAChF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAG1D,MAAM,WAAW,sBAAsB;IACrC,gBAAgB,EAAE,gBAAgB,CAAA;IAClC,cAAc,EAAE,cAAc,CAAA;CAC/B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,kBAAkB,GAAG,IAAI,CA4B/E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,sBAAsB,GAC9B,kBAAkB,CAqCpB"}

package/dist/src/routing/observation-recorder.js

@@ -0,0 +1,73 @@
+import { randomUUID } from 'crypto';
+import { computeReward, extractRewardFromProcess } from './reward.js';
+/**
+ * Create a routing observation from an AgentProcess.
+ * Returns null if provider or workType is missing (can't record without them).
+ */
+export function buildObservation(agent) {
+    if (!agent.providerName || !agent.workType) {
+        return null;
+    }
+    const rewardInput = extractRewardFromProcess(agent);
+    const reward = computeReward(rewardInput);
+    return {
+        id: randomUUID(),
+        provider: agent.providerName,
+        workType: agent.workType,
+        project: undefined, // will be populated when integrated
+        issueIdentifier: agent.identifier,
+        sessionId: agent.sessionId ?? '',
+        reward,
+        taskCompleted: agent.status === 'completed',
+        prCreated: agent.pullRequestUrl !== undefined,
+        qaResult: agent.workResult ?? 'unknown',
+        totalCostUsd: agent.totalCostUsd ?? 0,
+        wallClockMs: agent.completedAt && agent.startedAt
+            ? agent.completedAt.getTime() - agent.startedAt.getTime()
+            : 0,
+        timestamp: Date.now(),
+        confidence: 0, // populated once routing engine is active
+        explorationReason: undefined,
+    };
+}
+/**
+ * Wrap OrchestratorEvents to record routing observations on agent completion.
+ * Best-effort: failures are logged but don't block agent completion flow.
+ */
+export function wrapEventsWithRecorder(events, options) {
+    const { observationStore, posteriorStore } = options;
+    async function recordObservation(agent) {
+        const obs = buildObservation(agent);
+        if (!obs)
+            return;
+        try {
+            await observationStore.recordObservation(obs);
+            await posteriorStore.updatePosterior(obs.provider, obs.workType, obs.reward);
+        }
+        catch (error) {
+            console.error('[routing] Failed to record observation', {
+                error: error instanceof Error ? error.message : String(error),
+                identifier: agent.identifier,
+            });
+        }
+    }
+    return {
+        ...events,
+        onAgentComplete: (agent) => {
+            events.onAgentComplete?.(agent);
+            void recordObservation(agent);
+        },
+        onAgentStopped: (agent) => {
+            events.onAgentStopped?.(agent);
+            void recordObservation(agent);
+        },
+        onAgentError: (agent, error) => {
+            events.onAgentError?.(agent, error);
+            void recordObservation(agent);
+        },
+        onAgentIncomplete: (agent) => {
+            events.onAgentIncomplete?.(agent);
+            void recordObservation(agent);
+        },
+    };
+}

package/dist/src/routing/observation-recorder.test.d.ts

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

package/dist/src/routing/observation-recorder.test.d.ts.map

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