nexus-agents 2.71.0 → 2.72.1

package/dist/{chunk-POQQ7A5E.js → chunk-53K3KEKT.js}

@@ -1,11 +1,18 @@
+import {
+  AdapterModelError,
+  BaseAdapter,
+  createStream,
+  requireApiKey,
+  validateApiKeyPresence
+} from "./chunk-5MHIWRKB.js";
 import {
   CUSTOM_API_BASE_URL_ENV,
   PROVIDER_ENV_KEYS,
   validateCustomApiBaseUrl
-} from "./chunk-VGZJIR22.js";
+} from "./chunk-5WQ3SRSE.js";
 import {
   CUSTOM_API_DEFAULT_MODEL
-} from "./chunk-L2LQ3TSV.js";
+} from "./chunk-2MD5MWCK.js";
 import {
   createCliAdapter,
   createCliDetectionCache,
@@ -13,10 +20,10 @@ import {
   getAvailableClis,
   isCliAvailable,
   withTimeout
-} from "./chunk-XATH462F.js";
+} from "./chunk-ES6GFP35.js";
 import {
   SessionMemory
-} from "./chunk-ZPPX2K57.js";
+} from "./chunk-2KB63QGE.js";
 import {
   AdaptiveMemoryBackend,
   HybridMemoryBackend,
@@ -25,7 +32,7 @@ import {
   getMemoryEntry,
   memoryExists,
   memoryRowToEntry
-} from "./chunk-MJHOSM5U.js";
+} from "./chunk-QECRZ3YA.js";
 import {
   stringifyValue,
   tokenizeFiltered
@@ -34,7 +41,6 @@ import {
   AgentError,
   CACHE_TIMEOUTS,
   CLI_NAMES,
-  ConfigError,
   DEFAULT_CLI,
   DEFAULT_MODEL_CAPABILITIES,
   DEFAULT_MODEL_PER_CLI,
@@ -43,13 +49,11 @@ import {
   MobiMem,
   ModelCapability,
   ModelError,
-  NexusError,
   OutcomeStore,
   SecurityError,
   TASK_SPECIALIZATION_MATRIX,
   TIMEOUT_GUARD,
   TaskOutcomeSchema,
-  TimeoutError,
   VOTE_TIMEOUTS,
   ValidationError,
   categorizeOutcomeErrorMessage,
@@ -76,14 +80,14 @@ import {
   resolveVoteTimeout,
   toRateLimitError,
   validateTimeout
-} from "./chunk-7OBFO4GF.js";
+} from "./chunk-O4KUCF5S.js";
 import {
   ensureLearningDir,
   getOutcomesFile
-} from "./chunk-LJT65EA7.js";
+} from "./chunk-I7ORMAO7.js";
 import {
   nexusDataPath
-} from "./chunk-FDNWRZNJ.js";
+} from "./chunk-GOT7OAL5.js";
 
 // src/mcp/tools/consensus-vote.ts
 import { z as z19 } from "zod";
@@ -1124,51 +1128,51 @@ function composeMiddleware(middlewares) {
     return dispatch(0, args);
   };
 }
