@kalenkevich/agent_007 0.0.1

package/src/tools/build_in/view_file.ts

@@ -0,0 +1,47 @@
+import { FunctionalTool } from "../functional_tool.js";
+import { type Schema, Type } from "../schema.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export const VIEW_FILE_TOOL = new FunctionalTool({
+  name: "view_file",
+  description: "Reads the content of a file.",
+  params: {
+    type: Type.OBJECT,
+    properties: {
+      path: {
+        type: Type.STRING,
+        description: "The path to the file to read.",
+      },
+    },
+    required: ["path"],
+  } as Schema,
+  output: {
+    type: Type.OBJECT,
+    properties: {
+      content: {
+        type: Type.STRING,
+        description: "The content of the file",
+      },
+    },
+  } as Schema,
+  execute: async (input: unknown) => {
+    const typedInput = input as { path: string };
+    const filePath = typedInput.path;
+    const resolvedPath = path.resolve(filePath);
+    const cwd = process.cwd();
+
+    if (!resolvedPath.startsWith(cwd)) {
+      throw new Error(
+        `Access denied: Path ${resolvedPath} is outside the project directory.`,
+      );
+    }
+
+    try {
+      const content = await fs.readFile(resolvedPath, "utf-8");
+      return { content };
+    } catch (error: any) {
+      throw new Error(`Failed to read file: ${error.message}`);
+    }
+  },
+});

package/src/tools/build_in/write_file.ts

@@ -0,0 +1,53 @@
+import { FunctionalTool } from "../functional_tool.js";
+import { type Schema, Type } from "../schema.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export const WRITE_FILE_TOOL = new FunctionalTool({
+  name: "write_file",
+  description: "Writes content to a file.",
+  params: {
+    type: Type.OBJECT,
+    properties: {
+      path: {
+        type: Type.STRING,
+        description: "The path to the file to write.",
+      },
+      content: {
+        type: Type.STRING,
+        description: "The content to write to the file.",
+      },
+    },
+    required: ["path", "content"],
+  } as Schema,
+  output: {
+    type: Type.OBJECT,
+    properties: {
+      success: {
+        type: Type.BOOLEAN,
+        description: "Whether the operation was successful",
+      },
+    },
+  } as Schema,
+  execute: async (input: unknown) => {
+    const typedInput = input as { path: string; content: string };
+    const filePath = typedInput.path;
+    const content = typedInput.content;
+    const resolvedPath = path.resolve(filePath);
+    const cwd = process.cwd();
+
+    if (!resolvedPath.startsWith(cwd)) {
+      throw new Error(
+        `Access denied: Path ${resolvedPath} is outside the project directory.`,
+      );
+    }
+
+    try {
+      await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+      await fs.writeFile(resolvedPath, content, "utf-8");
+      return { success: true };
+    } catch (error: any) {
+      throw new Error(`Failed to write file: ${error.message}`);
+    }
+  },
+});

package/src/tools/functional_tool.ts

@@ -0,0 +1,59 @@
+import type {
+  Tool,
+  FunctionDeclaration,
+  ToolInputSchema,
+  ToolOutputSchema,
+  ToolInput,
+  ToolOutput,
+} from "./tool.js";
+import type { Schema } from "./schema.js";
+
+export interface FunctionalToolParams<
+  TInputParameters extends ToolInputSchema = ToolInputSchema,
+  TOutputParameters extends ToolOutputSchema = ToolOutputSchema,
+> {
+  name: string;
+  description: string;
+  params: TInputParameters;
+  output: TOutputParameters;
+  execute: (
+    input: ToolInput<TInputParameters>,
+  ) => Promise<ToolOutput<TOutputParameters>> | ToolOutput<TOutputParameters>;
+}
+
+export class FunctionalTool<
+  TInputParameters extends ToolInputSchema = ToolInputSchema,
+  TOutputParameters extends ToolOutputSchema = ToolOutputSchema,
+> implements Tool<TInputParameters, TOutputParameters> {
+  public readonly name: string;
+  public readonly description: string;
+  public readonly params: TInputParameters;
+  public readonly output: TOutputParameters;
+  private readonly executeFn: (
+    input: ToolInput<TInputParameters>,
+  ) => Promise<ToolOutput<TOutputParameters>> | ToolOutput<TOutputParameters>;
+
+  constructor(
+    params: FunctionalToolParams<TInputParameters, TOutputParameters>,
+  ) {
+    this.name = params.name;
+    this.description = params.description;
+    this.params = params.params;
+    this.output = params.output;
+    this.executeFn = params.execute;
+  }
+
+  async execute(
+    input: ToolInput<TInputParameters>,
+  ): Promise<ToolOutput<TOutputParameters>> {
+    return this.executeFn(input);
+  }
+
+  toFunctionDeclaration(): FunctionDeclaration {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: this.params as unknown as Schema,
+    };
+  }
+}

