@iinm/plain-agent 1.8.3 → 1.8.4

package/src/tools/askURL.mjs

@@ -1,209 +0,0 @@
-/**
- * @import { Tool } from '../tool'
- */
-
-import { styleText } from "node:util";
-import { getGoogleCloudAccessToken } from "../providers/platform/googleCloud.mjs";
-import { noThrow } from "../utils/noThrow.mjs";
-
-/** @typedef {AskURLToolGeminiOptions | AskURLToolGeminiVertexAIOptions} AskURLToolOptions */
-
-/**
- * @typedef {Object} AskURLToolGeminiOptions
- * @property {"gemini"} provider
- * @property {string=} baseURL
- * @property {string} apiKey
- * @property {string} model
- */
-
-/**
- * @typedef {Object} AskURLToolGeminiVertexAIOptions
- * @property {"gemini-vertex-ai"} provider
- * @property {string} baseURL
- * @property {string=} account
- * @property {string} model
- */
-
-/**
- * @typedef {Object} AskURLInput
- * @property {string} question
- */
-
-/**
- * @param {AskURLToolOptions} config
- * @returns {Tool}
- */
-export function createAskURLTool(config) {
-  /**
-   * @param {AskURLInput} input
-   * @param {number} retryCount
-   * @returns {Promise<string | Error>}
-   */
-  async function askURL(input, retryCount = 0) {
-    const model = config.model ?? "gemini-3-flash-preview";
-    const url =
-      config.provider === "gemini-vertex-ai"
-        ? `${config.baseURL}/publishers/google/models/${config.model}:generateContent`
-        : config.baseURL
-          ? `${config.baseURL}/models/${model}:generateContent`
-          : `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
-
-    /** @type {Record<string,string>} */
-    const authHeader =
-      config.provider === "gemini-vertex-ai"
-        ? {
-            Authorization: `Bearer ${await getGoogleCloudAccessToken(config.account)}`,
-          }
-        : {
-            "x-goog-api-key": config.apiKey ?? "",
-          };
-
-    const data = {
-      contents: [
-        {
-          role: "user",
-          parts: [
-            {
-              text: `I need a comprehensive answer to this question. Please note that I don't have access to external URLs, so include all relevant facts, data, or explanations directly in your response. Avoid referencing links I can't open.
-
-Question: ${input.question}`,
-            },
-          ],
-        },
-      ],
-      tools: [
-        {
-          url_context: {},
-        },
-      ],
-    };
-
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        ...authHeader,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(data),
-      signal: AbortSignal.timeout(120 * 1000),
-    });
-
-    if (response.status === 429 || response.status >= 500) {
-      const interval = Math.min(2 * 2 ** retryCount, 16);
-      console.error(
-        styleText(
-          "yellow",
-          `Google API returned ${response.status}. Retrying in ${interval} seconds...`,
-        ),
-      );
-      await new Promise((resolve) => setTimeout(resolve, interval * 1000));
-      return askURL(input, retryCount + 1);
-    }
-
-    if (!response.ok) {
-      return new Error(
-        `Failed to ask Web: status=${response.status}, body=${await response.text()}`,
-      );
-    }
-
-    const body = await response.json();
-
-    const candidate = body.candidates?.[0];
-    const text = candidate?.content?.parts?.[0]?.text;
-    /** @type {{segment?:{startIndex:number,endIndex:number,text:string},groundingChunkIndices?:number[]}[] | undefined} */
-    const supports = candidate?.groundingMetadata?.groundingSupports;
-    /** @type {{web?:{uri:string,title:string}}[] | undefined} */
-    const chunks = candidate?.groundingMetadata?.groundingChunks;
-
-    if (typeof text !== "string") {
-      return new Error(
-        `Unexpected response format from Google: ${JSON.stringify(body)}`,
-      );
-    }
-
-    /**
-     * @param {string} source
-     * @param {number} byteIndex
-     * @param {string} insertText
-     */
-    const insertTextAtUtf8ByteIndex = (source, byteIndex, insertText) => {
-      const sourceBuffer = Buffer.from(source, "utf8");
-      const normalizedByteIndex = Math.max(
-        0,
-        Math.min(byteIndex, sourceBuffer.length),
-      );
-
-      return Buffer.concat([
-        sourceBuffer.subarray(0, normalizedByteIndex),
-        Buffer.from(insertText, "utf8"),
-        sourceBuffer.subarray(normalizedByteIndex),
-      ]).toString("utf8");
-    };
-
-    // Sort by end_index desc because Gemini grounding indexes are byte offsets
-    // into the original UTF-8 text.
-    const sortedSupports = supports?.toSorted(
-      (a, b) => (b.segment?.endIndex ?? 0) - (a.segment?.endIndex ?? 0),
-    );
-
-    // Insert citations using UTF-8 byte offsets.
-    let textWithCitations = text;
-    for (const support of sortedSupports ?? []) {
-      const endIndex = support.segment?.endIndex;
-      if (
-        typeof endIndex !== "number" ||
-        !support.groundingChunkIndices?.length
-      ) {
-        continue;
-      }
-
-      textWithCitations = insertTextAtUtf8ByteIndex(
-        textWithCitations,
-        endIndex,
-        ` [${support.groundingChunkIndices.map((i) => i + 1).join(", ")}] `,
-      );
-    }
-
-    const chunkString = (chunks ?? [])
-      .map(
-        (chunk, index) =>
-          `- [${index + 1} - ${chunk.web?.title}](${chunk.web?.uri})`,
-      )
-      .join("\n");
-
-    return [textWithCitations, chunkString].join("\n\n");
-  }
-
-  return {
-    def: {
-      name: "ask_url",
-      description:
-        "Use one or more provided URLs to answer a question. Include the URLs in your question.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          question: {
-            type: "string",
-            description:
-              "The question to ask, including one or more URLs to use as context.",
-          },
-        },
-        required: ["question"],
-      },
-    },
-
-    /**
-     * @param {AskURLInput} input
-     * @returns {Promise<string | Error>}
-     */
-    impl: async (input) => await noThrow(async () => askURL(input, 0)),
-
-    /**
-     * @param {Record<string, unknown>} _input
-     * @returns {Record<string, unknown>}
-     */
-    maskApprovalInput: (_input) => {
-      return {};
-    },
-  };
-}

package/src/tools/askWeb.mjs

@@ -1,208 +0,0 @@
-/**
- * @import { Tool } from '../tool'
- */
-
-import { styleText } from "node:util";
-import { getGoogleCloudAccessToken } from "../providers/platform/googleCloud.mjs";
-import { noThrow } from "../utils/noThrow.mjs";
-
-/** @typedef {AskWebToolGeminiOptions | AskWebToolGeminiVertexAIOptions} AskWebToolOptions */
-
-/**
- * @typedef {Object} AskWebToolGeminiOptions
- * @property {"gemini"} provider
- * @property {string=} baseURL
- * @property {string} apiKey
- * @property {string} model
- */
-
-/**
- * @typedef {Object} AskWebToolGeminiVertexAIOptions
- * @property {"gemini-vertex-ai"} provider
- * @property {string} baseURL
- * @property {string=} account
- * @property {string} model
- */
-
-/**
- * @typedef {Object} AskWebInput
- * @property {string} question
- */
-
-/**
- * @param {AskWebToolOptions} config
- * @returns {Tool}
- */
-export function createAskWebTool(config) {
-  /**
-   * @param {AskWebInput} input
-   * @param {number} retryCount
-   * @returns {Promise<string | Error>}
-   */
-  async function askWeb(input, retryCount = 0) {
-    const model = config.model ?? "gemini-3-flash-preview";
-    const url =
-      config.provider === "gemini-vertex-ai"
-        ? `${config.baseURL}/publishers/google/models/${config.model}:generateContent`
-        : config.baseURL
-          ? `${config.baseURL}/models/${model}:generateContent`
-          : `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
-
-    /** @type {Record<string,string>} */
-    const authHeader =
-      config.provider === "gemini-vertex-ai"
-        ? {
-            Authorization: `Bearer ${await getGoogleCloudAccessToken(config.account)}`,
-          }
-        : {
-            "x-goog-api-key": config.apiKey ?? "",
-          };
-
-    const data = {
-      contents: [
-        {
-          role: "user",
-          parts: [
-            {
-              text: `I need a comprehensive answer to this question. Please note that I don't have access to external URLs, so include all relevant facts, data, or explanations directly in your response. Avoid referencing links I can't open.
-
-Question: ${input.question}`,
-            },
-          ],
-        },
-      ],
-      tools: [
-        {
-          google_search: {},
-        },
-      ],
-    };
-
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        ...authHeader,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(data),
-      signal: AbortSignal.timeout(120 * 1000),
-    });
-
-    if (response.status === 429 || response.status >= 500) {
-      const interval = Math.min(2 * 2 ** retryCount, 16);
-      console.error(
-        styleText(
-          "yellow",
-          `Google API returned ${response.status}. Retrying in ${interval} seconds...`,
-        ),
-      );
-      await new Promise((resolve) => setTimeout(resolve, interval * 1000));
-      return askWeb(input, retryCount + 1);
-    }
-
-    if (!response.ok) {
-      return new Error(
-        `Failed to ask Web: status=${response.status}, body=${await response.text()}`,
-      );
-    }
-
-    const body = await response.json();
-
-    const candidate = body.candidates?.[0];
-    const text = candidate?.content?.parts?.[0]?.text;
-    /** @type {{segment?:{startIndex:number,endIndex:number,text:string},groundingChunkIndices?:number[]}[] | undefined} */
-    const supports = candidate?.groundingMetadata?.groundingSupports;
-    /** @type {{web?:{uri:string,title:string}}[] | undefined} */
-    const chunks = candidate?.groundingMetadata?.groundingChunks;
-
-    if (typeof text !== "string") {
-      return new Error(
-        `Unexpected response format from Google: ${JSON.stringify(body)}`,
-      );
-    }
-
-    /**
-     * @param {string} source
-     * @param {number} byteIndex
-     * @param {string} insertText
-     */
-    const insertTextAtUtf8ByteIndex = (source, byteIndex, insertText) => {
-      const sourceBuffer = Buffer.from(source, "utf8");
-      const normalizedByteIndex = Math.max(
-        0,
-        Math.min(byteIndex, sourceBuffer.length),
-      );
-
-      return Buffer.concat([
-        sourceBuffer.subarray(0, normalizedByteIndex),
-        Buffer.from(insertText, "utf8"),
-        sourceBuffer.subarray(normalizedByteIndex),
-      ]).toString("utf8");
-    };
-
-    // Sort by end_index desc because Gemini grounding indexes are byte offsets
-    // into the original UTF-8 text.
-    const sortedSupports = supports?.toSorted(
-      (a, b) => (b.segment?.endIndex ?? 0) - (a.segment?.endIndex ?? 0),
-    );
-
-    // Insert citations using UTF-8 byte offsets.
-    let textWithCitations = text;
-    for (const support of sortedSupports ?? []) {
-      const endIndex = support.segment?.endIndex;
-      if (
-        typeof endIndex !== "number" ||
-        !support.groundingChunkIndices?.length
-      ) {
-        continue;
-      }
-
-      textWithCitations = insertTextAtUtf8ByteIndex(
-        textWithCitations,
-        endIndex,
-        ` [${support.groundingChunkIndices.map((i) => i + 1).join(", ")}] `,
-      );
-    }
-
-    const chunkString = (chunks ?? [])
-      .map(
-        (chunk, index) =>
-          `- [${index + 1} - ${chunk.web?.title}](${chunk.web?.uri})`,
-      )
-      .join("\n");
-
-    return [textWithCitations, chunkString].join("\n\n");
-  }
-
-  return {
-    def: {
-      name: "ask_web",
-      description:
-        "Use the web search to answer questions that need up-to-date information or supporting sources.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          question: {
-            type: "string",
-            description: "The question to ask",
-          },
-        },
-        required: ["question"],
-      },
-    },
-
-    /**
-     * @param {AskWebInput} input
-     * @returns {Promise<string | Error>}
-     */
-    impl: async (input) => await noThrow(async () => askWeb(input, 0)),
-
-    /**
-     * @param {Record<string, unknown>} _input
-     * @returns {Record<string, unknown>}
-     */
-    maskApprovalInput: (_input) => {
-      return {};
-    },
-  };
-}

