@kalenkevich/agent_007 0.0.1

package/src/logger.ts

@@ -0,0 +1,128 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as util from "util";
+
+export interface LogTransport {
+  enabled: boolean;
+  log(level: string, formattedMessage: string, args: any[]): void;
+}
+
+export class ConsoleTransport implements LogTransport {
+  enabled: boolean;
+
+  constructor(enabled: boolean) {
+    this.enabled = enabled;
+  }
+
+  log(level: string, formattedMessage: string, args: any[]) {
+    if (!this.enabled) {
+      return;
+    }
+
+    switch (level) {
+      case "DEBUG":
+        console.debug(...args);
+        break;
+      case "INFO":
+        console.info(...args);
+        break;
+      case "WARN":
+        console.warn(...args);
+        break;
+      case "ERROR":
+        console.error(...args);
+        break;
+      case "LOG":
+      default:
+        console.log(...args);
+    }
+  }
+}
+
+export class FileTransport implements LogTransport {
+  enabled: boolean = true;
+
+  constructor(
+    enabled: boolean,
+    private logFile: string,
+  ) {
+    this.enabled = enabled;
+  }
+
+  log(level: string, formattedMessage: string, args: any[]) {
+    if (!this.enabled) {
+      return;
+    }
+
+    try {
+      fs.appendFileSync(this.logFile, `[${level}] ${formattedMessage}\n`);
+    } catch (err) {
+      console.error("Failed to write to log file:", err);
+    }
+  }
+}
+
+export class Logger {
+  private transports: LogTransport[] = [];
+
+  constructor(transports?: LogTransport[]) {
+    if (transports) {
+      this.transports = transports;
+    }
+  }
+
+
+  getTransports(): LogTransport[] {
+    if (this.transports.length) {
+      return this.transports;
+    }
+
+    if (process.env.DEBUG_LOGGER) {
+      const logFile = path.join(process.cwd(), "debug.log");
+
+      return [
+        new ConsoleTransport(process.env.DEBUG_LOGGER_CONSOLE === "true"),
+        new FileTransport(process.env.DEBUG_LOGGER === "true", logFile),
+      ];
+    }
+
+    return [];
+  }
+
+  private formatMessage(level: string, ...args: any[]): string {
+    const timestamp = new Date().toISOString();
+    const message = args
+      .map((arg) =>
+        typeof arg === "string" ? arg : util.inspect(arg, { depth: null }),
+      )
+      .join(" ");
+    return `[${timestamp}] [${level}] ${message}`;
+  }
+
+  log(...args: any[]) {
+    const formatted = this.formatMessage("LOG", ...args);
+    this.getTransports().forEach((t) => t.log("LOG", formatted, args));
+  }
+
+  debug(...args: any[]) {
+    const formatted = this.formatMessage("DEBUG", ...args);
+    this.getTransports().forEach((t) => t.log("DEBUG", formatted, args));
+  }
+
+  info(...args: any[]) {
+    const formatted = this.formatMessage("INFO", ...args);
+    this.getTransports().forEach((t) => t.log("INFO", formatted, args));
+  }
+
+  warn(...args: any[]) {
+    const formatted = this.formatMessage("WARN", ...args);
+    this.getTransports().forEach((t) => t.log("WARN", formatted, args));
+  }
+
+  error(...args: any[]) {
+    const formatted = this.formatMessage("ERROR", ...args);
+    this.getTransports().forEach((t) => t.log("ERROR", formatted, args));
+  }
+}
+
+export const logger = new Logger();

package/src/model/adaptive_model.ts