package/src/tools/schema.ts

@@ -0,0 +1,87 @@
+/** Data type of the schema field. */
+export enum Type {
+  /**
+   * Not specified, should not be used.
+   */
+  TYPE_UNSPECIFIED = "TYPE_UNSPECIFIED",
+  /**
+   * OpenAPI string type
+   */
+  STRING = "STRING",
+  /**
+   * OpenAPI number type
+   */
+  NUMBER = "NUMBER",
+  /**
+   * OpenAPI integer type
+   */
+  INTEGER = "INTEGER",
+  /**
+   * OpenAPI boolean type
+   */
+  BOOLEAN = "BOOLEAN",
+  /**
+   * OpenAPI array type
+   */
+  ARRAY = "ARRAY",
+  /**
+   * OpenAPI object type
+   */
+  OBJECT = "OBJECT",
+  /**
+   * Null type
+   */
+  NULL = "NULL",
+}
+
+/** Schema is used to define the format of input/output data.
+
+ Represents a select subset of an [OpenAPI 3.0 schema
+ object](https://spec.openapis.org/oas/v3.0.3#schema-object). More fields may
+ be added in the future as needed. */
+export interface Schema {
+  /** Optional. The instance must be valid against any (one or more) of the subschemas listed in `any_of`. */
+  anyOf?: Schema[];
+  /** Optional. Default value to use if the field is not specified. */
+  default?: unknown;
+  /** Optional. Describes the data. The model uses this field to understand the purpose of the schema and how to use it. It is a best practice to provide a clear and descriptive explanation for the schema and its properties here, rather than in the prompt. */
+  description?: string;
+  /** Optional. Possible values of the field. This field can be used to restrict a value to a fixed set of values. To mark a field as an enum, set `format` to `enum` and provide the list of possible values in `enum`. For example: 1. To define directions: `{type:STRING, format:enum, enum:["EAST", "NORTH", "SOUTH", "WEST"]}` 2. To define apartment numbers: `{type:INTEGER, format:enum, enum:["101", "201", "301"]}` */
+  enum?: string[];
+  /** Optional. Example of an instance of this schema. */
+  example?: unknown;
+  /** Optional. The format of the data. For `NUMBER` type, format can be `float` or `double`. For `INTEGER` type, format can be `int32` or `int64`. For `STRING` type, format can be `email`, `byte`, `date`, `date-time`, `password`, and other formats to further refine the data type. */
+  format?: string;
+  /** Optional. If type is `ARRAY`, `items` specifies the schema of elements in the array. */
+  items?: Schema;
+  /** Optional. If type is `ARRAY`, `max_items` specifies the maximum number of items in an array. */
+  maxItems?: string;
+  /** Optional. If type is `STRING`, `max_length` specifies the maximum length of the string. */
+  maxLength?: string;
+  /** Optional. If type is `OBJECT`, `max_properties` specifies the maximum number of properties that can be provided. */
+  maxProperties?: string;
+  /** Optional. If type is `INTEGER` or `NUMBER`, `maximum` specifies the maximum allowed value. */
+  maximum?: number;
+  /** Optional. If type is `ARRAY`, `min_items` specifies the minimum number of items in an array. */
+  minItems?: string;
+  /** Optional. If type is `STRING`, `min_length` specifies the minimum length of the string. */
+  minLength?: string;
+  /** Optional. If type is `OBJECT`, `min_properties` specifies the minimum number of properties that can be provided. */
+  minProperties?: string;
+  /** Optional. If type is `INTEGER` or `NUMBER`, `minimum` specifies the minimum allowed value. */
+  minimum?: number;
+  /** Optional. Indicates if the value of this field can be null. */
+  nullable?: boolean;
+  /** Optional. If type is `STRING`, `pattern` specifies a regular expression that the string must match. */
+  pattern?: string;
+  /** Optional. If type is `OBJECT`, `properties` is a map of property names to schema definitions for each property of the object. */
+  properties?: Record<string, Schema>;
+  /** Optional. Order of properties displayed or used where order matters. This is not a standard field in OpenAPI specification, but can be used to control the order of properties. */
+  propertyOrdering?: string[];
+  /** Optional. If type is `OBJECT`, `required` lists the names of properties that must be present. */
+  required?: string[];
+  /** Optional. Title for the schema. */
+  title?: string;
+  /** Optional. Data type of the schema field. */
+  type?: Type;
+}