package/src/tools/compactContext.d.ts

@@ -1,4 +0,0 @@
-export type CompactContextInput = {
-  memoryPath: string;
-  reason: string;
-};

package/src/tools/compactContext.mjs

@@ -1,87 +0,0 @@
-/**
- * @import { Tool, ToolImplementation } from '../tool'
- * @import { CompactContextInput } from './compactContext'
- */
-
-import fs from "node:fs/promises";
-import path from "node:path";
-import { AGENT_MEMORY_DIR } from "../env.mjs";
-import { noThrow } from "../utils/noThrow.mjs";
-
-export const compactContextToolName = "compact_context";
-
-/** @returns {Tool} */
-export function createCompactContextTool() {
-  /** @type {ToolImplementation} */
-  let impl = async () => {
-    throw new Error("Not implemented");
-  };
-
-  /** @type {Tool} */
-  const tool = {
-    def: {
-      name: compactContextToolName,
-      description:
-        "Discard prior messages and reload task state from a memory file.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          memoryPath: {
-            type: "string",
-            description: `Path to the memory file under ${AGENT_MEMORY_DIR}/.`,
-          },
-          reason: {
-            type: "string",
-            description: "The reason for compacting the context.",
-          },
-        },
-        required: ["memoryPath", "reason"],
-      },
-    },
-
-    // Implementation is injected by the agent so it can access subagent
-    // state (compact_context is not allowed during subagent execution).
-    get impl() {
-      return impl;
-    },
-
-    injectImpl(fn) {
-      impl = fn;
-    },
-  };
-
-  return tool;
-}
-
-/**
- * Read a memory file and return the compact_context tool result string.
- * Validates that the memoryPath is within the project memory directory.
- * @param {CompactContextInput} input
- * @returns {Promise<string | Error>}
- */
-export async function readMemoryForCompaction(input) {
-  return await noThrow(async () => {
-    const absolutePath = path.resolve(input.memoryPath);
-    const memoryDir = path.resolve(AGENT_MEMORY_DIR);
-    const relativePath = path.relative(memoryDir, absolutePath);
-    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
-      return new Error(
-        `Access denied: memoryPath must be within ${AGENT_MEMORY_DIR}`,
-      );
-    }
-
-    const memoryContent = await fs.readFile(absolutePath, {
-      encoding: "utf-8",
-    });
-
-    return [
-      "Context compacted. Prior conversation has been discarded.",
-      `Reason: ${input.reason}`,
-      `Memory file: ${input.memoryPath}`,
-      "",
-      "Resume the task using the memory file contents below.",
-      "",
-      memoryContent,
-    ].join("\n");
-  });
-}