-function addAuditMiddleware(middlewares, skip2) {
-  if (skip2.audit !== true) {
+function addAuditMiddleware(middlewares, skip) {
+  if (skip.audit !== true) {
     middlewares.push(createAuditMiddleware());
   }
 }
-function addRateLimitMiddleware(middlewares, config, skip2) {
-  if (skip2.rateLimit !== true && config.rateLimiter !== void 0) {
+function addRateLimitMiddleware(middlewares, config, skip) {
+  if (skip.rateLimit !== true && config.rateLimiter !== void 0) {
     const limiter = config.rateLimiter instanceof RateLimiter ? config.rateLimiter : new RateLimiter(config.rateLimiter);
     middlewares.push(createRateLimitMiddleware(limiter));
   }
 }
-function addValidationMiddleware(middlewares, config, skip2) {
-  if (skip2.validation !== true && config.schema !== void 0) {
+function addValidationMiddleware(middlewares, config, skip) {
+  if (skip.validation !== true && config.schema !== void 0) {
     middlewares.push(createValidationMiddleware(config.schema));
   }
 }
-function addPolicyMiddleware(middlewares, config, skip2) {
-  if (skip2.policy !== true && config.policyFirewall !== void 0) {
+function addPolicyMiddleware(middlewares, config, skip) {
+  if (skip.policy !== true && config.policyFirewall !== void 0) {
     const mode = config.executionMode ?? "read-only";
     middlewares.push(
       createPolicyMiddleware(config.policyFirewall, config.toolName, mode, config.allowedPaths)
     );
   }
 }
-function addTimeoutMiddleware(middlewares, config, skip2) {
-  if (skip2.timeout !== true && config.timeout !== void 0) {
+function addTimeoutMiddleware(middlewares, config, skip) {
+  if (skip.timeout !== true && config.timeout !== void 0) {
     const guard = new TimeoutGuard(config.timeout);
     middlewares.push(createTimeoutMiddleware(guard, config.toolName));
   }
 }
-function addAccessPolicyMiddleware(middlewares, config, skip2) {
-  if (skip2.accessPolicy !== true) {
+function addAccessPolicyMiddleware(middlewares, config, skip) {
+  if (skip.accessPolicy !== true) {
     middlewares.push(createAccessPolicyChainMiddleware(config.toolName));
   }
 }
 function buildMiddlewareStack(config) {
-  const skip2 = config.skip ?? {};
+  const skip = config.skip ?? {};
   const middlewares = [];
   middlewares.push(createMetricsMiddleware());
-  addAuditMiddleware(middlewares, skip2);
-  addRateLimitMiddleware(middlewares, config, skip2);
-  addValidationMiddleware(middlewares, config, skip2);
-  addPolicyMiddleware(middlewares, config, skip2);
-  addAccessPolicyMiddleware(middlewares, config, skip2);
-  addTimeoutMiddleware(middlewares, config, skip2);
+  addAuditMiddleware(middlewares, skip);
+  addRateLimitMiddleware(middlewares, config, skip);
+  addValidationMiddleware(middlewares, config, skip);
+  addPolicyMiddleware(middlewares, config, skip);
+  addAccessPolicyMiddleware(middlewares, config, skip);
+  addTimeoutMiddleware(middlewares, config, skip);
   return middlewares;
 }
 function createMiddlewareChain(config) {
@@ -1829,658 +1833,6 @@ function createCliToModelAdapter(cliAdapter, config) {
 // src/adapters/claude-adapter.ts
 import Anthropic3 from "@anthropic-ai/sdk";
 
-// src/adapters/base-adapter.ts
-var AdapterModelError = class extends ModelError {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ModelError";
-  }
-};
-function isApiKeyMissing(apiKey) {
-  return apiKey === void 0 || apiKey === "" || apiKey.trim() === "";
-}
-function requireApiKey(apiKey, providerName, modelId) {
-  if (isApiKeyMissing(apiKey)) {
-    throw new ConfigError(`${providerName} API key is required`, {
-      context: { providerId: providerName.toLowerCase(), modelId }
-    });
-  }
-}
-function validateApiKeyPresence(apiKey, providerId, modelId) {
-  if (isApiKeyMissing(apiKey)) {
-    return err(
-      new ConfigError(`${providerId} API key is required`, {
-        context: { providerId, modelId }
-      })
-    );
-  }
-  return ok(void 0);
-}
-var BaseAdapter = class {
-  providerId;
-  modelId;
-  capabilities;
-  /** Logger for request/response logging */
-  logger;
-  /** Configuration for the adapter */
-  config;
-  /**
-   * Creates a new BaseAdapter instance.
-   *
-   * @param config - Adapter configuration
-   */
-  constructor(config) {
-    this.providerId = config.providerId;
-    this.modelId = config.modelId;
-    this.capabilities = config.capabilities;
-    this.config = config;
-    this.logger = config.logger ?? createLogger({
-      adapter: config.providerId,
-      model: config.modelId
-    });
-  }
-  /**
-   * Count tokens in text using the unified TokenEstimator.
-   *
-   * This provides a reasonable estimate for most use cases.
-   * Concrete adapters may override this with provider-specific tokenizers.
-   *
-   * @param text - Text to count tokens for
-   * @returns Approximate token count
-   */
-  countTokens(text) {
-    return Promise.resolve(getTokenEstimator().estimateText(text));
-  }
-  /**
-   * Validate adapter configuration.
-   *
-   * Checks that required configuration fields are present and valid.
-   * Concrete adapters may override to add provider-specific validation.
-   *
-   * @returns Ok if valid, ConfigError if invalid
-   */
-  validateConfig() {
-    const errors = [];
-    if (!this.providerId || this.providerId.trim() === "") {
-      errors.push("Provider ID is required");
-    }
-    if (!this.modelId || this.modelId.trim() === "") {
-      errors.push("Model ID is required");
-    }
-    if (this.config.timeout !== void 0 && this.config.timeout <= 0) {
-      errors.push("Timeout must be positive");
-    }
-    if (this.config.maxRetries !== void 0 && this.config.maxRetries < 0) {
-      errors.push("Max retries cannot be negative");
-    }
-    if (errors.length > 0) {
-      return err(
-        new ConfigError(`Invalid adapter configuration: ${errors.join("; ")}`, {
-          context: {
-            providerId: this.providerId,
-            modelId: this.modelId,
-            errors
-          }
-        })
-      );
-    }
-    return ok(void 0);
-  }
-  /**
-   * Check if this adapter supports a specific capability.
-   *
-   * @param capability - The capability to check for
-   * @returns True if the capability is supported
-   */
-  hasCapability(capability) {
-    return this.capabilities.includes(capability);
-  }
-  /**
-   * Log details about an outgoing request.
-   * Sanitizes sensitive information before logging.
-   *
-   * @param request - The completion request to log
-   */
-  logRequest(request) {
-    const messageCount = request.messages.length;
-    const hasTools = request.tools !== void 0 && request.tools.length > 0;
-    const toolCount = request.tools?.length ?? 0;
-    this.logger.debug("Sending completion request", {
-      messageCount,
-      hasSystemPrompt: request.systemPrompt !== void 0,
-      temperature: request.temperature,
-      maxTokens: request.maxTokens,
-      hasTools,
-      toolCount,
-      responseFormat: request.responseFormat?.type,
-      stopSequences: request.stop?.length ?? 0
-    });
-  }
-  /**
-   * Log details about a received response.
-   *
-   * @param response - The completion response to log
-   */
-  logResponse(response) {
-    this.logger.debug("Received completion response", {
-      contentBlocks: response.content.length,
-      stopReason: response.stopReason,
-      inputTokens: response.usage.inputTokens,
-      outputTokens: response.usage.outputTokens,
-      totalTokens: response.usage.totalTokens,
-      model: response.model
-    });
-  }
-  /**
-   * Transform a provider-specific error into a standardized ModelError.
-   *
-   * Maps common error patterns to appropriate error codes:
-   * - Rate limiting (429, quota exceeded)
-   * - Timeouts (ETIMEDOUT, ESOCKETTIMEDOUT)
-   * - Authentication (401, 403)
-   * - Model unavailable (503, 502)
-   *
-   * @param error - The original error from the provider
-   * @returns A standardized ModelError
-   */
-  transformError(error) {
-    if (error instanceof ModelError) {
-      return error;
-    }
-    const errorMessage = getErrorMessage(error);
-    const errorCode = this.determineErrorCode(error);
-    const modelError = this.createModelError(errorMessage, errorCode, error);
-    this.logger.error("Model adapter error", modelError, {
-      errorCode,
-      providerId: this.providerId,
-      modelId: this.modelId
-    });
-    return modelError;
-  }
-  /**
-   * Create a ModelError with appropriate error code.
-   */
-  createModelError(message, errorCode, originalError) {
-    const fullMessage = `${this.providerId}/${this.modelId}: ${message}`;
-    const options = {
-      code: errorCode,
-      context: {
-        providerId: this.providerId,
-        modelId: this.modelId
-      }
-    };
-    if (originalError instanceof Error) {
-      options.cause = originalError;
-    }
-    return new AdapterModelError(fullMessage, options);
-  }
-  /**
-   * Determine the appropriate error code based on error characteristics.
-   */
-  determineErrorCode(error) {
-    if (!(error instanceof Error)) {
-      return ErrorCode.MODEL_ERROR;
-    }
-    const message = error.message.toLowerCase();
-    const errorObj = error;
-    if (isRateLimitLikeError(error)) {
-      return ErrorCode.MODEL_RATE_LIMITED;
-    }
-    if (this.isTimeoutError(message, errorObj)) {
-      return ErrorCode.MODEL_TIMEOUT;
-    }
-    if (this.isUnavailableError(message, errorObj)) {
-      return ErrorCode.MODEL_UNAVAILABLE;
-    }
-    return ErrorCode.MODEL_ERROR;
-  }
-  /**
-   * Check if error indicates a timeout.
-   */
-  isTimeoutError(message, errorObj) {
-    const timeoutPatterns = ["timeout", "etimedout", "esockettimedout"];
-    return errorObj.code === "ETIMEDOUT" || errorObj.code === "ESOCKETTIMEDOUT" || timeoutPatterns.some((pattern) => message.includes(pattern));
-  }
-  /**
-   * Check if error indicates model unavailability.
-   */
-  isUnavailableError(message, errorObj) {
-    const unavailablePatterns = ["unavailable", "service unavailable", "overloaded"];
-    return errorObj.status === 502 || errorObj.status === 503 || unavailablePatterns.some((pattern) => message.includes(pattern));
-  }
-};
-
-// src/adapters/streaming-types.ts
-var StreamError = class extends NexusError {
-  constructor(message, options) {
-    super(message, { code: ErrorCode.INTERNAL_ERROR, ...options });
-    this.name = "StreamError";
-  }
-};
-var StreamCancelledError = class extends NexusError {
-  constructor(reason) {
-    super(reason ?? "Stream was cancelled", { code: ErrorCode.INTERNAL_ERROR });
-    this.name = "StreamCancelledError";
-  }
-};
-var StreamController = class {
-  chunks = [];
-  waiters = [];
-  _state = "idle";
-  _error;
-  maxBufferSize;
-  abortHandler;
-  abortSignal;
-  /**
-   * Creates a new StreamController.
-   * @param options - Stream creation options
-   */
-  constructor(options = {}) {
-    this.maxBufferSize = options.maxBufferSize ?? 100;
-    if (options.signal) {
-      this.abortSignal = options.signal;
-      this.abortHandler = () => {
-        this.cancel("AbortSignal triggered");
-      };
-      options.signal.addEventListener("abort", this.abortHandler);
-    }
-  }
-  /**
-   * Current state of the stream.
-   */
-  get state() {
-    return this._state;
-  }
-  /**
-   * Whether the stream is still active (can receive chunks).
-   */
-  get isActive() {
-    return this._state === "idle" || this._state === "streaming" || this._state === "paused";
-  }
-  /**
-   * Current buffer size.
-   */
-  get bufferSize() {
-    return this.chunks.length;
-  }
-  /**
-   * Push a chunk to the stream.
-   * @param chunk - The chunk to push
-   * @returns Result indicating success or backpressure
-   */
-  push(chunk) {
-    if (!this.isActive) {
-      return err(new StreamError(`Cannot push to stream in state: ${this._state}`));
-    }
-    if (this._state === "idle") {
-      this._state = "streaming";
-    }
-    const waiter = this.waiters.shift();
-    if (waiter) {
-      waiter.resolve({ done: false, value: chunk });
-      return ok(void 0);
-    }
-    if (this.chunks.length >= this.maxBufferSize) {
-      this._state = "paused";
-      return err(
-        new StreamError("Buffer full - backpressure applied", {
-          context: { bufferSize: this.chunks.length, maxBufferSize: this.maxBufferSize }
-        })
-      );
-    }
-    this.chunks.push(chunk);
-    return ok(void 0);
-  }
-  /**
-   * Complete the stream successfully.
-   */
-  complete() {
-    if (!this.isActive) {
-      return;
-    }
-    this._state = "completed";
-    this.removeAbortListener();
-    this.resolveAllWaiters();
-  }
-  /**
-   * Complete the stream with an error.
-   * @param error - The error that occurred
-   */
-  error(error) {
-    if (!this.isActive) {
-      return;
-    }
-    this._state = "error";
-    this._error = error;
-    this.removeAbortListener();
-    this.rejectAllWaiters(error);
-  }
-  /**
-   * Cancel the stream.
-   * @param reason - Optional reason for cancellation
-   */
-  cancel(reason) {
-    if (!this.isActive) {
-      return;
-    }
-    this._state = "cancelled";
-    this._error = new StreamCancelledError(reason);
-    this.removeAbortListener();
-    this.rejectAllWaiters(this._error);
-  }
-  /**
-   * Get the AsyncIterable for consuming the stream.
-   */
-  getIterable() {
-    const nextChunk = () => this.nextChunk();
-    const cancel = (reason) => {
-      this.cancel(reason);
-    };
-    return {
-      [Symbol.asyncIterator]() {
-        return {
-          async next() {
-            return nextChunk();
-          },
-          return() {
-            cancel("Iterator returned");
-            return Promise.resolve({ done: true, value: void 0 });
-          }
-        };
-      }
-    };
-  }
-  async nextChunk() {
-    const chunk = this.chunks.shift();
-    if (chunk !== void 0) {
-      if (this._state === "paused" && this.chunks.length < this.maxBufferSize / 2) {
-        this._state = "streaming";
-      }
-      return { done: false, value: chunk };
-    }
-    if (this._state === "completed") {
-      return { done: true, value: void 0 };
-    }
-    if (this._state === "cancelled" || this._state === "error") {
-      throw this._error ?? new StreamCancelledError();
-    }
-    return new Promise((resolve, reject) => {
-      this.waiters.push({ resolve, reject });
-    });
-  }
-  removeAbortListener() {
-    if (this.abortSignal && this.abortHandler) {
-      this.abortSignal.removeEventListener("abort", this.abortHandler);
-    }
-  }
-  resolveAllWaiters() {
-    for (const waiter of this.waiters) {
-      waiter.resolve({ done: true, value: void 0 });
-    }
-    this.waiters.length = 0;
-  }
-  rejectAllWaiters(error) {
-    for (const waiter of this.waiters) {
-      waiter.reject(error);
-    }
-    this.waiters.length = 0;
-  }
-};
-function createStream(options = {}) {
-  const controller = new StreamController(options);
-  return [controller, controller.getIterable()];
-}
-
-// src/adapters/stream-operators-helpers.ts
-async function* take(stream, count, options = {}) {
-  if (count <= 0) {
-    return;
-  }
-  let taken = 0;
-  for await (const chunk of stream) {
-    if (options.signal?.aborted === true) {
-      throw new StreamCancelledError("take aborted");
-    }
-    yield chunk;
-    taken++;
-    if (taken >= count) {
-      return;
-    }
-  }
-}
-async function* skip(stream, count, options = {}) {
-  let skipped = 0;
-  for await (const chunk of stream) {
-    if (options.signal?.aborted === true) {
-      throw new StreamCancelledError("skip aborted");
-    }
-    if (skipped < count) {
-      skipped++;
-      continue;
-    }
-    yield chunk;
-  }
-}
-async function* concatStreams(streams, options = {}) {
-  for (const stream of streams) {
-    if (options.signal?.aborted === true) {
-      throw new StreamCancelledError("concat aborted");
-    }
-    yield* stream;
-  }
-}
-async function* fromArray(values, options = {}) {
-  for (const value of values) {
-    if (options.signal?.aborted === true) {
-      throw new StreamCancelledError("fromArray aborted");
-    }
-    if (options.delayMs !== void 0 && options.delayMs > 0) {
-      await new Promise((resolve) => setTimeout(resolve, options.delayMs));
-    }
-    yield value;
-  }
-}
-async function* tapStream(stream, fn, options = {}) {
-  let index = 0;
-  for await (const chunk of stream) {
-    if (options.signal?.aborted === true) {
-      throw new StreamCancelledError("tap aborted");
-    }
-    await fn(chunk, index);
-    yield chunk;
-    index++;
-  }
-}
-async function reduceStream(stream, reducer, initialValue, options = {}) {
-  let accumulator = initialValue;
-  let index = 0;
-  try {
-    for await (const chunk of stream) {
-      if (options.signal?.aborted === true) {
-        return err(new StreamError("Reduce aborted"));
-      }
-      accumulator = await reducer(accumulator, chunk, index);
-      index++;
-    }
-    return ok(accumulator);
-  } catch (error) {
-    return err(
-      new StreamError("Failed to reduce stream", {
-        cause: error instanceof Error ? error : new Error(String(error))
-      })
-    );
-  }
-}
-
-// src/adapters/stream-operators.ts
-async function* transformStream(stream, fn, options = {}) {
-  let index = 0;
-  for await (const chunk of stream) {
-    if (options.signal?.aborted === true) {
-      throw new StreamCancelledError("Transform aborted");
-    }
-    yield await fn(chunk, index);
-    index++;
-  }
-}
-async function* mergeStreams(streams, options = {}) {
-  if (streams.length === 0) {
-    return;
-  }
-  const streamOptions = {};
-  if (options.signal) {
-    streamOptions.signal = options.signal;
-  }
-  const [controller, merged] = createStream(streamOptions);
-  let activeCount = streams.length;
-  const consumers = streams.map(async (stream, streamIndex) => {
-    try {
-      for await (const chunk of stream) {
-        if (options.signal?.aborted === true) {
-          break;
-        }
-        controller.push(chunk);
-      }
-    } catch (error) {
-      if (error instanceof StreamCancelledError) {
-        controller.cancel(`Stream ${String(streamIndex)} was cancelled`);
-        return;
-      }
-      controller.error(error instanceof Error ? error : new Error(String(error)));
-      return;
-    } finally {
-      activeCount--;
-      if (activeCount === 0) {
-        controller.complete();
-      }
-    }
-  });
-  Promise.all(consumers).catch((error) => {
-    controller.error(error instanceof Error ? error : new StreamError(String(error)));
-  });
-  yield* merged;
-}
-async function* takeUntil(stream, predicate, options = {}) {
-  let index = 0;
-  for await (const chunk of stream) {
-    if (options.signal?.aborted === true) {
-      throw new StreamCancelledError("takeUntil aborted");
-    }
-    const shouldStop = await predicate(chunk, index);
-    if (shouldStop) {
-      if (options.inclusive === true) {
-        yield chunk;
-      }
-      return;
-    }
-    yield chunk;
-    index++;
-  }
-}
-async function* filterStream(stream, predicate, options = {}) {
-  let index = 0;
-  for await (const chunk of stream) {
-    if (options.signal?.aborted === true) {
-      throw new StreamCancelledError("filter aborted");
-    }
-    if (await predicate(chunk, index)) {
-      yield chunk;
-    }
-    index++;
-  }
-}
-async function* withTimeout2(stream, timeoutMs, options = {}) {
-  const iterator = stream[Symbol.asyncIterator]();
-  try {
-    let running = true;
-    while (running) {
-      if (options.signal?.aborted === true) {
-        throw new StreamCancelledError("withTimeout aborted");
-      }
-      let timeoutId;
-      try {
-        const result = await Promise.race([
-          iterator.next().then((res) => {
-            if (timeoutId !== void 0) {
-              clearTimeout(timeoutId);
-            }
-            return res;
-          }),
-          new Promise((_, reject) => {
-            timeoutId = setTimeout(() => {
-              reject(
-                new TimeoutError(`Stream timed out after ${String(timeoutMs)}ms`, {
-                  context: { timeoutMs }
-                })
-              );
-            }, timeoutMs);
-          })
-        ]);
-        if (result.done === true) {
-          running = false;
-        } else {
-          yield result.value;
-        }
-      } finally {
-        if (timeoutId !== void 0) {
-          clearTimeout(timeoutId);
-        }
-      }
-    }
-  } finally {
-    if (iterator.return !== void 0) {
-      await iterator.return();
-    }
-  }
-}
-async function* bufferStream(stream, size, options = {}) {
-  if (size <= 0) {
-    throw new StreamError("Buffer size must be positive");
-  }
-  let buffer = [];
-  for await (const chunk of stream) {
-    if (options.signal?.aborted === true) {
-      throw new StreamCancelledError("buffer aborted");
-    }
-    buffer.push(chunk);
-    if (buffer.length >= size) {
-      yield buffer;
-      buffer = [];
-    }
-  }
-  if (buffer.length > 0) {
-    yield buffer;
-  }
-}
-
-// src/adapters/streaming.ts
-var DEFAULT_COLLECT_STREAM_MAX_CHUNKS = 1e5;
-async function collectStream(stream, options = {}) {
-  const chunks = [];
-  const maxChunks = options.maxChunks ?? DEFAULT_COLLECT_STREAM_MAX_CHUNKS;
-  try {
-    for await (const chunk of stream) {
-      if (options.signal?.aborted === true) {
-        return err(new StreamError("Collection aborted"));
-      }
-      chunks.push(chunk);
-      if (chunks.length >= maxChunks) {
-        break;
-      }
-    }
-    return ok(chunks);
-  } catch (error) {
-    if (error instanceof StreamCancelledError) {
-      return err(new StreamError("Stream was cancelled during collection", { cause: error }));
-    }
-    return err(
-      new StreamError("Failed to collect stream", {
-        cause: error instanceof Error ? error : new Error(String(error))
-      })
-    );
-  }
-}
-
 // src/adapters/claude-adapter-types.ts
 var CLAUDE_MODELS = {
   OPUS_4: getCliModelName("claude-opus"),
@@ -4689,12 +4041,27 @@ async function executeWithRetries(opts) {
       logger11.debug("Retrying vote execution", { role, attempt, delayMs, isRateLimit });
       await delay(delayMs);
     }
+    const attemptStart = Date.now();
     const result = await executeSingleVoteAttempt(role, proposal, adapter, timeoutMs);
+    const attemptMs = Date.now() - attemptStart;
     if (result.ok) {
+      logger11.info("Vote attempt timing", {
+        role,
+        attempt: attempt + 1,
+        attemptMs,
+        succeeded: true
+      });
       return { vote: result.vote, ok: true };
     }
     lastError = result.error;
     const rateLimited = isRateLimitError(lastError);
+    logger11.info("Vote attempt timing", {
+      role,
+      attempt: attempt + 1,
+      attemptMs,
+      succeeded: false,
+      rateLimited
+    });
     logger11.warn("Vote attempt failed", {
       role,
       attempt: attempt + 1,
@@ -12875,7 +12242,7 @@ async function processVotesWithCascade(votes, opts) {
 var CONTRARIAN_ESCALATION_THRESHOLD = 0.8;
 async function runContrarianCheck(proposal, log) {
   try {
-    const { executeExpert } = await import("./expert-bridge-75WNNWI4.js");
+    const { executeExpert } = await import("./expert-bridge-DMDHHDEU.js");
     const prompt = [
       "You are a contrarian analyst. Your job is to find reasons this proposal should be REJECTED.",
       "Look for: YAGNI (not needed), MISALIGNED (wrong tech/architecture), SECURITY_RISK, SCOPE_CREEP.",
@@ -13111,29 +12478,6 @@ export {
   messagesToAnthropicFormat,
   extractSystemPrompt,
   extractRequestSystemPrompt,
-  AdapterModelError,
-  isApiKeyMissing,
-  requireApiKey,
-  validateApiKeyPresence,
-  BaseAdapter,
-  StreamError,
-  StreamCancelledError,
-  StreamController,
-  createStream,
-  take,
-  skip,
-  concatStreams,
-  fromArray,
-  tapStream,
-  reduceStream,
-  transformStream,
-  mergeStreams,
-  takeUntil,
-  filterStream,
-  withTimeout2 as withTimeout,
-  bufferStream,
-  DEFAULT_COLLECT_STREAM_MAX_CHUNKS,
-  collectStream,
   CLAUDE_MODELS,
   CLAUDE_MODEL_ALIASES,
   ClaudeAdapter,
@@ -13250,4 +12594,4 @@ export {
   CONSENSUS_VOTE_OUTPUT_SCHEMA,
   registerConsensusVoteTool
 };
-//# sourceMappingURL=chunk-POQQ7A5E.js.map
+//# sourceMappingURL=chunk-53K3KEKT.js.map