package/src/tools/tool.ts

@@ -0,0 +1,68 @@
+import { z as z3 } from "zod/v3";
+import { z as z4 } from "zod/v4";
+import type { Schema } from "./schema.js";
+
+export enum Behavior {
+  UNSPECIFIED = "UNSPECIFIED",
+  BLOCKING = "BLOCKING",
+  NON_BLOCKING = "NON_BLOCKING",
+}
+
+export interface FunctionDeclaration {
+  description?: string;
+  name?: string;
+  parameters?: Schema;
+  parametersJsonSchema?: unknown;
+  response?: Schema;
+  responseJsonSchema?: unknown;
+  behavior?: Behavior;
+}
+
+export type ToolInputSchema =
+  | z3.ZodObject<z3.ZodRawShape>
+  | z4.ZodObject<z4.ZodRawShape>
+  | Schema
+  | undefined;
+
+export type ToolOutputSchema =
+  | z3.ZodObject<z3.ZodRawShape>
+  | z4.ZodObject<z4.ZodRawShape>
+  | Schema
+  | undefined;
+
+export type ToolInput<TParameters extends ToolInputSchema> =
+  TParameters extends z3.ZodObject<infer T, infer U, infer V>
+    ? z3.infer<z3.ZodObject<T, U, V>>
+    : TParameters extends z4.ZodObject<infer T>
+      ? z4.infer<z4.ZodObject<T>>
+      : TParameters extends Schema
+        ? unknown
+        : string;
+
+export type ToolOutput<TOutputParameters extends ToolOutputSchema> =
+  TOutputParameters extends z3.ZodObject<infer T, infer U, infer V>
+    ? z3.infer<z3.ZodObject<T, U, V>>
+    : TOutputParameters extends z4.ZodObject<infer T>
+      ? z4.infer<z4.ZodObject<T>>
+      : TOutputParameters extends Schema
+        ? unknown
+        : string;
+
+export type ToolExecuteFunction<
+  TInputParameters extends ToolInputSchema = ToolInputSchema,
+  TOutputParameters extends ToolOutputSchema = ToolOutputSchema,
+> = (
+  input: ToolInput<TInputParameters>,
+) => Promise<ToolOutput<TOutputParameters>> | ToolOutput<TOutputParameters>;
+
+export interface Tool<
+  TInputParameters extends ToolInputSchema = ToolInputSchema,
+  TOutputParameters extends ToolOutputSchema = ToolOutputSchema,
+> {
+  name: string;
+  description: string;
+  params: ToolInputSchema;
+  output: ToolOutputSchema;
+  execute: ToolExecuteFunction<TInputParameters, TOutputParameters>;
+  toFunctionDeclaration(): FunctionDeclaration;
+}

package/src/tools/tool_call_policy.ts

@@ -0,0 +1,7 @@
+export interface ToolCallPolicy {
+  confirmationRequired: boolean;
+}
+
+export const DEFAULT_POLICY: ToolCallPolicy = {
+  confirmationRequired: true,
+};

package/src/user_input.ts

@@ -0,0 +1,51 @@
+import type { ModelConfig } from "./config/config.js";
+import type { Content, ContentPart } from "./content.js";
+import type { UserInputResponseEvent } from "./agent/agent_event.js";
+
+export type UserCommand = SetModelCommand | PlanCommand;
+
+export enum UserCommandType {
+  SET_MODEL = "set_model",
+  PLAN = "plan",
+}
+
+export interface SetModelCommand {
+  command: UserCommandType.SET_MODEL;
+  modelName: string;
+  config?: ModelConfig;
+}
+
+export interface PlanCommand {
+  command: UserCommandType.PLAN;
+  task: string;
+}
+
+export type UserInput =
+  | string
+  | Content
+  | ContentPart
+  | ContentPart[]
+  | UserCommand
+  | UserInputResponseEvent;
+
+export function isUserCommand(userInput: UserInput): userInput is UserCommand {
+  return (userInput as UserCommand).command !== undefined;
+}
+
+export function toContentParts(
+  userInput: string | Content | ContentPart | ContentPart[],
+): ContentPart[] {
+  if (typeof userInput === "string") {
+    return [{ type: "text", text: userInput }];
+  }
+
+  if (Array.isArray(userInput)) {
+    return userInput;
+  }
+
+  if ("parts" in userInput) {
+    return userInput.parts;
+  }
+
+  return [userInput];
+}