@@ -0,0 +1,77 @@
+import type { LlmModel, LlmModelConfig } from "./model.js";
+import type { LlmRequest } from "./request.js";
+import type { LlmResponse } from "./response.js";
+import type { ModelConfig } from "../config/config.js";
+import { resolveLlmModel } from "./registry.js";
+import { logger } from "../logger.js";
+
+export class AdaptiveLlmModel implements LlmModel {
+  private currentModel!: LlmModel;
+  private fallbackConfigs?: ModelConfig[];
+  readonly modelName: string = "adaptive";
+
+  constructor(config: { main: ModelConfig; fallback?: ModelConfig[] }) {
+    this.setModel(config.main);
+    this.fallbackConfigs = config.fallback;
+  }
+
+  setModel(modelConfig: ModelConfig) {
+    const ModelClass = resolveLlmModel(modelConfig.modelName);
+    this.currentModel = new ModelClass(modelConfig);
+  }
+
+  async *run(
+    request: LlmRequest,
+    config?: LlmModelConfig,
+  ): AsyncGenerator<LlmResponse, void, unknown> {
+    if (!this.currentModel) {
+      throw new Error("Model not initialized");
+    }
+
+    try {
+      yield* this.currentModel.run(request, config);
+    } catch (e: unknown) {
+      logger.error("[AdaptiveLlmModel] error:", e);
+
+      if (this.fallbackConfigs && this.fallbackConfigs.length > 0) {
+        for (const fallbackConfig of this.fallbackConfigs) {
+          logger.info(
+            `[AdaptiveLlmModel] Attempting fallback to ${fallbackConfig.modelName}`,
+          );
+          try {
+            const FallbackModelClass = resolveLlmModel(
+              fallbackConfig.modelName,
+            );
+
+            this.currentModel = new FallbackModelClass(fallbackConfig);
+            yield* this.currentModel.run(request, config);
+            return; // Success, exit the generator
+          } catch (fallbackError: unknown) {
+            logger.error(
+              `[AdaptiveLlmModel] fallback to ${fallbackConfig.modelName} failed:`,
+              fallbackError,
+            );
+            // Continue loop to try next fallback
+          }
+        }
+        // If all fallbacks failed
+        yield {
+          errorCode: "ADAPTIVE_MODEL_ALL_FALLBACKS_FAILED",
+          errorMessage: "All fallback models failed.",
+        };
+      } else {
+        yield {
+          errorCode: "ADAPTIVE_MODEL_ERROR",
+          errorMessage: e instanceof Error ? e.message : String(e),
+        };
+      }
+    }
+  }
+
+  async countTokens(request: LlmRequest): Promise<number> {
+    if (!this.currentModel) {
+      throw new Error("Model not initialized");
+    }
+    return this.currentModel.countTokens(request);
+  }
+}

package/src/model/google/gemini_model.ts