package/src/tools/delegateToSubagent.d.ts

@@ -1,4 +0,0 @@
-export type DelegateToSubagentInput = {
-  name: string;
-  goal: string;
-};

package/src/tools/delegateToSubagent.mjs

@@ -1,48 +0,0 @@
-/**
- * @import { Tool, ToolImplementation } from '../tool'
- */
-
-export const delegateToSubagentToolName = "delegate_to_subagent";
-
-/** @returns {Tool} */
-export function createDelegateToSubagentTool() {
-  /** @type {ToolImplementation} */
-  let impl = async () => {
-    throw new Error("Not implemented");
-  };
-
-  /** @type {Tool} */
-  const tool = {
-    def: {
-      name: delegateToSubagentToolName,
-      description:
-        "Delegate a subtask to a subagent. You inherit the current context and work on the delegated goal.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          name: {
-            type: "string",
-            description:
-              "Role or name of the subagent. Use 'custom:' prefix for ad-hoc roles.",
-          },
-          goal: {
-            type: "string",
-            description: "The goal or task for the subagent to achieve.",
-          },
-        },
-        required: ["name", "goal"],
-      },
-    },
-
-    // Implementation will be injected by the agent to access its state
-    get impl() {
-      return impl;
-    },
-
-    injectImpl(fn) {
-      impl = fn;
-    },
-  };
-
-  return tool;
-}

package/src/tools/execCommand.d.ts

@@ -1,22 +0,0 @@
-export type ExecCommandInput = {
-  command: string;
-  args?: string[];
-};
-
-export type ExecCommandConfig = {
-  sandbox?: ExecCommandSanboxConfig;
-};
-
-export type ExecCommandSanboxConfig = {
-  command: string;
-  args?: string[];
-  separator?: string;
-  rules?: {
-    pattern: {
-      command: string;
-      args?: string[];
-    };
-    mode: "sandbox" | "unsandboxed";
-    additionalArgs?: string[];
-  }[];
-};