package/tests/integration/util_llm_test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from "vitest";
+import { UtilLlm } from "../../src/model/util_llm.js";
+import { AdaptiveLlmModel } from "../../src/model/adaptive_model.js";
+import { loadConfig } from "../../src/config/config_loader.js";
+import { AgentEventType, type AgentEvent } from "../../src/agent/agent_event.js";
+
+describe("UtilLlm Integration", () => {
+  it("should generate a session title using real model", async () => {
+    const config = await loadConfig();
+    if (!config.models.main.apiKey) {
+      console.warn("Skipping integration test: GEMINI_API_KEY is not set.");
+      return;
+    }
+    const model = new AdaptiveLlmModel(config.models);
+    const utilLlm = new UtilLlm(model);
+
+    const events: AgentEvent[] = [
+      {
+        id: "1",
+        streamId: "s1",
+        timestamp: new Date().toISOString(),
+        role: "user",
+        type: AgentEventType.MESSAGE,
+        parts: [{ type: "text", text: "How do I write a file in Node.js?" }],
+      },
+      {
+        id: "2",
+        streamId: "s1",
+        timestamp: new Date().toISOString(),
+        role: "agent",
+        type: AgentEventType.MESSAGE,
+        parts: [{ type: "text", text: "You can use the `fs` module. For example, `fs.writeFileSync('file.txt', 'content')`." }],
+      },
+    ];
+
+    const title = await utilLlm.generateSessionTitle(events);
+    console.log("Generated Title:", title);
+
+    expect(title).toBeTruthy();
+    expect(title).not.toBe("New Session");
+  }, 30000); // Extend timeout for API call
+});

package/tests/unit/adaptive_model_test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { AdaptiveLlmModel } from "../../src/model/adaptive_model.js";
+import { resolveLlmModel } from "../../src/model/registry.js";
+
+vi.mock("../../src/model/registry.js");
+
+describe("AdaptiveLlmModel", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should use main model on success", async () => {
+    const mockMainModel = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield { text: "hello" };
+      }),
+    };
+    const MockMainClass = vi.fn().mockImplementation(function () {
+      return mockMainModel;
+    });
+
+    vi.mocked(resolveLlmModel).mockReturnValue(MockMainClass as any);
+
+    const model = new AdaptiveLlmModel({
+      main: { modelName: "main-model", apiKey: "key" },
+    });
+
+    const generator = model.run({ prompt: "test" } as any);
+    const results = [];
+    for await (const res of generator) {
+      results.push(res);
+    }
+
+    expect(results).toEqual([{ text: "hello" }]);
+    expect(mockMainModel.run).toHaveBeenCalled();
+  });
+
+  it("should fallback to next model on failure", async () => {
+    const mockMainModel = {
+      run: vi.fn().mockImplementation(async function* () {
+        throw new Error("Main model failed");
+      }),
+    };
+    const mockFallbackModel = {
+      run: vi.fn().mockImplementation(async function* () {
+        yield { text: "fallback success" };
+      }),
+    };
+
+    const MockMainClass = vi.fn().mockImplementation(function () {
+      return mockMainModel;
+    });
+    const MockFallbackClass = vi.fn().mockImplementation(function () {
+      return mockFallbackModel;
+    });
+
+    vi.mocked(resolveLlmModel).mockImplementation((name) => {
+      if (name === "main-model") return MockMainClass as any;
+      if (name === "fallback-model") return MockFallbackClass as any;
+      throw new Error("Unknown model");
+    });
+
+    const model = new AdaptiveLlmModel({
+      main: { modelName: "main-model", apiKey: "key" },
+      fallback: [{ modelName: "fallback-model", apiKey: "key" }],
+    });
+
+    const generator = model.run({ prompt: "test" } as any);
+    const results = [];
+    for await (const res of generator) {
+      results.push(res);
+    }
+
+    expect(results).toEqual([{ text: "fallback success" }]);
+    expect(mockMainModel.run).toHaveBeenCalled();
+    expect(mockFallbackModel.run).toHaveBeenCalled();
+  });
+
+  it("should fail if all models fail", async () => {
+    const mockMainModel = {
+      run: vi.fn().mockImplementation(async function* () {
+        throw new Error("Main model failed");
+      }),
+    };
+    const mockFallbackModel = {
+      run: vi.fn().mockImplementation(async function* () {
+        throw new Error("Fallback model failed");
+      }),
+    };
+
+    const MockMainClass = vi.fn().mockImplementation(function () {
+      return mockMainModel;
+    });
+    const MockFallbackClass = vi.fn().mockImplementation(function () {
+      return mockFallbackModel;
+    });
+
+    vi.mocked(resolveLlmModel).mockImplementation((name) => {
+      if (name === "main-model") return MockMainClass as any;
+      if (name === "fallback-model") return MockFallbackClass as any;
+      throw new Error("Unknown model");
+    });
+
+    const model = new AdaptiveLlmModel({
+      main: { modelName: "main-model", apiKey: "key" },
+      fallback: [{ modelName: "fallback-model", apiKey: "key" }],
+    });
+
+    const generator = model.run({ prompt: "test" } as any);
+    const results = [];
+    for await (const res of generator) {
+      results.push(res);
+    }
+
+    expect(results).toEqual([
+      {
+        errorCode: "ADAPTIVE_MODEL_ALL_FALLBACKS_FAILED",
+        errorMessage: "All fallback models failed.",
+      },
+    ]);
+  });
+});

