@doist/doistbot-cli 1.0.4 → 1.0.6

package/sandbox/dist/core/tracing.js

@@ -0,0 +1,71 @@
+import { context, SpanStatusCode, trace } from '@opentelemetry/api';
+// recordDecision/recordEvent emit directly (bypassing the processor), so they
+// apply the same per-attribute cap themselves to keep large arrays/objects
+// from blowing the log-size budget.
+import { truncateAttrs } from './logger-span-processor.js';
+import { logger } from './logging.js';
+const tracer = trace.getTracer('doistbot-sandbox');
+/**
+ * THE phase-boundary API. Works for sequential AND parallel phases — OTel's
+ * async-hooks context manager (registered by setupTracing) parents nested
+ * spans correctly even across Promise.all.
+ *
+ * On throw: records the exception, sets span status ERROR, re-throws.
+ * On normal return: status is left UNSET (OTel's recommended success default;
+ *   the LoggerSpanProcessor maps UNSET → 'ok'). We deliberately do NOT force
+ *   OK, so a callback that returns a failure result (instead of throwing) and
+ *   sets ERROR itself keeps its ERROR status.
+ * Always ends the span.
+ */
+export async function withPhase(name, attributes, fn) {
+    return tracer.startActiveSpan(name, { attributes: { ...attributes, 'doistbot.kind': 'phase' } }, async (span) => {
+        try {
+            return await fn(span);
+        }
+        catch (err) {
+            span.recordException(err);
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    });
+}
+/**
+ * Start a tool span manually. The ONE exception to "withPhase everywhere":
+ * pi emits tool start/end across separate async callbacks (onProgress), so
+ * there is no single scope to wrap. Parent = the currently-active span (the
+ * model phase). Caller MUST call `span.end()` when the matching tool_end
+ * arrives (and may `setStatus({ code: ERROR })` first on failure).
+ */
+export function startToolSpan(name, attributes) {
+    return tracer.startSpan(name, { attributes: { ...attributes, 'doistbot.kind': 'tool' } }, context.active());
+}
+// Point-in-time lines bypass OTel spans entirely; they read the active span
+// id only for correlation. Meta is spread FIRST so callers can never clobber
+// the envelope fields (event/name/span_id). Timestamps come from the logging
+// system, never from meta.
+function emitPointInTime(kind, name, meta) {
+    const span = trace.getActiveSpan();
+    logger.info(`${kind}: ${name}`, {
+        ...truncateAttrs(meta),
+        event: kind,
+        name,
+        span_id: span?.spanContext().spanId ?? null,
+    });
+}
+/**
+ * Record a point-in-time decision (branch taken, scope resolved, gate passed)
+ * correlated to the active span. Not a span — no duration.
+ */
+export function recordDecision(name, meta) {
+    emitPointInTime('decision', name, meta);
+}
+/** Generic point-in-time annotation. Same mechanics as recordDecision. */
+export function recordEvent(name, meta) {
+    emitPointInTime('event', name, meta);
+}

package/sandbox/dist/main.js

@@ -1,3 +1,7 @@
+import { setupTracing } from './core/tracing-setup.js';
+// Register the OTel SDK before any task module loads — withPhase/startToolSpan
+// are no-ops until a tracer provider is registered.
+setupTracing();
 const taskType = process.env.TASK_TYPE ?? 'review';
 switch (taskType) {
     case 'chat':
@@ -32,4 +36,3 @@ switch (taskType) {
         process.stderr.write(`Unknown TASK_TYPE: ${taskType}\n`);
         process.exit(1);
 }
-export {};

package/sandbox/dist/providers/config.js

@@ -15,7 +15,7 @@ export function resolveProviderTimeoutMs(explicitTimeoutMs) {
         explicitTimeoutMs > 0) {
         return explicitTimeoutMs;
     }
-    const sharedTimeout = parseTimeoutMs(process.env.COUNCIL_MODEL_TIMEOUT_MS);
+    const sharedTimeout = parseTimeoutMs(process.env.REVIEW_MODEL_TIMEOUT_MS);
     if (sharedTimeout != null) {
         return sharedTimeout;
     }

package/sandbox/dist/providers/credentials.js

@@ -0,0 +1,40 @@
+import { parsePiAuthProviderId } from '../core/pi.js';
+export function resolveReviewProviderCredential(credential) {
+    if (typeof credential === 'string') {
+        const apiKey = credential.trim();
+        if (!apiKey) {
+            return undefined;
+        }
+        const piAuthProviderId = parsePiAuthProviderId(apiKey);
+        return {
+            apiKey,
+            ...(piAuthProviderId ? { piProviderId: piAuthProviderId } : {}),
+        };
+    }
+    if (!credential) {
+        return undefined;
+    }
+    const apiKey = credential.apiKey.trim();
+    if (!apiKey) {
+        return undefined;
+    }
+    const piAuthProviderId = parsePiAuthProviderId(apiKey);
+    const piProviderId = piAuthProviderId ?? credential.piProviderId;
+    return {
+        apiKey,
+        ...(piProviderId ? { piProviderId } : {}),
+        ...(credential.modelName ? { modelName: credential.modelName } : {}),
+    };
+}
+export function hasReviewProviderCredential(credential) {
+    return resolveReviewProviderCredential(credential) !== undefined;
+}
+export function getReviewProviderCredential(apiKeys, provider) {
+    return resolveReviewProviderCredential(apiKeys[provider]);
+}
+export function createOpenRouterCredential(apiKey) {
+    return {
+        apiKey,
+        piProviderId: 'openrouter',
+    };
+}

package/sandbox/dist/providers/gemini.js

@@ -2,29 +2,27 @@
  * Gemini provider for the multi-model code review system.
  * Uses the Pi harness instead of the Gemini CLI.
  */
-import { DEFAULT_PI_MODELS } from '../core/pi.js';
+import { DEFAULT_OPENROUTER_MODELS, DEFAULT_PI_MODELS } from '../core/pi.js';
 import { resolveProviderTimeoutMs } from './config.js';
 import { extractJsonFromResponse } from './helpers.js';
 import { runPiReviewProvider } from './pi-review.js';
 export class GeminiProvider {
     name = 'gemini';
-    async review(prompt, config, logOptions) {
+    async review(prompt, config) {
+        const modelName = config.modelName ??
+            (config.piProviderId === 'openrouter'
+                ? DEFAULT_OPENROUTER_MODELS.gemini
+                : DEFAULT_PI_MODELS.gemini) ??
+            DEFAULT_PI_MODELS.gemini;
         return await runPiReviewProvider({
             provider: this.name,
-            modelName: config.modelName ?? DEFAULT_PI_MODELS.gemini,
+            modelName,
             prompt,
             config: {
                 ...config,
                 timeout: resolveProviderTimeoutMs(config.timeout),
             },
-            prompts: config.jsonSchema
-                ? [
-                    prompt,
-                    `${prompt}\n\nReturn only JSON that matches the provided schema. Do not include analysis text.`,
-                ]
-                : [prompt],
             parseOutput: (output) => JSON.parse(extractJsonFromResponse(output)),
-            logOptions,
         });
     }
 }

package/sandbox/dist/providers/helpers.js

@@ -3,8 +3,9 @@
  */
 import { randomUUID } from 'crypto';
 import { logger } from '../core/logging.js';
-import { isBatchVoteResponse, isRawReviewResult, isVoteResponse } from './schemas.js';
+import { isRawReviewResult } from './schemas.js';
 const RAW_MODEL_LOG_CHUNK_CHARS = 8000;
+const REVIEW_LOG_ENGINE = 'multi_focus';
 function redactSensitiveStrings(content) {
     return content
         .replace(/(sk-[A-Za-z0-9_-]{10,})/g, '[REDACTED_OPENAI_KEY]')
@@ -34,7 +35,7 @@ export function buildRawModelOutputEntries(content) {
         originalLength: content.length,
     }));
 }
-export function logRawModelOutput({ model, engine = 'council', stage, success, status, durationMs, stdout, stderr, }) {
+export function logRawModelOutput({ model, stage, success, status, durationMs, stdout, stderr, }) {
     const streams = [
         { name: 'stdout', value: stdout },
         { name: 'stderr', value: stderr },
@@ -48,7 +49,7 @@ export function logRawModelOutput({ model, engine = 'council', stage, success, s
         for (const entry of entries) {
             logger.info('Review model raw output', {
                 model,
-                engine,
+                engine: REVIEW_LOG_ENGINE,
                 stage,
                 success,
                 status: status ?? null,
@@ -95,30 +96,14 @@ export function parseRawFindings(comments, modelName) {
 /**
  * Normalizes structured model output into a single provider response shape.
  */
-export function normalizeParsedModelOutput(parsed, modelName, structuredOutputKind = 'auto') {
+export function normalizeParsedModelOutput(parsed, modelName) {
     if (isRawReviewResult(parsed)) {
         return {
             summary: parsed.summary,
             findings: parseRawFindings(parsed.comments, modelName),
         };
     }
-    if ((structuredOutputKind === 'auto' || structuredOutputKind === 'vote') &&
-        isVoteResponse(parsed)) {
-        return {
-            summary: '',
-            findings: [],
-            structuredOutput: parsed,
-        };
-    }
-    if ((structuredOutputKind === 'auto' || structuredOutputKind === 'batch-vote') &&
-        isBatchVoteResponse(parsed)) {
-        return {
-            summary: '',
-            findings: [],
-            structuredOutput: parsed,
-        };
-    }
-    throw new Error('Model output did not match review or vote schema');
+    throw new Error('Model output did not match review schema');
 }
 function extractFencedJsonCandidates(content) {
     const matches = content.match(/```json\s*([\s\S]*?)\s*```/gi);
@@ -181,29 +166,24 @@ function extractBalancedJsonCandidates(content) {
     }
     return candidates;
 }
+/**
+ * Returns JSON-looking candidates from a response string in parser preference order.
+ * Fenced JSON blocks are preferred over balanced objects because models often include
+ * code snippets or object-shaped prose before the final fenced response.
+ */
+export function extractJsonCandidatesFromResponse(content) {
+    return [
+        ...extractFencedJsonCandidates(content).reverse(),
+        ...extractBalancedJsonCandidates(content).reverse(),
+    ];
+}
 /**
  * Extracts JSON from a response string that may contain additional text.
  * Prefers valid fenced JSON blocks, then valid balanced JSON objects.
  * Throws when no valid JSON candidate can be parsed.
  */
 export function extractJsonFromResponse(content) {
-    const fencedCandidates = extractFencedJsonCandidates(content);
-    for (let index = fencedCandidates.length - 1; index >= 0; index--) {
-        const candidate = fencedCandidates[index];
-        if (!candidate) {
-            continue;
-        }
-        try {
-            JSON.parse(candidate);
-            return candidate;
-        }
-        catch {
-            continue;
-        }
-    }
-    const balancedCandidates = extractBalancedJsonCandidates(content);
-    for (let index = balancedCandidates.length - 1; index >= 0; index--) {
-        const candidate = balancedCandidates[index];
+    for (const candidate of extractJsonCandidatesFromResponse(content)) {
         if (!candidate) {
             continue;
         }

package/sandbox/dist/providers/index.js

@@ -1,17 +1,18 @@
 /**
  * Provider factory and exports for the multi-model code review system.
  */
-import { AnthropicProvider } from './anthropic.js';
 import { GeminiProvider } from './gemini.js';
 import { OpenAIProvider } from './openai.js';
-export { AnthropicProvider } from './anthropic.js';
+import { OpenRouterPiProvider } from './openrouter-pi.js';
 export { GeminiProvider } from './gemini.js';
 export { OpenAIProvider } from './openai.js';
+export { OpenRouterPiProvider } from './openrouter-pi.js';
 export * from './types.js';
 const providers = {
+    deepseek: new OpenRouterPiProvider('deepseek'),
     gemini: new GeminiProvider(),
+    zai: new OpenRouterPiProvider('zai'),
     openai: new OpenAIProvider(),
-    anthropic: new AnthropicProvider(),
 };
 /**
  * Gets a provider instance by name.

package/sandbox/dist/providers/openai.js

@@ -8,7 +8,7 @@ import { extractJsonFromResponse } from './helpers.js';
 import { runPiReviewProvider } from './pi-review.js';
 export class OpenAIProvider {
     name = 'openai';
-    async review(prompt, config, logOptions) {
+    async review(prompt, config) {
         return await runPiReviewProvider({
             provider: this.name,
             modelName: config.modelName ?? DEFAULT_PI_MODELS.openai,
@@ -17,14 +17,7 @@ export class OpenAIProvider {
                 ...config,
                 timeout: resolveProviderTimeoutMs(config.timeout),
             },
-            prompts: config.jsonSchema
-                ? [
-                    prompt,
-                    `${prompt}\n\nReturn only JSON that matches the provided schema. Do not include analysis text.`,
-                ]
-                : [prompt],
             parseOutput: (output) => JSON.parse(extractJsonFromResponse(output)),
-            logOptions,
         });
     }
 }

package/sandbox/dist/providers/openrouter-pi.js

@@ -0,0 +1,25 @@
+import { DEFAULT_OPENROUTER_MODELS, DEFAULT_PI_MODELS } from '../core/pi.js';
+import { resolveProviderTimeoutMs } from './config.js';
+import { extractJsonFromResponse } from './helpers.js';
+import { runPiReviewProvider } from './pi-review.js';
+export class OpenRouterPiProvider {
+    name;
+    fallbackModelName;
+    constructor(name, fallbackModelName = DEFAULT_OPENROUTER_MODELS[name] ??
+        DEFAULT_PI_MODELS[name]) {
+        this.name = name;
+        this.fallbackModelName = fallbackModelName;
+    }
+    async review(prompt, config) {
+        return await runPiReviewProvider({
+            provider: this.name,
+            modelName: config.modelName ?? this.fallbackModelName,
+            prompt,
+            config: {
+                ...config,
+                timeout: resolveProviderTimeoutMs(config.timeout),
+            },
+            parseOutput: (output) => JSON.parse(extractJsonFromResponse(output)),
+        });
+    }
+}

package/sandbox/dist/providers/pi-review.js

@@ -1,22 +1,12 @@
 import { logger } from '../core/logging.js';
-import { createPiInvoker } from '../core/pi.js';
+import { createPiInvoker, parsePiAuthProviderId, PI_PROVIDER_BY_DOISTBOT_PROVIDER, } from '../core/pi.js';
 import { logPiProgressEvent } from '../core/pi-progress-logging.js';
 import { WORKSPACE_DIR } from '../core/shared.js';
 import { logRawModelOutput, normalizeParsedModelOutput } from './helpers.js';
-import { BATCH_VOTE_SCHEMA, VOTE_SCHEMA } from './schemas.js';
 const VERBOSE_PI_PROGRESS_LOGS = process.env.DOISTBOT_VERBOSE_PI_PROGRESS === 'true';
 const VERBOSE_PI_RAW_OUTPUT_LOGS = process.env.DOISTBOT_VERBOSE_PI_RAW_OUTPUT === 'true';
+const REVIEW_LOG_ENGINE = 'multi_focus';
 const REVIEW_PI_SYSTEM_PROMPT = 'You are running inside doistbot in a non-interactive environment. Stay tightly focused on the review task in the user prompt. Read only the files that are directly relevant to the changed code, the explicitly named guidance files, and any immediately connected definitions needed to verify a concrete finding. Do not broadly explore the repository, inspect unrelated modules, or search history unless it is necessary to validate a specific review concern. Stop gathering context once you have enough evidence to answer the review task accurately.';
-const DEFAULT_REVIEW_LOG_ENGINE = 'council';
-function getStructuredOutputKind(jsonSchema) {
-    if (jsonSchema === BATCH_VOTE_SCHEMA) {
-        return 'batch-vote';
-    }
-    if (jsonSchema === VOTE_SCHEMA) {
-        return 'vote';
-    }
-    return 'auto';
-}
 function buildModelFailureResult({ model, error, durationMs, timedOut = false, }) {
     return {
         model,
@@ -27,7 +17,7 @@ function buildModelFailureResult({ model, error, durationMs, timedOut = false, }
         durationMs,
     };
 }
-function logReviewModelProgress(model, event, engine) {
+function logReviewModelProgress(model, event) {
     logPiProgressEvent({
         event,
         messages: {
@@ -39,17 +29,17 @@ function logReviewModelProgress(model, event, engine) {
             toolUpdate: 'Review model tool still running',
             toolEnd: 'Review model tool finished',
         },
-        meta: { model, engine },
+        meta: { model, engine: REVIEW_LOG_ENGINE },
         logResponding: VERBOSE_PI_PROGRESS_LOGS,
         logTools: VERBOSE_PI_PROGRESS_LOGS,
     });
 }
-function emitReviewModelProgress(provider, event, config, engine) {
+function emitReviewModelProgress(provider, event, config) {
     config.onProgress?.({
         ...event,
         provider,
     });
-    logReviewModelProgress(provider, event, engine);
+    logReviewModelProgress(provider, event);
 }
 function logReviewRawModelOutput(args) {
     if (!VERBOSE_PI_RAW_OUTPUT_LOGS) {
@@ -57,31 +47,42 @@ function logReviewRawModelOutput(args) {
     }
     logRawModelOutput(args);
 }
-export async function runPiReviewProvider({ provider, modelName, prompt, config, prompts = [prompt], parseOutput, logOptions, }) {
+function isOpenRouterBackedReviewRequest(provider, config) {
+    const resolvedPiProviderId = parsePiAuthProviderId(config.apiKey) ??
+        config.piProviderId ??
+        PI_PROVIDER_BY_DOISTBOT_PROVIDER[provider];
+    return resolvedPiProviderId === 'openrouter';
+}
+export async function runPiReviewProvider({ provider, modelName, prompt, config, prompts = [prompt], parseOutput, }) {
     const startTime = Date.now();
     const timeoutMs = config.timeout ?? 0;
-    const engine = logOptions?.engine ?? DEFAULT_REVIEW_LOG_ENGINE;
     let stdout = '';
     let stderr = '';
     let status = null;
     logger.info('Review model request', {
         model: provider,
-        engine,
+        engine: REVIEW_LOG_ENGINE,
         promptLength: prompt.length,
         modelName,
         timeoutMs,
+        ...(isOpenRouterBackedReviewRequest(provider, config) && config.openRouterSessionId
+            ? { openRouterSessionId: config.openRouterSessionId }
+            : {}),
     });
     try {
         const invoker = createPiInvoker({
             provider,
             apiKey: config.apiKey,
+            piProviderId: config.piProviderId,
             cwd: config.workspaceDir ?? WORKSPACE_DIR,
             onProgress: (event) => {
-                emitReviewModelProgress(provider, event, config, engine);
+                emitReviewModelProgress(provider, event, config);
             },
             capabilityPreset: 'read-only',
             thinkingLevel: config.thinkingLevel,
             systemPrompt: REVIEW_PI_SYSTEM_PROMPT,
+            noContextFiles: true,
+            openRouterSessionId: config.openRouterSessionId,
         });
         for (let attempt = 0; attempt < prompts.length; attempt += 1) {
             const result = await invoker.invoke({
@@ -95,7 +96,7 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
             status = result.ok ? 0 : null;
             logger.info('Review model tool usage', {
                 model: provider,
-                engine,
+                engine: REVIEW_LOG_ENGINE,
                 attempt: attempt + 1,
                 attemptsTotal: prompts.length,
                 attemptDurationMs: result.durationMs,
@@ -104,7 +105,6 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
             if (!result.ok && result.timedOut) {
                 logReviewRawModelOutput({
                     model: provider,
-                    engine,
                     stage: 'timeout',
                     success: false,
                     status,
@@ -115,7 +115,7 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
                 const error = result.error || `Pi ${provider} request timed out after ${timeoutMs}ms`;
                 logger.error('Review model failed', {
                     model: provider,
-                    engine,
+                    engine: REVIEW_LOG_ENGINE,
                     error,
                     durationMs,
                 });
@@ -129,7 +129,6 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
             if (!result.ok) {
                 logReviewRawModelOutput({
                     model: provider,
-                    engine,
                     stage: 'non-zero-exit',
                     success: false,
                     status,
@@ -140,7 +139,7 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
                 const error = `Pi ${provider} request failed: ${result.error.slice(0, 500)}`;
                 logger.error('Review model failed', {
                     model: provider,
-                    engine,
+                    engine: REVIEW_LOG_ENGINE,
                     error,
                     durationMs,
                 });
@@ -154,7 +153,6 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
             if (!output.trim()) {
                 logReviewRawModelOutput({
                     model: provider,
-                    engine,
                     stage: 'empty-output',
                     success: false,
                     status,
@@ -169,10 +167,10 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
                 });
             }
             try {
-                const normalized = normalizeParsedModelOutput(parseOutput(output), provider, getStructuredOutputKind(config.jsonSchema));
+                const normalized = normalizeParsedModelOutput(parseOutput(output), provider);
                 logger.info('Review model response', {
                     model: provider,
-                    engine,
+                    engine: REVIEW_LOG_ENGINE,
                     findingsCount: normalized.findings.length,
                     durationMs,
                     parseMethod: 'extract_json',
@@ -180,13 +178,12 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
                 if (VERBOSE_PI_RAW_OUTPUT_LOGS) {
                     logger.info('Review model findings', {
                         model: provider,
-                        engine,
+                        engine: REVIEW_LOG_ENGINE,
                         findings: normalized.findings,
                     });
                 }
                 logReviewRawModelOutput({
                     model: provider,
-                    engine,
                     stage: 'success',
                     success: true,
                     status,
@@ -198,35 +195,12 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
                     model: provider,
                     summary: normalized.summary,
                     findings: normalized.findings,
-                    structuredOutput: normalized.structuredOutput,
                     durationMs,
                 };
             }
             catch (error) {
-                if (config.jsonSchema && attempt < prompts.length - 1) {
-                    const retryError = error instanceof Error ? error.message : String(error);
-                    logReviewRawModelOutput({
-                        model: provider,
-                        engine,
-                        stage: 'schema-retry',
-                        success: false,
-                        status,
-                        durationMs,
-                        stdout,
-                        stderr,
-                    });
-                    logger.warn('Review model schema retry', {
-                        model: provider,
-                        engine,
-                        durationMs,
-                        attempt: attempt + 1,
-                        error: retryError,
-                    });
-                    continue;
-                }
                 logReviewRawModelOutput({
                     model: provider,
-                    engine,
                     stage: 'parse-error',
                     success: false,
                     status,
@@ -248,7 +222,6 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
         const errorMessage = error instanceof Error ? error.message : String(error);
         logReviewRawModelOutput({
             model: provider,
-            engine,
             stage: 'exception',
             success: false,
             status,
@@ -258,7 +231,7 @@ export async function runPiReviewProvider({ provider, modelName, prompt, config,
         });
         logger.error('Review model failed', {
             model: provider,
-            engine,
+            engine: REVIEW_LOG_ENGINE,
             error: errorMessage,
             durationMs,
         });

package/sandbox/dist/providers/schemas.js

@@ -21,37 +21,6 @@ export const REVIEW_SCHEMA = {
     },
     required: ['summary', 'comments'],
 };
-export const VOTE_SCHEMA = {
-    type: 'object',
-    additionalProperties: false,
-    properties: {
-        approve: { type: 'boolean' },
-        confidence: { type: 'number', minimum: 0, maximum: 1 },
-        reasoning: { type: 'string', minLength: 1 },
-    },
-    required: ['approve', 'confidence', 'reasoning'],
-};
-export const BATCH_VOTE_SCHEMA = {
-    type: 'object',
-    additionalProperties: false,
-    properties: {
-        votes: {
-            type: 'array',
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    findingId: { type: 'string', minLength: 1 },
-                    approve: { type: 'boolean' },
-                    confidence: { type: 'number', minimum: 0, maximum: 1 },
-                    reasoning: { type: 'string', minLength: 1 },
-                },
-                required: ['findingId', 'approve', 'confidence', 'reasoning'],
-            },
-        },
-    },
-    required: ['votes'],
-};
 export const DEDUPE_SCHEMA = {
     type: 'object',
     additionalProperties: false,
@@ -76,18 +45,10 @@ export const DEDUPE_SCHEMA = {
 };
 const ajv = new Ajv();
 const validateRawReviewResult = ajv.compile(REVIEW_SCHEMA);
-const validateVoteResponse = ajv.compile(VOTE_SCHEMA);
-const validateBatchVoteResponse = ajv.compile(BATCH_VOTE_SCHEMA);
 const validateDedupeResponse = ajv.compile(DEDUPE_SCHEMA);
 export function isRawReviewResult(value) {
     return validateRawReviewResult(value);
 }
-export function isVoteResponse(value) {
-    return validateVoteResponse(value);
-}
-export function isBatchVoteResponse(value) {
-    return validateBatchVoteResponse(value);
-}
 export function isDedupeResponse(value) {
     return validateDedupeResponse(value);
 }