nexus-agents 2.70.1 → 2.72.0

package/dist/chunk-5MHIWRKB.js

@@ -0,0 +1,691 @@
+import {
+  ConfigError,
+  ErrorCode,
+  ModelError,
+  NexusError,
+  TimeoutError,
+  createLogger,
+  err,
+  getErrorMessage,
+  getTokenEstimator,
+  isRateLimitLikeError,
+  ok
+} from "./chunk-O4KUCF5S.js";
+
+// 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* withTimeout(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))
+      })
+    );
+  }
+}
+
+export {
+  AdapterModelError,
+  requireApiKey,
+  validateApiKeyPresence,
+  BaseAdapter,
+  StreamError,
+  StreamCancelledError,
+  StreamController,
+  createStream,
+  take,
+  skip,
+  concatStreams,
+  fromArray,
+  tapStream,
+  reduceStream,
+  transformStream,
+  mergeStreams,
+  takeUntil,
+  filterStream,
+  withTimeout,
+  bufferStream,
+  DEFAULT_COLLECT_STREAM_MAX_CHUNKS,
+  collectStream
+};
+//# sourceMappingURL=chunk-5MHIWRKB.js.map