package/tests/unit/agent/request_processor/compaction_processor_test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { CompactionProcessor } from "../../../../src/agent/request_processor/compaction_processor.js";
+import { AgentEventType } from "../../../../src/agent/agent_event.js";
+
+describe("CompactionProcessor", () => {
+  const mockModel = {
+    countTokens: vi.fn().mockResolvedValue(100),
+    run: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should do nothing if disabled", async () => {
+    const processor = new CompactionProcessor({
+      model: mockModel as any,
+      compactionConfig: {
+        enabled: false,
+        strategy: "truncate",
+        maxTokens: 1000,
+      },
+      requestBuilderOptions: {} as any,
+      streamId: "123",
+    });
+
+    const state = {
+      historyContent: [
+        {
+          role: "user" as const,
+          parts: [{ type: "text" as const, text: "hi" }],
+        },
+      ],
+      llmRequest: {} as any,
+      events: [],
+    };
+
+    const newState = await processor.process(state);
+    expect(newState).toBe(state);
+  });
+
+  it("should do nothing if below threshold", async () => {
+    const processor = new CompactionProcessor({
+      model: mockModel as any,
+      compactionConfig: {
+        enabled: true,
+        strategy: "truncate",
+        maxTokens: 1000,
+        triggerThreshold: 0.8,
+      },
+      requestBuilderOptions: {} as any,
+      streamId: "123",
+    });
+
+    const state = {
+      historyContent: [
+        {
+          role: "user" as const,
+          parts: [{ type: "text" as const, text: "hi" }],
+        },
+      ],
+      llmRequest: {} as any,
+      events: [],
+    };
+
+    mockModel.countTokens.mockResolvedValue(500); // 500 < 800
+
+    const newState = await processor.process(state);
+    expect(newState).toBe(state);
+  });
+
+  it("should truncate history when exceeded", async () => {
+    const processor = new CompactionProcessor({
+      model: mockModel as any,
+      compactionConfig: {
+        enabled: true,
+        strategy: "truncate",
+        maxTokens: 1000,
+        triggerThreshold: 0.8,
+      },
+      requestBuilderOptions: {
+        agentName: "test",
+        instructions: "test",
+        tools: [],
+      } as any,
+      streamId: "123",
+    });
+
+    const state = {
+      historyContent: [
+        {
+          role: "user" as const,
+          parts: [{ type: "text" as const, text: "m1" }],
+        },
+        {
+          role: "agent" as const,
+          parts: [{ type: "text" as const, text: "r1" }],
+        },
+        {
+          role: "user" as const,
+          parts: [{ type: "text" as const, text: "m2" }],
+        },
+        {
+          role: "agent" as const,
+          parts: [{ type: "text" as const, text: "r2" }],
+        },
+      ],
+      llmRequest: { contents: [] } as any,
+      events: [],
+    };
+
+    mockModel.countTokens.mockResolvedValue(900); // 900 > 800
+
+    const newState = await processor.process(state);
+    expect(newState.historyContent.length).toBeLessThan(
+      state.historyContent.length,
+    );
+    expect(newState.events.length).toBe(1);
+    expect(newState.events[0].type).toBe(AgentEventType.COMPACTION);
+  });
+});