@@ -0,0 +1,194 @@
+import {
+  GoogleGenAI,
+  type GenerateContentParameters,
+  ThinkingLevel,
+} from "@google/genai";
+import type { LlmRequest } from "../request.js";
+import type { LlmResponse } from "../response.js";
+import type { ModelConfig } from "../../config/config.js";
+import { contentToGenAIContent } from "./gen_ai_convert_utils.js";
+import { StreamingResponseAggregator } from "./gemini_streaming_utils.js";
+import { createLlmResponse } from "./gemini_response_utils.js";
+import { logger } from "../../logger.js";
+
+export interface RunConfig {
+  stream?: boolean;
+  abortSignal?: AbortSignal;
+}
+
+export class Gemini {
+  public readonly modelName: string;
+  private readonly client: GoogleGenAI;
+
+  constructor(config: ModelConfig) {
+    this.modelName = config.modelName;
+    this.client = new GoogleGenAI(config);
+  }
+
+  async *run(
+    request: LlmRequest,
+    config?: RunConfig,
+  ): AsyncGenerator<LlmResponse, void, unknown> {
+    logger.debug(
+      "[Gemini Model] Running model with request:",
+      JSON.stringify(request, null, 2),
+    );
+
+    if (config?.stream) {
+      yield* this.runStream(request, config);
+      return;
+    }
+
+    try {
+      const response = await this.client.models.generateContent(
+        toGenAiRequest({
+          model: this.modelName,
+          request,
+          config,
+        }),
+      );
+
+      logger.debug(
+        "[Gemini Model] response received:",
+        JSON.stringify(response, null, 2),
+      );
+
+      yield createLlmResponse(response);
+    } catch (e: unknown) {
+      logger.error("[Gemini Model] error:", e);
+      yield {
+        errorCode: "GEMINI_ERROR",
+        errorMessage: extractErrorMessage(e),
+      };
+    }
+  }
+
+  async countTokens(request: LlmRequest): Promise<number> {
+    const response = await this.client.models.countTokens({
+      model: this.modelName,
+      contents: request.contents.map((c) => contentToGenAIContent(c)),
+      config: {
+        tools: request.tools
+          ? [{ functionDeclarations: request.tools }]
+          : undefined,
+        systemInstruction: request.systemInstructions,
+      },
+    });
+
+    logger.debug("[Gemini Model] token count:", response.totalTokens);
+
+    return response.totalTokens || 0;
+  }
+
+  private async *runStream(
+    request: LlmRequest,
+    config?: RunConfig,
+  ): AsyncGenerator<LlmResponse, void, unknown> {
+    try {
+      const aggregator = new StreamingResponseAggregator();
+      const stream = await this.client.models.generateContentStream(
+        toGenAiRequest({
+          model: this.modelName,
+          request,
+          config,
+        }),
+      );
+
+      for await (const response of stream) {
+        for await (const llmResponse of aggregator.processResponse(response)) {
+          logger.debug(
+            "[Gemini Model] yielding streaming response",
+            JSON.stringify(llmResponse, null, 2),
+          );
+
+          yield llmResponse;
+        }
+      }
+
+      const finalResponse = aggregator.close();
+      if (finalResponse) {
+        logger.debug(
+          "[Gemini Model] yielding final streaming response",
+          JSON.stringify(finalResponse, null, 2),
+        );
+
+        yield finalResponse;
+      }
+    } catch (e: unknown) {
+      logger.error("[Gemini Model] stream error:", e);
+      yield {
+        errorCode: "GEMINI_STREAM_ERROR",
+        errorMessage: extractErrorMessage(e),
+      };
+    }
+
+    logger.debug("[Gemini Model] stream finished");
+  }
+}
+
+interface ToGenAiRequestConfig {
+  model: string;
+  request: LlmRequest;
+  config?: RunConfig;
+}
+function toGenAiRequest({
+  model,
+  request,
+  config = {},
+}: ToGenAiRequestConfig): GenerateContentParameters {
+  return {
+    model,
+    contents: request.contents.map((c) => contentToGenAIContent(c)),
+    config: {
+      ...(config || {}),
+      tools: request.tools
+        ? [{ functionDeclarations: request.tools }]
+        : undefined,
+      thinkingConfig: request.thinkingConfig?.enabled ? {
+        includeThoughts: request.thinkingConfig.enabled,
+        thinkingLevel: toThinkingLevelConfig(
+          request.thinkingConfig.level || "auto",
+        ),
+      } : undefined,
+      systemInstruction: request.systemInstructions,
+    },
+  };
+}
+
+function extractErrorMessage(e: unknown): string {
+  if (e instanceof Error) {
+    try {
+      const parsed = JSON.parse(e.message);
+      if (parsed.error && parsed.error.message) {
+        try {
+          const innerParsed = JSON.parse(parsed.error.message);
+          if (innerParsed.error && innerParsed.error.message) {
+            return innerParsed.error.message;
+          }
+        } catch {
+          return parsed.error.message;
+        }
+        return parsed.error.message;
+      }
+    } catch {
+      return e.message;
+    }
+    return e.message;
+  }
+  return String(e);
+}
+
+function toThinkingLevelConfig(
+  thinkingLevel: "low" | "medium" | "high" | "auto",
+): ThinkingLevel {
+  switch (thinkingLevel) {
+    case "low":
+      return ThinkingLevel.LOW;
+    case "medium":
+      return ThinkingLevel.MEDIUM;
+    case "high":
+      return ThinkingLevel.HIGH;
+    case "auto":
+      return ThinkingLevel.HIGH;
+  }
+}

package/src/model/google/gemini_response_utils.ts

@@ -0,0 +1,46 @@
+import { GenerateContentResponse, FinishReason } from "@google/genai";
+import type { LlmResponse } from "../response.js";
+import { genAIContentToContent } from "./gen_ai_convert_utils.js";
+
+export function createLlmResponse(
+  response: GenerateContentResponse,
+): LlmResponse {
+  const candidate = response.candidates?.[0];
+
+  const llmResponse: LlmResponse = {};
+
+  if (response.usageMetadata) {
+    llmResponse.usageMetadata = {
+      inputTokens: response.usageMetadata.promptTokenCount,
+      outputTokens: response.usageMetadata.candidatesTokenCount,
+      cachedTokens: response.usageMetadata.cachedContentTokenCount,
+    };
+  }
+
+  if (candidate) {
+    if (candidate.content) {
+      llmResponse.content = genAIContentToContent(candidate.content);
+    }
+
+    if (candidate.finishReason) {
+      llmResponse.finishReason = candidate.finishReason;
+
+      if (candidate.finishReason !== FinishReason.STOP) {
+        llmResponse.errorCode = candidate.finishReason;
+        llmResponse.errorMessage = (candidate as any).finishMessage;
+      }
+    }
+  }
+
+  if (candidate) {
+    const cand = candidate as any;
+    if (cand.groundingMetadata) {
+      (llmResponse as any).groundingMetadata = cand.groundingMetadata;
+    }
+    if (cand.citationMetadata) {
+      (llmResponse as any).citationMetadata = cand.citationMetadata;
+    }
+  }
+
+  return llmResponse;
+}